# Copyright 2013 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Test cros_generate_breakpad_symbols."""

import ctypes
import io
import logging
import multiprocessing
import os
import pathlib
from unittest import mock

from chromite.lib import cros_test_lib
from chromite.lib import osutils
from chromite.lib import parallel_unittest
from chromite.lib import partial_mock
from chromite.scripts import cros_generate_breakpad_symbols


class FindDebugDirMock(partial_mock.PartialMock):
    """Mock out the DebugDir helper so we can point it to a tempdir."""

    TARGET = "chromite.scripts.cros_generate_breakpad_symbols"
    ATTRS = ("FindDebugDir",)
    DEFAULT_ATTR = "FindDebugDir"

    def __init__(self, path, *args, **kwargs) -> None:
        self.path = path
        super().__init__(*args, **kwargs)

    # pylint: disable=unused-argument
    def FindDebugDir(self, _board, sysroot=None):
        return self.path


class IsSharedLibraryTest(cros_test_lib.TestCase):
    """Test IsSharedLibrary"""

    def testSharedLibaries(self) -> None:
        """Verify that shared libraries return truthy"""
        shared_libraries = [
            "lib/libcontainer.so",
            "lib64/libnss_db.so.2",
            "usr/lib/libboost_type_erasure.so.1.81.0",
            "usr/lib/v4l1compat.so",
        ]

        for shared_library in shared_libraries:
            self.assertTrue(
                cros_generate_breakpad_symbols.IsSharedLibrary(shared_library),
                msg=f"expected {shared_library} to be a shared library",
            )

    def testExecutables(self) -> None:
        """Verify that executables return None"""
        executables = [
            "sbin/crash_reporter",
            "usr/bin/pqso",  # ends in so but not .so
            "usr/bin/perl5.36.0",  # ends in numbers but not .so
        ]

        for executable in executables:
            self.assertFalse(
                cros_generate_breakpad_symbols.IsSharedLibrary(executable),
                msg=f"expected {executable} to not be a shared library",
            )


