xref: /aosp_15_r20/external/toolchain-utils/llvm_tools/patch_utils_unittest.py (revision 760c253c1ed00ce9abd48f8546f08516e57485fe)

#!/usr/bin/env python3
# Copyright 2022 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Unit tests for the patch_utils.py file."""

import copy
import io
import json
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
from unittest import mock

import patch_utils as pu


class TestPatchUtils(unittest.TestCase):
    """Test the patch_utils."""

    def make_tempdir(self) -> Path:
        tmpdir = Path(tempfile.mkdtemp(prefix="patch_utils_unittest"))
        self.addCleanup(shutil.rmtree, tmpdir)
        return tmpdir

    def test_predict_indent(self):
        test_str1 = """
a
  a
      a
  a
a
"""
        self.assertEqual(pu.predict_indent(test_str1.splitlines()), 2)
        test_str2 = """
a
    a
        a
    a
a
"""
        self.assertEqual(pu.predict_indent(test_str2.splitlines()), 4)

    def test_from_to_dict(self):
        """Test to and from dict conversion."""
        d = TestPatchUtils._default_json_dict()
        d["metadata"] = {
            "title": "hello world",
            "info": [],
            "other_extra_info": {
                "extra_flags": [],
            },
        }
        e = pu.PatchEntry.from_dict(TestPatchUtils._mock_dir(), d)
        self.assertEqual(d, e.to_dict())

        # Test that they aren't serialised the same, as 'd' isn't sorted.
        self.assertNotEqual(
            json.dumps(d["metadata"]), json.dumps(e.to_dict()["metadata"])
        )
        self.assertEqual(
            ["info", "other_extra_info", "title"],
            list(e.to_dict()["metadata"].keys()),
        )

    def test_patch_path(self):
        """Test that we can get the full path from a PatchEntry."""
        d = TestPatchUtils._default_json_dict()
        with mock.patch.object(Path, "is_dir", return_value=True):
            entry = pu.PatchEntry.from_dict(Path("/home/dir"), d)
            self.assertEqual(
                entry.patch_path(), Path("/home/dir") / d["rel_patch_path"]
            )

    def test_can_patch_version(self):
        """Test that patch application based on version is correct."""
        base_dict = TestPatchUtils._default_json_dict()
        workdir = TestPatchUtils._mock_dir()
        e1 = pu.PatchEntry.from_dict(workdir, base_dict)
        self.assertFalse(e1.can_patch_version(3))
        self.assertTrue(e1.can_patch_version(4))
        self.assertTrue(e1.can_patch_version(5))
        self.assertFalse(e1.can_patch_version(9))
        base_dict["version_range"] = {"until": 9}
        e2 = pu.PatchEntry.from_dict(workdir, base_dict)
        self.assertTrue(e2.can_patch_version(0))
        self.assertTrue(e2.can_patch_version(5))
        self.assertFalse(e2.can_patch_version(9))
        base_dict["version_range"] = {"from": 4}
        e3 = pu.PatchEntry.from_dict(workdir, base_dict)
        self.assertFalse(e3.can_patch_version(3))
        self.assertTrue(e3.can_patch_version(5))
        self.assertTrue(e3.can_patch_version(1 << 31))
        base_dict["version_range"] = {"from": 4, "until": None}
        e4 = pu.PatchEntry.from_dict(workdir, base_dict)
        self.assertFalse(e4.can_patch_version(3))
        self.assertTrue(e4.can_patch_version(5))
        self.assertTrue(e4.can_patch_version(1 << 31))
        base_dict["version_range"] = {"from": None, "until": 9}
        e5 = pu.PatchEntry.from_dict(workdir, base_dict)
        self.assertTrue(e5.can_patch_version(0))
        self.assertTrue(e5.can_patch_version(5))
        self.assertFalse(e5.can_patch_version(9))

    def test_can_parse_from_json(self):
        """Test that patches be loaded from json."""
        patches_json = """
[
  {
    "metadata": {},
    "platforms": [],
    "rel_patch_path": "cherry/nowhere.patch",
    "version_range": {}
  },
  {
    "metadata": {},
    "rel_patch_path": "cherry/somewhere.patch",
    "version_range": {}
  },
  {
    "rel_patch_path": "where.patch",
    "version_range": null
  },
  {
    "rel_patch_path": "cherry/anywhere.patch"
  }
]
    """
        result = pu.json_str_to_patch_entries(Path(), patches_json)
        self.assertEqual(len(result), 4)

        result = pu.json_to_patch_entries(Path(), io.StringIO(patches_json))
        self.assertEqual(len(result), 4)

    def test_parsed_hunks(self):
        """Test that we can parse patch file hunks."""
        m = mock.mock_open(read_data=_EXAMPLE_PATCH)

        def mocked_open(self, *args, **kwargs):
            return m(self, *args, **kwargs)

        with mock.patch.object(Path, "open", mocked_open):
            e = pu.PatchEntry.from_dict(
                TestPatchUtils._mock_dir(), TestPatchUtils._default_json_dict()
            )
            hunk_dict = e.parsed_hunks()

        m.assert_called()
        filename1 = "clang/lib/Driver/ToolChains/Clang.cpp"
        filename2 = "llvm/lib/Passes/PassBuilder.cpp"
        self.assertEqual(set(hunk_dict.keys()), {filename1, filename2})
        hunk_list1 = hunk_dict[filename1]
        hunk_list2 = hunk_dict[filename2]
        self.assertEqual(len(hunk_list1), 1)
        self.assertEqual(len(hunk_list2), 2)

    def test_apply_when_patch_nonexistent(self):
        """Test that we error out when we try to apply a non-existent patch."""
        src_dir = TestPatchUtils._mock_dir("somewhere/llvm-project")
        patch_dir = TestPatchUtils._mock_dir()
        e = pu.PatchEntry.from_dict(
            patch_dir, TestPatchUtils._default_json_dict()
        )
        with mock.patch("subprocess.run", mock.MagicMock()):
            self.assertRaises(RuntimeError, lambda: e.apply(src_dir))

    def test_apply_success(self):
        """Test that we can call apply."""
        src_dir = TestPatchUtils._mock_dir("somewhere/llvm-project")
        patch_dir = TestPatchUtils._mock_dir()
        e = pu.PatchEntry.from_dict(
            patch_dir, TestPatchUtils._default_json_dict()
        )

        # Make a deepcopy of the case for testing commit patch option.
        e1 = copy.deepcopy(e)

        with mock.patch("pathlib.Path.is_file", return_value=True):
            with mock.patch("subprocess.run", mock.MagicMock()):
                result = e.apply(src_dir)
        self.assertTrue(result.succeeded)

        # Test that commit patch option works.
        with mock.patch("pathlib.Path.is_file", return_value=True):
            with mock.patch("subprocess.run", mock.MagicMock()):
                result1 = e1.apply(src_dir, pu.git_am)
        self.assertTrue(result1.succeeded)

    def test_parse_failed_patch_output(self):
        """Test that we can call parse `patch` output."""
        fixture = """
checking file a/b/c.cpp
Hunk #1 SUCCEEDED at 96 with fuzz 1.
Hunk #12 FAILED at 77.
Hunk #42 FAILED at 1979.
checking file x/y/z.h
Hunk #4 FAILED at 30.
checking file works.cpp
Hunk #1 SUCCEEDED at 96 with fuzz 1.
"""
        result = pu.parse_failed_patch_output(fixture)
        self.assertEqual(result["a/b/c.cpp"], [12, 42])
        self.assertEqual(result["x/y/z.h"], [4])
        self.assertNotIn("works.cpp", result)

    def test_is_git_dirty(self):
        """Test if a git directory has uncommitted changes."""
        dirpath = self.make_tempdir()

        def _run_h(cmd):
            subprocess.run(
                cmd,
                cwd=dirpath,
                stdout=subprocess.DEVNULL,
                stderr=subprocess.DEVNULL,
                check=True,
            )

        _run_h(["git", "init"])
        self.assertFalse(pu.is_git_dirty(dirpath))
        test_file = dirpath / "test_file"
        test_file.touch()
        self.assertTrue(pu.is_git_dirty(dirpath))
        _run_h(["git", "add", "."])
        _run_h(["git", "commit", "-m", "test"])
        self.assertFalse(pu.is_git_dirty(dirpath))
        test_file.touch()
        self.assertFalse(pu.is_git_dirty(dirpath))
        with test_file.open("w", encoding="utf-8"):
            test_file.write_text("abc")
        self.assertTrue(pu.is_git_dirty(dirpath))

    @mock.patch("patch_utils.git_clean_context", mock.MagicMock)
    def test_update_version_ranges(self):
        """Test the UpdateVersionRanges function."""
        dirpath = self.make_tempdir()
        patches = [
            pu.PatchEntry(
                workdir=dirpath,
                rel_patch_path="x.patch",
                metadata=None,
                platforms=None,
                version_range={
                    "from": 0,
                    "until": 2,
                },
            ),
            pu.PatchEntry(
                workdir=dirpath,
                rel_patch_path="y.patch",
                metadata=None,
                platforms=None,
                version_range={
                    "from": 0,
                    "until": 2,
                },
            ),
            pu.PatchEntry(
                workdir=dirpath,
                rel_patch_path="z.patch",
                metadata=None,
                platforms=None,
                version_range={
                    "from": 4,
                    "until": 5,
                },
            ),
        ]

        patches[0].apply = mock.MagicMock(
            return_value=pu.PatchResult(
                succeeded=False, failed_hunks={"a/b/c": []}
            )
        )
        patches[1].apply = mock.MagicMock(
            return_value=pu.PatchResult(succeeded=True)
        )
        patches[2].apply = mock.MagicMock(
            return_value=pu.PatchResult(succeeded=False)
        )

        # Make a deepcopy of patches to test commit patch option
        patches2 = copy.deepcopy(patches)

        results, _ = pu.update_version_ranges_with_entries(
            1, dirpath, patches, pu.gnu_patch
        )

        # We should only have updated the version_range of the first patch,
        # as that one failed to apply.
        self.assertEqual(len(results), 1)
        self.assertEqual(results[0].version_range, {"from": 0, "until": 1})
        self.assertEqual(patches[0].version_range, {"from": 0, "until": 1})
        self.assertEqual(patches[1].version_range, {"from": 0, "until": 2})
        self.assertEqual(patches[2].version_range, {"from": 4, "until": 5})

        # Test git am option
        results2, _ = pu.update_version_ranges_with_entries(
            1, dirpath, patches2, pu.git_am
        )

        # We should only have updated the version_range of the first patch
        # via git am, as that one failed to apply.
        self.assertEqual(len(results2), 1)
        self.assertEqual(results2[0].version_range, {"from": 0, "until": 1})
        self.assertEqual(patches2[0].version_range, {"from": 0, "until": 1})
        self.assertEqual(patches2[1].version_range, {"from": 0, "until": 2})
        self.assertEqual(patches2[2].version_range, {"from": 4, "until": 5})

    def test_remove_old_patches(self):
        patches = [
            {"rel_patch_path": "foo.patch"},
            {
                "rel_patch_path": "bar.patch",
                "version_range": {
                    "from": 1,
                },
            },
            {
                "rel_patch_path": "baz.patch",
                "version_range": {
                    "until": 1,
                },
            },
        ]

        tempdir = self.make_tempdir()
        patches_json = tempdir / "PATCHES.json"
        with patches_json.open("w", encoding="utf-8") as f:
            json.dump(patches, f)

        removed_paths = pu.remove_old_patches(
            svn_version=10, patches_json=patches_json
        )
        self.assertEqual(removed_paths, [tempdir / "baz.patch"])
        expected_patches = [
            x for x in patches if x["rel_patch_path"] != "baz.patch"
        ]
        self.assertEqual(
            json.loads(patches_json.read_text(encoding="utf-8")),
            expected_patches,
        )

    @staticmethod
    def _default_json_dict():
        return {
            "metadata": {
                "title": "hello world",
            },
            "platforms": ["a"],
            "rel_patch_path": "x/y/z",
            "version_range": {
                "from": 4,
                "until": 9,
            },
        }

    @staticmethod
    def _mock_dir(path: str = "a/b/c"):
        workdir = Path(path)
        workdir = mock.MagicMock(workdir)
        workdir.is_dir = lambda: True
        workdir.joinpath = lambda x: Path(path).joinpath(x)
        workdir.__truediv__ = lambda self, x: self.joinpath(x)
        return workdir