# This long decorator triggers a false positive in the docstring test.
# https://github.com/PyCQA/pylint/issues/3077
# pylint: disable=bad-docstring-quotes
@mock.patch(
    "chromite.scripts.cros_generate_breakpad_symbols." "GenerateBreakpadSymbol"
)
class GenerateSymbolsTest(cros_test_lib.MockTempDirTestCase):
    """Test GenerateBreakpadSymbols."""

    def setUp(self) -> None:
        self.board = "monkey-board"
        self.board_dir = os.path.join(self.tempdir, "build", self.board)
        self.debug_dir = os.path.join(self.board_dir, "usr", "lib", "debug")
        self.breakpad_dir = os.path.join(self.debug_dir, "breakpad")

        # Generate a tree of files which we'll scan through.
        elf_files = [
            "bin/elf",
            "iii/large-elf",
            # Need some kernel modules (with & without matching .debug).
            "lib/modules/3.10/module.ko",
            "lib/modules/3.10/module-no-debug.ko",
            # Need a file which has an ELF only, but not a .debug.
            "usr/bin/elf-only",
            "usr/sbin/elf",
        ]
        debug_files = [
            "bin/bad-file",
            "bin/elf.debug",
            "iii/large-elf.debug",
            "boot/vmlinux.debug",
            "lib/modules/3.10/module.ko.debug",
            # Need a file which has a .debug only, but not an ELF.
            "sbin/debug-only.debug",
            "usr/sbin/elf.debug",
        ]
        for f in [os.path.join(self.board_dir, x) for x in elf_files] + [
            os.path.join(self.debug_dir, x) for x in debug_files
        ]:
            osutils.Touch(f, makedirs=True)

        # Set up random build dirs and symlinks.
        buildid = os.path.join(self.debug_dir, ".build-id", "00")
        osutils.SafeMakedirs(buildid)
        os.symlink("/asdf", os.path.join(buildid, "foo"))
        os.symlink("/bin/sh", os.path.join(buildid, "foo.debug"))
        os.symlink("/bin/sh", os.path.join(self.debug_dir, "file.debug"))
        osutils.WriteFile(
            os.path.join(self.debug_dir, "iii", "large-elf.debug"),
            "just some content",
        )

        self.StartPatcher(FindDebugDirMock(self.debug_dir))

    def markAllFilesAsProcessed(self, gen_mock) -> None:
        """Sets mock to pretend it processed all the expected ELF files.

        This avoids having GenerateBreakpadSymbols return an error because not
        all expected files were processed.
        """
        expected_found = list(cros_generate_breakpad_symbols.ALL_EXPECTED_FILES)

        def _SetFound(*_args, **kwargs):
            kwargs["found_files"].extend(expected_found)
            gen_mock.side_effect = None
            return 1

        gen_mock.side_effect = _SetFound

    def testNormal(self, gen_mock) -> None:
        """Verify all the files we expect to get generated do"""
        with parallel_unittest.ParallelMock():
            self.markAllFilesAsProcessed(gen_mock)
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board, sysroot=self.board_dir
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 5)

            # The largest ELF should be processed first.
            call1 = (
                os.path.join(self.board_dir, "iii/large-elf"),
                os.path.join(self.debug_dir, "iii/large-elf.debug"),
            )
            self.assertEqual(gen_mock.call_args_list[0][0], call1)

            # The other ELFs can be called in any order.
            call2 = (
                os.path.join(self.board_dir, "bin/elf"),
                os.path.join(self.debug_dir, "bin/elf.debug"),
            )
            call3 = (
                os.path.join(self.board_dir, "usr/sbin/elf"),
                os.path.join(self.debug_dir, "usr/sbin/elf.debug"),
            )
            call4 = (
                os.path.join(self.board_dir, "lib/modules/3.10/module.ko"),
                os.path.join(
                    self.debug_dir, "lib/modules/3.10/module.ko.debug"
                ),
            )
            call5 = (
                os.path.join(self.board_dir, "boot/vmlinux"),
                os.path.join(self.debug_dir, "boot/vmlinux.debug"),
            )
            exp_calls = set((call2, call3, call4, call5))
            actual_calls = set(
                (
                    gen_mock.call_args_list[1][0],
                    gen_mock.call_args_list[2][0],
                    gen_mock.call_args_list[3][0],
                    gen_mock.call_args_list[4][0],
                )
            )
            self.assertEqual(exp_calls, actual_calls)

    def testFileList(self, gen_mock) -> None:
        """Verify that file_list restricts the symbols generated"""
        with parallel_unittest.ParallelMock():
            # Don't need markAllFilesAsProcessed since using file_list will
            # skip the expected-files-processed check.
            call1 = (
                os.path.join(self.board_dir, "usr/sbin/elf"),
                os.path.join(self.debug_dir, "usr/sbin/elf.debug"),
            )

            # Filter with elf path.
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                breakpad_dir=self.breakpad_dir,
                file_list=[os.path.join(self.board_dir, "usr", "sbin", "elf")],
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 1)
            self.assertEqual(gen_mock.call_args_list[0][0], call1)

            # Filter with debug symbols file path.
            gen_mock.reset_mock()
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                breakpad_dir=self.breakpad_dir,
                file_list=[
                    os.path.join(self.debug_dir, "usr", "sbin", "elf.debug")
                ],
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 1)
            self.assertEqual(gen_mock.call_args_list[0][0], call1)

    def testGenLimit(self, gen_mock) -> None:
        """Verify generate_count arg works"""
        with parallel_unittest.ParallelMock():
            # Generate nothing!
            # Don't need markAllFilesAsProcessed since using generate_count will
            # skip the expected-files-processed check.
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                breakpad_dir=self.breakpad_dir,
                generate_count=0,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 0)

            # Generate just one.
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                breakpad_dir=self.breakpad_dir,
                generate_count=1,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 1)

            # The largest ELF should be processed first.
            call1 = (
                os.path.join(self.board_dir, "iii/large-elf"),
                os.path.join(self.debug_dir, "iii/large-elf.debug"),
            )
            self.assertEqual(gen_mock.call_args_list[0][0], call1)

    def testGenErrors(self, gen_mock) -> None:
        """Verify we handle errors from generation correctly"""

        def _SetError(*_args, **kwargs):
            kwargs["num_errors"].value += 1
            return 1

        gen_mock.side_effect = _SetError
        with parallel_unittest.ParallelMock():
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board, sysroot=self.board_dir
            )
            # Expect 5 errors from calls plus 1 from the
            # expected-files-processed check.
            self.assertEqual(ret, 6)
            self.assertEqual(gen_mock.call_count, 5)

    def testCleaningTrue(self, gen_mock) -> None:
        """Verify behavior of clean_breakpad=True"""
        with parallel_unittest.ParallelMock():
            self.markAllFilesAsProcessed(gen_mock)
            # Dir does not exist, and then does.
            self.assertNotExists(self.breakpad_dir)
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                generate_count=1,
                clean_breakpad=True,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 1)
            self.assertExists(self.breakpad_dir)

            # Dir exists before & after.
            # File exists, but then doesn't.
            stub_file = os.path.join(self.breakpad_dir, "fooooooooo")
            osutils.Touch(stub_file)
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                generate_count=1,
                clean_breakpad=True,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 2)
            self.assertNotExists(stub_file)

    def testCleaningFalse(self, gen_mock) -> None:
        """Verify behavior of clean_breakpad=False"""
        with parallel_unittest.ParallelMock():
            self.markAllFilesAsProcessed(gen_mock)
            # Dir does not exist, and then does.
            self.assertNotExists(self.breakpad_dir)
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                generate_count=1,
                clean_breakpad=False,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 1)
            self.assertExists(self.breakpad_dir)

            # Dir exists before & after.
            # File exists before & after.
            stub_file = os.path.join(self.breakpad_dir, "fooooooooo")
            osutils.Touch(stub_file)
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                generate_count=1,
                clean_breakpad=False,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 2)
            self.assertExists(stub_file)

    def testExclusionList(self, gen_mock) -> None:
        """Verify files in directories of the exclusion list are excluded"""
        exclude_dirs = ["bin", "usr", "fake/dir/fake"]
        with parallel_unittest.ParallelMock():
            self.markAllFilesAsProcessed(gen_mock)
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board, sysroot=self.board_dir, exclude_dirs=exclude_dirs
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 3)

    def testExpectedFilesCompleteFailure(self, _) -> None:
        """Verify if no files are processed, all expected files give errors"""
        with parallel_unittest.ParallelMock() and self.assertLogs(
            level=logging.WARNING
        ) as cm:
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board, sysroot=self.board_dir
            )
            self.assertEqual(ret, 1)
            self.assertIn(
                "Not all expected files were processed successfully",
                "\n".join(cm.output),
            )
            for output in cm.output:
                if (
                    "Not all expected files were processed successfully"
                    in output
                ):
                    # This is the line that lists all the files we didn't find.
                    for (
                        expected_file
                    ) in cros_generate_breakpad_symbols.ExpectedFiles:
                        self.assertIn(expected_file.name, output)

    def testExpectedFilesPartialFailure(self, gen_mock) -> None:
        """If some expected files are processed, the others give errors"""
        expected_found = (
            cros_generate_breakpad_symbols.ExpectedFiles.LIBC,
            cros_generate_breakpad_symbols.ExpectedFiles.CRASH_REPORTER,
        )

        def _SetFound(*_args, **kwargs):
            kwargs["found_files"].extend(expected_found)
            gen_mock.side_effect = None
            return 1

        gen_mock.side_effect = _SetFound
        with parallel_unittest.ParallelMock() and self.assertLogs(
            level=logging.WARNING
        ) as cm:
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board, sysroot=self.board_dir
            )
            self.assertEqual(ret, 1)
            self.assertIn(
                "Not all expected files were processed successfully",
                "\n".join(cm.output),
            )
            for output in cm.output:
                if (
                    "Not all expected files were processed successfully"
                    in output
                ):
                    # This is the line that lists all the files we didn't find.
                    for (
                        expected_file
                    ) in cros_generate_breakpad_symbols.ExpectedFiles:
                        if expected_file in expected_found:
                            self.assertNotIn(expected_file.name, output)
                        else:
                            self.assertIn(expected_file.name, output)

    def testExpectedFilesWithSomeIgnored(self, _) -> None:
        """If some expected files are ignored, they don't give errors"""
        ignore_expected_files = [
            cros_generate_breakpad_symbols.ExpectedFiles.ASH_CHROME,
            cros_generate_breakpad_symbols.ExpectedFiles.LIBC,
        ]
        with parallel_unittest.ParallelMock() and self.assertLogs(
            level=logging.WARNING
        ) as cm:
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                ignore_expected_files=ignore_expected_files,
            )
            self.assertEqual(ret, 1)
            self.assertIn(
                "Not all expected files were processed successfully",
                "\n".join(cm.output),
            )
            for output in cm.output:
                if (
                    "Not all expected files were processed successfully"
                    in output
                ):
                    # This is the line that lists all the files we didn't find.
                    for (
                        expected_file
                    ) in cros_generate_breakpad_symbols.ExpectedFiles:
                        if expected_file in ignore_expected_files:
                            self.assertNotIn(expected_file.name, output)
                        else:
                            self.assertIn(expected_file.name, output)

    def testExpectedFilesWithAllIgnored(self, _) -> None:
        """If all expected files are ignored, there is no error"""
        with parallel_unittest.ParallelMock() and self.assertLogs(
            level=logging.WARNING
        ) as cm:
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                ignore_expected_files=list(
                    cros_generate_breakpad_symbols.ExpectedFiles
                ),
            )
            self.assertEqual(ret, 0)
            self.assertNotIn(
                "Not all expected files were processed successfully",
                "\n".join(cm.output),
            )

    def testExpectedFilesWithSomeIgnoredAndSomeFound(self, gen_mock) -> None:
        """Some expected files are ignored, others processed => no error"""
        expected_found = (
            cros_generate_breakpad_symbols.ExpectedFiles.LIBC,
            cros_generate_breakpad_symbols.ExpectedFiles.CRASH_REPORTER,
        )

        def _SetFound(*_args, **kwargs):
            kwargs["found_files"].extend(expected_found)
            gen_mock.side_effect = None
            return 1

        gen_mock.side_effect = _SetFound
        with parallel_unittest.ParallelMock() and self.assertLogs(
            level=logging.WARNING
        ) as cm:
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                ignore_expected_files=[
                    cros_generate_breakpad_symbols.ExpectedFiles.ASH_CHROME,
                    cros_generate_breakpad_symbols.ExpectedFiles.LIBMETRICS,
                ],
            )
            self.assertEqual(ret, 0)
            self.assertNotIn(
                "Not all expected files were processed successfully",
                "\n".join(cm.output),
            )


class GenerateSymbolTest(cros_test_lib.RunCommandTempDirTestCase):
    """Test GenerateBreakpadSymbol."""

    _DUMP_SYMS_BASE_CMD = ["dump_syms", "-v", "-d", "-m"]

    def setUp(self) -> None:
        self.elf_file = os.path.join(self.tempdir, "elf")
        osutils.Touch(self.elf_file)
        self.debug_dir = os.path.join(self.tempdir, "debug")
        self.debug_file = os.path.join(self.debug_dir, "elf.debug")
        osutils.Touch(self.debug_file, makedirs=True)
        # Not needed as the code itself should create it as needed.
        self.breakpad_dir = os.path.join(self.debug_dir, "breakpad")

        self.FILE_OUT = (
            f"{self.elf_file}: ELF 64-bit LSB pie executable, x86-64, "
            "version 1 (SYSV), dynamically linked, interpreter "
            "/lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, "
            "BuildID[sha1]=cf9a21fa6b14bfb2dfcb76effd713c4536014d95, stripped"
        )
        # A symbol file which would pass validation.
        MINIMAL_SYMBOL_FILE = (
            "MODULE OS CPU ID NAME\n"
            "PUBLIC f10 0 func\n"
            "STACK CFI INIT f10 22 .cfa: $rsp 8 + .ra: .cfa -8 + ^\n"
        )
        self.rc.SetDefaultCmdResult(stdout=MINIMAL_SYMBOL_FILE)
        self.rc.AddCmdResult(
            ["/usr/bin/file", self.elf_file], stdout=self.FILE_OUT
        )
        self.assertCommandContains = self.rc.assertCommandContains
        self.sym_file = os.path.join(self.breakpad_dir, "NAME/ID/NAME.sym")

        self.StartPatcher(FindDebugDirMock(self.debug_dir))

    def assertCommandArgs(self, i, args) -> None:
        """Helper for looking at the args of the |i|th call"""
        self.assertEqual(self.rc.call_args_list[i][0][0], args)

    def testNormal(self) -> None:
        """Normal run -- given an ELF and a debug file"""
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            self.debug_file,
            self.breakpad_dir,
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(self.rc.call_count, 2)
        self.assertCommandArgs(
            1, self._DUMP_SYMS_BASE_CMD + [self.elf_file, self.debug_dir]
        )
        self.assertExists(self.sym_file)

    def testNormalNoCfi(self) -> None:
        """Normal run w/out CFI"""
        # Make sure the num_errors flag works too.
        num_errors = ctypes.c_int(0)
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            self.debug_file,
            breakpad_dir=self.breakpad_dir,
            strip_cfi=True,
            num_errors=num_errors,
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(num_errors.value, 0)
        self.assertCommandArgs(
            1, self._DUMP_SYMS_BASE_CMD + ["-c", self.elf_file, self.debug_dir]
        )
        self.assertEqual(self.rc.call_count, 2)
        self.assertExists(self.sym_file)

    def testNormalElfOnly(self) -> None:
        """Normal run with just an ELF will fail"""
        num_errors = ctypes.c_int(0)
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            breakpad_dir=self.breakpad_dir,
            num_errors=num_errors,
        )
        self.assertEqual(ret, 1)
        self.assertEqual(num_errors.value, 1)
        self.assertNotExists(self.sym_file)

    def testNormalSudo(self) -> None:
        """Normal run where ELF is readable only by root"""
        with mock.patch.object(os, "access") as mock_access:
            mock_access.return_value = False
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
                self.elf_file, self.debug_file, breakpad_dir=self.breakpad_dir
            )
        self.assertEqual(ret, self.sym_file)
        self.assertCommandArgs(
            1,
            ["sudo", "--"]
            + self._DUMP_SYMS_BASE_CMD
            + [self.elf_file, self.debug_dir],
        )

    def testDumpSymsFail(self) -> None:
        """The call to dump_syms failed"""
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + [self.elf_file, self.debug_dir],
            returncode=1,
        )
        num_errors = ctypes.c_int(0)
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            self.debug_file,
            breakpad_dir=self.breakpad_dir,
            num_errors=num_errors,
        )
        self.assertEqual(ret, 1)
        self.assertEqual(num_errors.value, 1)
        self.assertEqual(self.rc.call_count, 2)
        self.assertCommandArgs(
            1, self._DUMP_SYMS_BASE_CMD + [self.elf_file, self.debug_dir]
        )
        self.assertNotExists(self.sym_file)

    def testValidationFail(self) -> None:
        """If symbol file validation fails, return an error"""
        BAD_SYMBOL_FILE = "MODULE OS CPU ID NAME\n"
        self.rc.SetDefaultCmdResult(stdout=BAD_SYMBOL_FILE)
        num_errors = ctypes.c_int(0)
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            self.debug_file,
            breakpad_dir=self.breakpad_dir,
            strip_cfi=True,
            num_errors=num_errors,
        )
        self.assertEqual(ret, 1)
        self.assertEqual(num_errors.value, 1)
        self.assertNotExists(self.sym_file)

    def testValidationRaises(self) -> None:
        """If symbol file validation raises an error, return an error."""
        BAD_SYMBOL_FILE = (
            "MODULE Linux x86 D3096ED481217FD4C16B29CD9BC208BA0 elf\n"
            "JUNK LINE IS BAD LINE\n"
        )
        self.rc.SetDefaultCmdResult(stdout=BAD_SYMBOL_FILE)
        num_errors = ctypes.c_int(0)
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            self.debug_file,
            breakpad_dir=self.breakpad_dir,
            strip_cfi=True,
            num_errors=num_errors,
        )
        self.assertEqual(ret, 1)
        self.assertEqual(num_errors.value, 1)
        self.assertNotExists(self.sym_file)

    def testForceBasicFallback(self) -> None:
        """Running with force_basic_fallback

        Test force_basic_fallback goes straight to _DumpAllowingBasicFallback().
        """
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + [self.elf_file, self.debug_dir],
            returncode=1,
        )
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            self.debug_file,
            breakpad_dir=self.breakpad_dir,
            force_basic_fallback=True,
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(self.rc.call_count, 2)
        self.assertCommandArgs(
            0, self._DUMP_SYMS_BASE_CMD + [self.elf_file, self.debug_dir]
        )
        self.assertCommandArgs(
            1,
            self._DUMP_SYMS_BASE_CMD
            + ["-c", "-r", self.elf_file, self.debug_dir],
        )
        self.assertExists(self.sym_file)

    def testForceBasicFallbackElfOnly(self) -> None:
        """Running with force_basic_fallback run given just an ELF"""
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            breakpad_dir=self.breakpad_dir,
            force_basic_fallback=True,
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(self.rc.call_count, 1)
        self.assertCommandArgs(0, self._DUMP_SYMS_BASE_CMD + [self.elf_file])
        self.assertExists(self.sym_file)

    def testForceBasicFallbackLargeDebugFail(self) -> None:
        """In fallback mode, running w/large .debug failed, but retry worked"""
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + [self.elf_file, self.debug_dir],
            returncode=1,
        )
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            self.debug_file,
            breakpad_dir=self.breakpad_dir,
            force_basic_fallback=True,
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(self.rc.call_count, 2)
        self.assertCommandArgs(
            0, self._DUMP_SYMS_BASE_CMD + [self.elf_file, self.debug_dir]
        )
        self.assertCommandArgs(
            1,
            self._DUMP_SYMS_BASE_CMD
            + ["-c", "-r", self.elf_file, self.debug_dir],
        )
        self.assertExists(self.sym_file)

    def testForceBasicFallbackDebugFail(self) -> None:
        """In fallback mode, running w/.debug always fails, but works without"""
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + [self.elf_file, self.debug_dir],
            returncode=1,
        )
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD
            + ["-c", "-r", self.elf_file, self.debug_dir],
            returncode=1,
        )
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            self.debug_file,
            breakpad_dir=self.breakpad_dir,
            force_basic_fallback=True,
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(self.rc.call_count, 3)
        self.assertCommandArgs(
            0, self._DUMP_SYMS_BASE_CMD + [self.elf_file, self.debug_dir]
        )
        self.assertCommandArgs(
            1,
            self._DUMP_SYMS_BASE_CMD
            + ["-c", "-r", self.elf_file, self.debug_dir],
        )
        self.assertCommandArgs(2, self._DUMP_SYMS_BASE_CMD + [self.elf_file])
        self.assertExists(self.sym_file)

    def testForceBasicFallbackCompleteFail(self) -> None:
        """In fallback mode, if dump_syms always fails, still an error"""
        self.rc.SetDefaultCmdResult(returncode=1)
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            breakpad_dir=self.breakpad_dir,
            force_basic_fallback=True,
        )
        self.assertEqual(ret, 1)
        # Make sure the num_errors flag works too.
        num_errors = ctypes.c_int(0)
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file, breakpad_dir=self.breakpad_dir, num_errors=num_errors
        )
        self.assertEqual(ret, 1)
        self.assertEqual(num_errors.value, 1)

    def testKernelObjects(self) -> None:
        """Kernel object files should call _DumpAllowingBasicFallback()"""
        ko_file = os.path.join(self.tempdir, "elf.ko")
        osutils.Touch(ko_file)
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + [ko_file, self.debug_dir],
            returncode=1,
        )
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + ["-c", "-r", ko_file, self.debug_dir],
            returncode=1,
        )
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            ko_file, self.debug_file, self.breakpad_dir
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(self.rc.call_count, 3)
        self.assertCommandArgs(
            0, self._DUMP_SYMS_BASE_CMD + [ko_file, self.debug_dir]
        )
        self.assertCommandArgs(
            1,
            self._DUMP_SYMS_BASE_CMD + ["-c", "-r", ko_file, self.debug_dir],
        )
        self.assertCommandArgs(2, self._DUMP_SYMS_BASE_CMD + [ko_file])
        self.assertExists(self.sym_file)

    def testGoBinary(self) -> None:
        """Go binaries should call _DumpAllowingBasicFallback()

        Also tests that dump_syms failing with 'file contains no debugging
        information' does not fail the script.
        """
        go_binary = os.path.join(self.tempdir, "goprogram")
        osutils.Touch(go_binary)
        go_debug_file = os.path.join(self.debug_dir, "goprogram.debug")
        osutils.Touch(go_debug_file, makedirs=True)
        FILE_OUT_GO = go_binary + (
            ": ELF 64-bit LSB executable, x86-64, "
            "version 1 (SYSV), statically linked, "
            "Go BuildID=KKXVlL66E8Qmngr4qll9/5kOKGZw9I7TmNhoqKLqq/SiYVJam6w5Fo"
            "39B3BtDo/ba8_ceezZ-3R4qEv6_-K, not stripped"
        )
        self.rc.AddCmdResult(["/usr/bin/file", go_binary], stdout=FILE_OUT_GO)
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + [go_binary, self.debug_dir],
            returncode=1,
        )
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + ["-c", "-r", go_binary, self.debug_dir],
            returncode=1,
        )
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + [go_binary],
            returncode=1,
            stderr=(
                f"{go_binary}: file contains no debugging information "
                '(no ".stab" or ".debug_info" sections)'
            ),
        )
        num_errors = ctypes.c_int(0)
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            go_binary, go_debug_file, self.breakpad_dir
        )
        self.assertEqual(ret, 0)
        self.assertEqual(self.rc.call_count, 4)
        self.assertCommandArgs(0, ["/usr/bin/file", go_binary])
        self.assertCommandArgs(
            1, self._DUMP_SYMS_BASE_CMD + [go_binary, self.debug_dir]
        )
        self.assertCommandArgs(
            2,
            self._DUMP_SYMS_BASE_CMD + ["-c", "-r", go_binary, self.debug_dir],
        )
        self.assertCommandArgs(3, self._DUMP_SYMS_BASE_CMD + [go_binary])
        self.assertNotExists(self.sym_file)
        self.assertEqual(num_errors.value, 0)

    def _testBinaryIsInLocalFallback(self, directory, filename) -> None:
        binary = os.path.join(self.tempdir, directory, filename)
        osutils.Touch(binary, makedirs=True)
        debug_dir = os.path.join(self.debug_dir, directory)
        debug_file = os.path.join(debug_dir, f"{filename}.debug")
        osutils.Touch(debug_file, makedirs=True)
        self.rc.AddCmdResult(["/usr/bin/file", binary], stdout=self.FILE_OUT)
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + [binary, debug_dir], returncode=1
        )
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + ["-c", "-r", binary, debug_dir],
            returncode=1,
        )
        self.rc.AddCmdResult(
            self._DUMP_SYMS_BASE_CMD + [binary],
            returncode=1,
            stderr=(
                f"{binary}: file contains no debugging information "
                '(no ".stab" or ".debug_info" sections)'
            ),
        )
        num_errors = ctypes.c_int(0)
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            binary, debug_file, self.breakpad_dir, sysroot=self.tempdir
        )
        self.assertEqual(ret, 0)
        self.assertEqual(self.rc.call_count, 4)
        self.assertCommandArgs(0, ["/usr/bin/file", binary])
        self.assertCommandArgs(
            1, self._DUMP_SYMS_BASE_CMD + [binary, debug_dir]
        )
        self.assertCommandArgs(
            2, self._DUMP_SYMS_BASE_CMD + ["-c", "-r", binary, debug_dir]
        )
        self.assertCommandArgs(3, self._DUMP_SYMS_BASE_CMD + [binary])
        self.assertNotExists(self.sym_file)
        self.assertEqual(num_errors.value, 0)

    def testAllowlist(self) -> None:
        """Binaries in the allowlist should call _DumpAllowingBasicFallback()"""
        self._testBinaryIsInLocalFallback("usr/bin", "goldctl")

    def testUsrLocalSkip(self) -> None:
        """Binaries in /usr/local should call _DumpAllowingBasicFallback()"""
        self._testBinaryIsInLocalFallback("usr/local", "minidump_stackwalk")