_EXAMPLE_PATCH = """
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index 5620a543438..099eb769ca5 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -3995,8 +3995,11 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
       Args.hasArg(options::OPT_dA))
     CmdArgs.push_back("-masm-verbose");

-  if (!TC.useIntegratedAs())
+  if (!TC.useIntegratedAs()) {
     CmdArgs.push_back("-no-integrated-as");
+    CmdArgs.push_back("-mllvm");
+    CmdArgs.push_back("-enable-call-graph-profile-sort=false");
+  }

   if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
     CmdArgs.push_back("-mdebug-pass");
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index c5fd68299eb..4c6e15eeeb9 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -212,6 +212,10 @@ static cl::opt<bool>
     EnableCHR("enable-chr-npm", cl::init(true), cl::Hidden,
               cl::desc("Enable control height reduction optimization (CHR)"));

+static cl::opt<bool> EnableCallGraphProfileSort(
+    "enable-call-graph-profile-sort", cl::init(true), cl::Hidden,
+    cl::desc("Enable call graph profile pass for the new PM (default = on)"));
+
 extern cl::opt<bool> EnableHotColdSplit;
 extern cl::opt<bool> EnableOrderFileInstrumentation;

@@ -939,7 +943,8 @@ ModulePassManager PassBuilder::buildModuleOptimizationPipeline(
   // Add the core optimizing pipeline.
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(OptimizePM)));

-  MPM.addPass(CGProfilePass());
+  if (EnableCallGraphProfileSort)
+    MPM.addPass(CGProfilePass());

   // Now we need to do some global optimization transforms.
   // FIXME: It would seem like these should come first in the optimization
"""

if __name__ == "__main__":
    unittest.main()