class ValidateSymbolFileTest(cros_test_lib.TempDirTestCase):
    """Tests ValidateSymbolFile"""

    def _GetTestdataFile(self, filename: str) -> str:
        """Gets the path to a file in the testdata directory.

        Args:
            filename: The base filename of the file.

        Returns:
            A string with the complete path to the file.
        """
        return os.path.join(os.path.dirname(__file__), "testdata", filename)

    def testValidSymbolFiles(self) -> None:
        """Make sure ValidateSymbolFile passes on valid files"""

        # All files are in the testdata/ subdirectory.
        VALID_SYMBOL_FILES = [
            # A "normal" symbol file from an executable.
            "basic.sym",
            # A "normal" symbol file from a shared library.
            "basic_lib.sym",
            # A symbol file with PUBLIC records but no FUNC records.
            "public_only.sym",
            # A symbol file with FUNC records but no PUBLIC records.
            "func_only.sym",
            # A symbol file with at least one of every line type.
            "all_line_types.sym",
        ]

        for file in VALID_SYMBOL_FILES:
            with self.subTest(
                file=file
            ), multiprocessing.Manager() as mp_manager:
                found_files = mp_manager.list()
                self.assertTrue(
                    cros_generate_breakpad_symbols.ValidateSymbolFile(
                        self._GetTestdataFile(file),
                        "/build/board/bin/foo",
                        "/build/board",
                        found_files,
                    )
                )
                self.assertFalse(found_files)

    def testInvalidSymbolFiles(self) -> None:
        """Make sure ValidateSymbolFile fails on invalid files.

        This test only covers cases that return false, not cases that raise
        exceptions.
        """

        class InvalidSymbolFile:
            """The name of an invalid symbol file + the expected error msg."""

            def __init__(self, filename, expected_errors) -> None:
                self.filename = filename
                self.expected_errors = expected_errors

        INVALID_SYMBOL_FILES = [
            InvalidSymbolFile(
                "bad_no_func_or_public.sym",
                [
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has no FUNC or PUBLIC records"
                ],
            ),
            InvalidSymbolFile(
                "bad_no_stack.sym",
                [
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has no STACK records"
                ],
            ),
            InvalidSymbolFile(
                "bad_no_module.sym",
                [
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has 0 MODULE lines"
                ],
            ),
            InvalidSymbolFile(
                "bad_two_modules.sym",
                [
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has 2 MODULE lines"
                ],
            ),
            InvalidSymbolFile(
                "bad_func_no_line_numbers.sym",
                [
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has FUNC records but no line numbers"
                ],
            ),
            InvalidSymbolFile(
                "bad_line_numbers_no_file.sym",
                [
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has line number records but no FILE records"
                ],
            ),
            InvalidSymbolFile(
                "bad_inline_no_files.sym",
                [
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has INLINE records but no FILE records"
                ],
            ),
            InvalidSymbolFile(
                "bad_inline_no_origins.sym",
                [
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has INLINE records but no INLINE_ORIGIN "
                    "records"
                ],
            ),
            InvalidSymbolFile(
                "blank.sym",
                [
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has no STACK records",
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has 0 MODULE lines",
                    "WARNING:root:/build/board/bin/foo: "
                    "Symbol file has no FUNC or PUBLIC records",
                ],
            ),
        ]

        for file in INVALID_SYMBOL_FILES:
            with self.subTest(
                file=file.filename
            ), multiprocessing.Manager() as mp_manager:
                found_files = mp_manager.list()
                with self.assertLogs(level=logging.WARNING) as cm:
                    self.assertFalse(
                        cros_generate_breakpad_symbols.ValidateSymbolFile(
                            self._GetTestdataFile(file.filename),
                            "/build/board/bin/foo",
                            "/build/board",
                            found_files,
                        )
                    )
                self.assertEqual(file.expected_errors, cm.output)
                self.assertFalse(found_files)

    def testInvalidSymbolFilesWhichRaise(self) -> None:
        """Test ValidateSymbolFile raise exceptions on certain files"""

        class InvalidSymbolFile:
            """The invalid symbol file + the expected exception message"""

            def __init__(self, filename, expected_exception_regex) -> None:
                self.filename = filename
                self.expected_exception_regex = expected_exception_regex

        INVALID_SYMBOL_FILES = [
            InvalidSymbolFile(
                "bad_unknown_line_type.sym",
                r"symbol file has unknown line type UNKNOWN "
                r"\(line='UNKNOWN line type\n'\)",
            ),
            InvalidSymbolFile(
                "bad_blank_line.sym",
                "symbol file has unexpected blank line",
            ),
            InvalidSymbolFile(
                "bad_short_func.sym",
                r"symbol file has FUNC line with 2 words "
                r"\(expected 5 or more\) \(line='FUNC fb0\n'\)",
            ),
            InvalidSymbolFile(
                "bad_short_line_number.sym",
                r"symbol file has line number line with 3 words "
                r"\(expected 4 - 4\) \(line='fb0 106 0\n'\)",
            ),
            InvalidSymbolFile(
                "bad_long_line_number.sym",
                r"symbol file has line number line with 5 words "
                r"\(expected 4 - 4\) \(line='c184 7 59 4 8\n'\)",
            ),
        ]

        for file in INVALID_SYMBOL_FILES:
            with self.subTest(
                file=file.filename
            ), multiprocessing.Manager() as mp_manager:
                found_files = mp_manager.list()
                self.assertRaisesRegex(
                    ValueError,
                    file.expected_exception_regex,
                    cros_generate_breakpad_symbols.ValidateSymbolFile,
                    self._GetTestdataFile(file.filename),
                    "/build/board/bin/foo",
                    "/build/board",
                    found_files,
                )

    def testAllowlist(self) -> None:
        """Test that ELFs on the allowlist are allowed to pass."""
        with multiprocessing.Manager() as mp_manager:
            found_files = mp_manager.list()
            self.assertTrue(
                cros_generate_breakpad_symbols.ValidateSymbolFile(
                    self._GetTestdataFile("bad_no_module.sym"),
                    "/build/board/opt/google/chrome/nacl_helper_bootstrap",
                    "/build/board",
                    found_files,
                )
            )
            self.assertFalse(found_files)

    def testAllowlistRegex(self) -> None:
        """Test that ELFs on the regex-based allowlist are allowed to pass."""
        with multiprocessing.Manager() as mp_manager:
            found_files = mp_manager.list()
            self.assertTrue(
                cros_generate_breakpad_symbols.ValidateSymbolFile(
                    self._GetTestdataFile("bad_no_module.sym"),
                    "/build/board/lib64/libnss_dns.so.2",
                    "/build/board",
                    found_files,
                )
            )
            self.assertFalse(found_files)

    def testSharedLibrariesSkipStackTest(self) -> None:
        """Test that shared libraries can pass validation with no STACK."""
        with multiprocessing.Manager() as mp_manager:
            found_files = mp_manager.list()
            self.assertTrue(
                cros_generate_breakpad_symbols.ValidateSymbolFile(
                    self._GetTestdataFile("bad_no_stack.sym"),
                    "/build/board/lib64/libiw.so.30",
                    "/build/board",
                    found_files,
                )
            )
            self.assertFalse(found_files)

    def _CreateSymbolFile(
        self,
        sym_file: pathlib.Path,
        func_lines: int = 0,
        public_lines: int = 0,
        stack_lines: int = 0,
        line_number_lines: int = 0,
    ) -> None:
        """Creates a symbol file.

        Creates a symbol file with the given number of lines (and enough other
        lines to pass validation) in the temp directory.

        To pass validation, chrome.sym files must be huge; create them
        programmatically during the test instead of checking in a real 800MB+
        chrome symbol file.
        """
        with sym_file.open(mode="w", encoding="utf-8") as f:
            f.write("MODULE OS CPU ID NAME\n")
            f.write("FILE 0 /path/to/source.cc\n")
            for func in range(0, func_lines):
                f.write(f"FUNC {func} 1 0 function{func}\n")
            for public in range(0, public_lines):
                f.write(f"PUBLIC {public} 0 Public{public}\n")
            for line in range(0, line_number_lines):
                f.write(f"{line} 1 {line} 0\n")
            for stack in range(0, stack_lines):
                f.write(f"STACK CFI {stack} .cfa: $esp {stack} +\n")

    def testValidChromeSymbolFile(self) -> None:
        """Test that a chrome symbol file can pass the additional checks"""
        sym_file = self.tempdir / "chrome.sym"
        self._CreateSymbolFile(
            sym_file,
            func_lines=100000,
            public_lines=10,
            stack_lines=1000000,
            line_number_lines=1000000,
        )
        with multiprocessing.Manager() as mp_manager:
            found_files = mp_manager.list()
            self.assertTrue(
                cros_generate_breakpad_symbols.ValidateSymbolFile(
                    str(sym_file),
                    "/build/board/opt/google/chrome/chrome",
                    "/build/board",
                    found_files,
                )
            )
            self.assertEqual(
                list(found_files),
                [cros_generate_breakpad_symbols.ExpectedFiles.ASH_CHROME],
            )

    def testInvalidChromeSymbolFile(self) -> None:
        """Test that a chrome symbol file is held to higher standards."""

        class ChromeSymbolFileTest:
            """Defines the subtest for an invalid Chrome symbol file."""

            def __init__(
                self,
                name,
                expected_error,
                func_lines=100000,
                stack_lines=1000000,
                line_number_lines=1000000,
            ) -> None:
                self.name = name
                self.expected_error = expected_error
                self.func_lines = func_lines
                self.stack_lines = stack_lines
                self.line_number_lines = line_number_lines

        CHROME_SYMBOL_TESTS = [
            ChromeSymbolFileTest(
                name="Insufficient FUNC records",
                func_lines=10000,
                expected_error="chrome should have at least 100,000 FUNC "
                "records, found 10000",
            ),
            ChromeSymbolFileTest(
                name="Insufficient STACK records",
                stack_lines=100000,
                expected_error="chrome should have at least 1,000,000 STACK "
                "records, found 100000",
            ),
            ChromeSymbolFileTest(
                name="Insufficient line number records",
                line_number_lines=100000,
                expected_error="chrome should have at least 1,000,000 "
                "line number records, found 100000",
            ),
        ]
        for test in CHROME_SYMBOL_TESTS:
            with self.subTest(
                name=test.name
            ), multiprocessing.Manager() as mp_manager:
                sym_file = self.tempdir / "chrome.sym"
                self._CreateSymbolFile(
                    sym_file,
                    func_lines=test.func_lines,
                    public_lines=10,
                    stack_lines=test.stack_lines,
                    line_number_lines=test.line_number_lines,
                )
                found_files = mp_manager.list()
                with self.assertLogs(level=logging.WARNING) as cm:
                    self.assertFalse(
                        cros_generate_breakpad_symbols.ValidateSymbolFile(
                            str(sym_file),
                            "/build/board/opt/google/chrome/chrome",
                            "/build/board",
                            found_files,
                        )
                    )
                self.assertIn(test.expected_error, cm.output[0])
                self.assertEqual(len(cm.output), 1)

    def testValidLibcSymbolFile(self) -> None:
        """Test that a libc.so symbol file can pass the additional checks."""
        with multiprocessing.Manager() as mp_manager:
            sym_file = self.tempdir / "libc.so.sym"
            self._CreateSymbolFile(
                sym_file, public_lines=200, stack_lines=20000
            )
            found_files = mp_manager.list()
            self.assertTrue(
                cros_generate_breakpad_symbols.ValidateSymbolFile(
                    str(sym_file),
                    "/build/board/lib64/libc.so.6",
                    "/build/board",
                    found_files,
                )
            )
            self.assertEqual(
                list(found_files),
                [cros_generate_breakpad_symbols.ExpectedFiles.LIBC],
            )

    def testInvalidLibcSymbolFile(self) -> None:
        """Test that a libc.so symbol file is held to higher standards."""

        class LibcSymbolFileTest:
            """Defines the subtest for an invalid libc symbol file."""

            def __init__(
                self,
                name,
                expected_error,
                public_lines=200,
                stack_lines=20000,
            ) -> None:
                self.name = name
                self.expected_error = expected_error
                self.public_lines = public_lines
                self.stack_lines = stack_lines

        LIBC_SYMBOL_TESTS = [
            LibcSymbolFileTest(
                name="Insufficient PUBLIC records",
                public_lines=50,
                expected_error="/build/board/lib64/libc.so.6 should have at "
                "least 100 PUBLIC records, found 50",
            ),
            LibcSymbolFileTest(
                name="Insufficient STACK records",
                stack_lines=1000,
                expected_error="/build/board/lib64/libc.so.6 should have at "
                "least 10000 STACK records, found 1000",
            ),
        ]
        for test in LIBC_SYMBOL_TESTS:
            with self.subTest(
                name=test.name
            ), multiprocessing.Manager() as mp_manager:
                sym_file = self.tempdir / "libc.so.sym"
                self._CreateSymbolFile(
                    sym_file,
                    public_lines=test.public_lines,
                    stack_lines=test.stack_lines,
                )
                found_files = mp_manager.list()
                with self.assertLogs(level=logging.WARNING) as cm:
                    self.assertFalse(
                        cros_generate_breakpad_symbols.ValidateSymbolFile(
                            str(sym_file),
                            "/build/board/lib64/libc.so.6",
                            "/build/board",
                            found_files,
                        )
                    )
                self.assertIn(test.expected_error, cm.output[0])
                self.assertEqual(len(cm.output), 1)

    def testValidCrashReporterSymbolFile(self) -> None:
        """Test a crash_reporter symbol file can pass the additional checks."""
        with multiprocessing.Manager() as mp_manager:
            sym_file = self.tempdir / "crash_reporter.sym"
            self._CreateSymbolFile(
                sym_file,
                func_lines=2000,
                public_lines=10,
                stack_lines=2000,
                line_number_lines=20000,
            )
            found_files = mp_manager.list()
            self.assertTrue(
                cros_generate_breakpad_symbols.ValidateSymbolFile(
                    str(sym_file),
                    "/build/board/sbin/crash_reporter",
                    "/build/board",
                    found_files,
                )
            )
            self.assertEqual(
                list(found_files),
                [cros_generate_breakpad_symbols.ExpectedFiles.CRASH_REPORTER],
            )

    def testInvalidCrashReporterSymbolFile(self) -> None:
        """Test that a crash_reporter symbol file is held to higher standards"""

        class CrashReporterSymbolFileTest:
            """Defines the subtest for an invalid crash_reporter symbol file."""

            def __init__(
                self,
                name,
                expected_error,
                func_lines=2000,
                stack_lines=2000,
                line_number_lines=20000,
            ) -> None:
                self.name = name
                self.expected_error = expected_error
                self.func_lines = func_lines
                self.stack_lines = stack_lines
                self.line_number_lines = line_number_lines

        CRASH_REPORTER_SYMBOL_TESTS = [
            CrashReporterSymbolFileTest(
                name="Insufficient FUNC records",
                func_lines=500,
                expected_error="crash_reporter should have at least 1000 FUNC "
                "records, found 500",
            ),
            CrashReporterSymbolFileTest(
                name="Insufficient STACK records",
                stack_lines=100,
                expected_error="crash_reporter should have at least 1000 STACK "
                "records, found 100",
            ),
            CrashReporterSymbolFileTest(
                name="Insufficient line number records",
                line_number_lines=2000,
                expected_error="crash_reporter should have at least 10,000 "
                "line number records, found 2000",
            ),
        ]
        for test in CRASH_REPORTER_SYMBOL_TESTS:
            with self.subTest(
                name=test.name
            ), multiprocessing.Manager() as mp_manager:
                sym_file = self.tempdir / "crash_reporter.sym"
                self._CreateSymbolFile(
                    sym_file,
                    func_lines=test.func_lines,
                    stack_lines=test.stack_lines,
                    line_number_lines=test.line_number_lines,
                )
                found_files = mp_manager.list()
                with self.assertLogs(level=logging.WARNING) as cm:
                    self.assertFalse(
                        cros_generate_breakpad_symbols.ValidateSymbolFile(
                            str(sym_file),
                            "/build/board/sbin/crash_reporter",
                            "/build/board",
                            found_files,
                        )
                    )
                self.assertIn(test.expected_error, cm.output[0])
                self.assertEqual(len(cm.output), 1)

    def testValidLibMetricsSymbolFile(self) -> None:
        """Test a libmetrics.so symbol file can pass the additional checks."""
        with multiprocessing.Manager() as mp_manager:
            sym_file = self.tempdir / "libmetrics.so.sym"
            self._CreateSymbolFile(
                sym_file,
                func_lines=200,
                public_lines=2,
                stack_lines=2000,
                line_number_lines=10000,
            )
            found_files = mp_manager.list()
            self.assertTrue(
                cros_generate_breakpad_symbols.ValidateSymbolFile(
                    str(sym_file),
                    "/build/board/usr/lib64/libmetrics.so",
                    "/build/board",
                    found_files,
                )
            )
            self.assertEqual(
                list(found_files),
                [cros_generate_breakpad_symbols.ExpectedFiles.LIBMETRICS],
            )

    def testInvalidLibMetricsSymbolFile(self) -> None:
        """Test that a libmetrics.so symbol file is held to higher standards."""

        class LibMetricsSymbolFileTest:
            """Defines the subtest for an invalid libmetrics.so symbol file."""

            def __init__(
                self,
                name,
                expected_error,
                func_lines=200,
                public_lines=2,
                stack_lines=2000,
                line_number_lines=10000,
            ) -> None:
                self.name = name
                self.expected_error = expected_error
                self.func_lines = func_lines
                self.public_lines = public_lines
                self.stack_lines = stack_lines
                self.line_number_lines = line_number_lines

        LIBMETRICS_SYMBOL_TESTS = [
            LibMetricsSymbolFileTest(
                name="Insufficient FUNC records",
                func_lines=10,
                expected_error="libmetrics should have at least 100 FUNC "
                "records, found 10",
            ),
            LibMetricsSymbolFileTest(
                name="Insufficient PUBLIC records",
                public_lines=0,
                expected_error="libmetrics should have at least 1 PUBLIC "
                "record, found 0",
            ),
            LibMetricsSymbolFileTest(
                name="Insufficient STACK records",
                stack_lines=500,
                expected_error="libmetrics should have at least 1000 STACK "
                "records, found 500",
            ),
            LibMetricsSymbolFileTest(
                name="Insufficient line number records",
                line_number_lines=2000,
                expected_error="libmetrics should have at least 5000 "
                "line number records, found 2000",
            ),
        ]
        for test in LIBMETRICS_SYMBOL_TESTS:
            with self.subTest(
                name=test.name
            ), multiprocessing.Manager() as mp_manager:
                sym_file = self.tempdir / "libmetrics.so.sym"
                self._CreateSymbolFile(
                    sym_file,
                    func_lines=test.func_lines,
                    public_lines=test.public_lines,
                    stack_lines=test.stack_lines,
                    line_number_lines=test.line_number_lines,
                )
                found_files = mp_manager.list()
                with self.assertLogs(level=logging.WARNING) as cm:
                    self.assertFalse(
                        cros_generate_breakpad_symbols.ValidateSymbolFile(
                            str(sym_file),
                            "/build/board/usr/lib64/libmetrics.so",
                            "/build/board",
                            found_files,
                        )
                    )
                self.assertIn(test.expected_error, cm.output[0])
                self.assertEqual(len(cm.output), 1)


class UtilsTestDir(cros_test_lib.TempDirTestCase):
    """Tests ReadSymsHeader."""

    def testReadSymsHeaderGoodFile(self) -> None:
        """Make sure ReadSymsHeader can parse sym files"""
        sym_file = os.path.join(self.tempdir, "sym")
        osutils.WriteFile(sym_file, "MODULE Linux x86 s0m31D chrooome")
        result = cros_generate_breakpad_symbols.ReadSymsHeader(
            sym_file, "unused_elfname"
        )
        self.assertEqual(result.cpu, "x86")
        self.assertEqual(result.id, "s0m31D")
        self.assertEqual(result.name, "chrooome")
        self.assertEqual(result.os, "Linux")


class UtilsTest(cros_test_lib.TestCase):
    """Tests ReadSymsHeader."""

    def testReadSymsHeaderGoodBuffer(self) -> None:
        """Make sure ReadSymsHeader can parse sym file handles"""
        result = cros_generate_breakpad_symbols.ReadSymsHeader(
            io.BytesIO(b"MODULE Linux arm MY-ID-HERE blkid"), "unused_elfname"
        )
        self.assertEqual(result.cpu, "arm")
        self.assertEqual(result.id, "MY-ID-HERE")
        self.assertEqual(result.name, "blkid")
        self.assertEqual(result.os, "Linux")

    def testReadSymsHeaderBadd(self) -> None:
        """Make sure ReadSymsHeader throws on bad sym files"""
        self.assertRaises(
            ValueError,
            cros_generate_breakpad_symbols.ReadSymsHeader,
            io.BytesIO(b"asdf"),
            "unused_elfname",
        )

    def testBreakpadDir(self) -> None:
        """Make sure board->breakpad path expansion works"""
        expected = "/build/blah/usr/lib/debug/breakpad"
        result = cros_generate_breakpad_symbols.FindBreakpadDir("blah")
        self.assertEqual(expected, result)

    def testDebugDir(self) -> None:
        """Make sure board->debug path expansion works"""
        expected = "/build/blah/usr/lib/debug"
        result = cros_generate_breakpad_symbols.FindDebugDir("blah")
        self.assertEqual(expected, result)