#!/usr/bin/env fuchsia-vendored-python
# Copyright 2025 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import json
import os
import struct
import subprocess
import sys
import tempfile
import typing as T
import unittest
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))
from debug_symbols import (
    CommandPool,
    DebugSymbolExporter,
    DebugSymbolsManifestParser,
    extract_gnu_build_id,
)


def write_json(path: Path, content: T.Any) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("wt") as f:
        json.dump(content, f)


def generate_elf_with_build_id(build_id: bytes) -> bytes:
    """Generate a tiny ELF64 file that only contains a GNU .build-id note

    Args:
        build_id: The .build-id value as a bytes array.
    Returns:
        Content of the ELF file as a bytes array.
    """
    # This works in two passes. In the first pass, no data is generated, but write
    # positions are computed based on formatted ELF structures being appended,
    # the non-format values passed to add_struct() being ignored. This allows
    # computing all important offsets.
    #
    # On the second pass, the struct bytes are actually written to the output
    # and include the proper offset values computed in the first pass.

    def roundup8(value: int) -> int:
        return (value + 7) & -8

    class Writer(object):
        def __init__(self, enable_output: bool) -> None:
            self.offset = 0
            self.output = b""
            self.enable_output = enable_output

        def add_bytes(self, b: bytes) -> int:
            """Append a slice of bytes, then pad with zeroes for 8 alignment."""
            write_size = len(b)
            if self.enable_output:
                self.output += b
                padding = -write_size & 7
                self.output += b"\0" * padding
            self.offset = roundup8(self.offset + write_size)
            return write_size

        def add_struct(self, fmt: str, *args: T.Any) -> int:
            """Append a formatted struct, then pad with zeroes for 8 alignment."""
            if not self.enable_output:
                write_size = struct.calcsize(fmt)
                self.offset = roundup8(self.offset + write_size)
                return write_size

            return self.add_bytes(struct.pack(fmt, *args))

    program_header_offset = 0
    program_header_size = 0
    program_header_count = 0

    section_header_offset = 0
    section_header_size = 0
    section_header_count = 0

    string_table_offset = 0
    note_section_offset = 0

    for enable_output in (False, True):
        writer = Writer(enable_output)

        # ELF header - https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#ELF_header
        writer.add_struct(
            "<16sHHIQQQIHHHHHH",
            b"\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00",
            2,  # Type: ET_EXEC
            0x3E,  # Machine: AMD x86-64
            1,  # Version
            0,  # Entry point
            program_header_offset,  # Program header offset
            section_header_offset,  # Section header offset
            0,  # Flags
            0x40,  # ELF header size
            program_header_size,  # Program header entry size
            program_header_count,  # Program header entry count
            section_header_size,  # Section header entry size
            section_header_count,  # Section header entry count
            1,
        )  # Section header string table index

        # Program header (LOAD segment) - https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#Program_header
        program_header_offset = writer.offset
        program_header_count = 1
        program_header_size = writer.add_struct(
            "<IIQQQQQQ",
            1,  # p_type: PT_LOAD
            5,  # p_flags: PF_R | PF_X
            0,  # p_offset
            0,  # p_vaddr
            0,  # p_paddr
            0x1000,  # p_filesz
            0x1000,  # p_memsz
            0x1000,
        )  # p_align
        assert program_header_size == 0x38

        # Note section data - https://docs.oracle.com/cd/E23824_01/html/819-0690/chapter6-18048.html
        # Surprisingly, there is no official spec for the content of this note. From various sources:
        # There must be a single section named .note.gnu.build-id, with a single note with vendor
        # name "GNU\x00", and type NT_GNU_BUILD_ID.
        note_section_offset = writer.offset
        note_name = b"GNU\x00"
        note_desc = build_id
        note_header = struct.pack(
            "<III", len(note_name), len(note_desc), 3
        )  # NT_GNU_BUILD_ID
        note_section_data = note_header + note_name + note_desc
        writer.add_bytes(note_section_data)

        # String table data - https://refspecs.linuxbase.org/elf/gabi4+/ch4.strtab.html
        str1_index = 1  # First symbol starts after initial 0 byte.
        string_table = b"\x00.shstrtab\x00"
        str2_index = len(string_table)
        string_table += b".note.gnu.build-id\x00"

        string_table_offset = writer.offset
        writer.add_bytes(string_table)

        # Section headers - https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#Section_header
        section_header_offset = writer.offset
        section_header_count = 2
        section_header_size = writer.add_struct(
            "<IIQQQQIIQQ",
            str2_index,  # sh_name
            7,  # sh_type: SHT_NOTE
            0,  # sh_flags
            0,  # sh_addr
            note_section_offset,  # sh_offset
            len(note_section_data),  # sh_size
            0,  # sh_link
            0,  # sh_info
            8,  # sh_addralign
            0,
        )  # sh_entsize
        assert section_header_size == 0x40

        writer.add_struct(
            "<IIQQQQIIQQ",
            str1_index,  # sh_name
            7,  # sh_type: SHT_NOTE
            0,  # sh_flags
            0,  # sh_addr
            string_table_offset,  # sh_offset
            len(string_table),  # sh_size
            0,  # sh_link
            0,  # sh_info
            8,  # sh_addralign
            0,
        )  # sh_entsize

    return writer.output


# A constant .build-id value used by several tests.
TINY_ELF_BUILD_ID_VALUE = bytes.fromhex(
    "0123456789012345678901234567890123456789"
)


class ExtractGnuBuildIdTest(unittest.TestCase):
    def setUp(self) -> None:
        self._td = tempfile.TemporaryDirectory()
        self._root = Path(self._td.name)
        self._elf = self._root / "elf_file"

    def tearDown(self) -> None:
        self._td.cleanup()

    def _write_elf_with_build_id(self, build_id: bytes) -> None:
        self._elf.write_bytes(generate_elf_with_build_id(build_id))

    def test_1(self) -> None:
        self._write_elf_with_build_id(TINY_ELF_BUILD_ID_VALUE)
        self.assertEqual(
            extract_gnu_build_id(self._elf), TINY_ELF_BUILD_ID_VALUE.hex()
        )

        self._write_elf_with_build_id(b"\0")
        self.assertEqual(extract_gnu_build_id(self._elf), "00")

        self._write_elf_with_build_id(b"\xde\xad\xbe\xef")
        self.assertEqual(extract_gnu_build_id(self._elf), "deadbeef")


class DebugSymbolsManifestParserTest(unittest.TestCase):
    def setUp(self) -> None:
        self._td = tempfile.TemporaryDirectory()
        self._root = Path(self._td.name)

    def tearDown(self) -> None:
        self._td.cleanup()

    def _write_manifest(self, relpath: str, content: T.Any) -> Path:
        path = self._root / relpath
        write_json(path, content)
        return path

    def test_single_manifest(self) -> None:
        manifest = [
            {
                "label": "//src/lib/foo:lib",
                "debug": "obj/lib/foo/libfoo.so.unstripped",
                "elf_build_id_file": "obj/lib/foo/libfoo.so.elf_build_id",
                "dest_path": "lib/libfoo.so",
                "os": "fuchsia",
                "cpu": "arm64",
                "breakpad": "obj/lib/foo/libfoo.so.sym",
            }
        ]
        manifest_path = self._write_manifest("debug_symbols.json", manifest)

        parser = DebugSymbolsManifestParser(self._root)
        parser.parse_manifest_file(manifest_path)

        self.assertListEqual(parser.entries, manifest)
        self.assertSetEqual(parser.extra_input_files, set())

    def test_included_manifest(self) -> None:
        sub_manifest = [
            {
                "debug": "obj/prebuilt/packages/extracted/foo/.build-id/01/23456789.debug",
                "elf_build_id": "0123456789",
            }
        ]
        sub_relpath = "obj/prebuilt/packages/debug_symbols/foo/manifest.json"

        sub_path = self._write_manifest(sub_relpath, sub_manifest)

        manifest_path = self._write_manifest(
            "debug_symbols.json",
            [
                {
                    "label": "//prebuilt/packages/foo",
                    "manifest": sub_relpath,
                }
            ],
        )

        parser = DebugSymbolsManifestParser(self._root)
        parser.parse_manifest_file(manifest_path)

        self.assertListEqual(parser.entries, sub_manifest)
        self.assertSetEqual(parser.extra_input_files, {sub_path})

    def test_recursive_includes(self) -> None:
        top_path = self._write_manifest(
            "debug_symbols.json",
            [
                {
                    "debug": "top/a/debug_file",
                },
                {
                    "manifest": "middle/debug_symbols.json",
                },
                {
                    "debug": "top/b/debug_file",
                },
            ],
        )

        middle_path = self._write_manifest(
            "middle/debug_symbols.json",
            [
                {
                    "debug": "middle/c/debug_file",
                },
                {
                    "manifest": "bottom/debug_symbols.json",
                },
                {
                    "debug": "middle/d/debug_file",
                },
            ],
        )

        bottom_path = self._write_manifest(
            "bottom/debug_symbols.json", [{"debug": "bottom/e/debug_file"}]
        )

        parser = DebugSymbolsManifestParser(self._root)
        parser.parse_manifest_file(top_path)

        self.assertListEqual(
            parser.entries,
            [
                {
                    "debug": "top/a/debug_file",
                },
                {
                    "debug": "middle/c/debug_file",
                },
                {
                    "debug": "bottom/e/debug_file",
                },
                {
                    "debug": "middle/d/debug_file",
                },
                {
                    "debug": "top/b/debug_file",
                },
            ],
        )

        self.assertSetEqual(
            parser.extra_input_files, {middle_path, bottom_path}
        )

    def test_cycle_detection(self) -> None:
        # Write manifests such that:
        #
        #   a --> b --> c --> d
        #         ^           |
        #         |___________|
        #
        a_path = self._write_manifest(
            "a.manifest", [{"manifest": "b.manifest"}]
        )
        b_path = self._write_manifest(
            "b.manifest", [{"manifest": "c.manifest"}]
        )
        c_path = self._write_manifest(
            "c.manifest", [{"manifest": "d.manifest"}]
        )
        d_path = self._write_manifest(
            "d.manifest", [{"manifest": "b.manifest"}]
        )

        parser = DebugSymbolsManifestParser(self._root)

        with self.assertRaises(ValueError) as cm:
            parser.parse_manifest_file(a_path)

        self.assertEqual(
            str(cm.exception),
            f"""Recursive manifest includes:
  {b_path} -->
  {c_path} -->
  {d_path} -->
  {b_path}""",
        )

    def test_build_id_resolution(self) -> None:
        a_build_id_file = self._root / "a.build_id"
        a_build_id_file.write_text("build_id_for_a")

        manifest_path = self._write_manifest(
            "debug_symbols.json",
            [
                {
                    "debug": "a/libfoo.so.unstripped",
                    "elf_build_id_file": "a.build_id",
                },
                {
                    "debug": "b/libbar.so.unstripped",
                },
                {
                    "debug": "c/.build-id/bu/ild_id_for_c.debug",
                },
                {
                    "debug": "d/libzoo.so.unstripped",
                    "elf_build_id": "build_id_for_d",
                },
            ],
        )

        b_file = self._root / "b/libbar.so.unstripped"
        b_file.parent.mkdir(parents=True)
        b_file.write_bytes(generate_elf_with_build_id(TINY_ELF_BUILD_ID_VALUE))

        parser = DebugSymbolsManifestParser(self._root)
        parser.enable_build_id_resolution()
        parser.parse_manifest_file(manifest_path)

        self.maxDiff = None

        self.assertListEqual(
            parser.entries,
            [
                {
                    "debug": "a/libfoo.so.unstripped",
                    "elf_build_id": "build_id_for_a",
                    "elf_build_id_file": "a.build_id",
                },
                {
                    "debug": "b/libbar.so.unstripped",
                    "elf_build_id": TINY_ELF_BUILD_ID_VALUE.hex(),
                },
                {
                    "debug": "c/.build-id/bu/ild_id_for_c.debug",
                    "elf_build_id": "build_id_for_c",
                },
                {
                    "debug": "d/libzoo.so.unstripped",
                    "elf_build_id": "build_id_for_d",
                },
            ],
        )

        self.assertSetEqual(
            parser.extra_input_files,
            {a_build_id_file, self._root / "b/libbar.so.unstripped"},
        )

    def test_deduplicate_entries(self) -> None:
        # Check that duplicates are merged, but other items are kept.
        manifest = [
            {
                "label": "//src:label_1",
                "debug": "../../prebuilt/.build-id/12/3456789.debug",
                "elf_build_id": "123456789",
            },
            {
                "label": "//src:label_2",
                "debug": "../../prebuilt/.build-id/55/67676767.debug",
                "elf_build_id": "5567676767",
            },
            {
                "label": "//src:label_1",
                "debug": "../../prebuilt/.build-id/12/3456789.debug",
                "elf_build_id": "123456789",
            },
            {
                "label": "//src:label_3",
                "debug": "../../prebuilt/.build-id/00/11223344.debug",
                "elf_build_id": "0011223344",
            },
        ]

        parser = DebugSymbolsManifestParser(self._root)
        parser.parse_manifest_json(manifest, "manifest.json")
        parser.deduplicate_entries()
        self.assertListEqual(
            parser.entries,
            [
                {
                    "label": "//src:label_1",
                    "debug": "../../prebuilt/.build-id/12/3456789.debug",
                    "elf_build_id": "123456789",
                },
                {
                    "label": "//src:label_2",
                    "debug": "../../prebuilt/.build-id/55/67676767.debug",
                    "elf_build_id": "5567676767",
                },
                {
                    "label": "//src:label_3",
                    "debug": "../../prebuilt/.build-id/00/11223344.debug",
                    "elf_build_id": "0011223344",
                },
            ],
        )

        # Check that merging duplicates propagates label and dest_path
        manifest = [
            {
                "debug": "../../prebuilt/.build-id/12/3456789.debug",
                "elf_build_id": "123456789",
            },
            {
                "label": "//src:label_1",
                "debug": "../../prebuilt/.build-id/12/3456789.debug",
                "dest_path": "bin/prog",
            },
        ]

        parser = DebugSymbolsManifestParser(self._root)
        parser.parse_manifest_json(manifest, "manifest.json")
        parser.deduplicate_entries()
        self.assertListEqual(
            parser.entries,
            [
                {
                    "label": "//src:label_1",
                    "debug": "../../prebuilt/.build-id/12/3456789.debug",
                    "elf_build_id": "123456789",
                    "dest_path": "bin/prog",
                },
            ],
        )

        # Check that duplicates with conflicting elf_build_id values are detected.
        manifest = [
            {
                "debug": "../../prebuilt/.build-id/12/3456789.debug",
                "elf_build_id": "123456789",
            },
            {
                "label": "//src:label_1",
                "debug": "../../prebuilt/.build-id/12/3456789.debug",
                "elf_build_id": "abcdef012",
            },
        ]
        parser = DebugSymbolsManifestParser(self._root)
        parser.parse_manifest_json(manifest, "manifest.json")
        with self.assertRaises(ValueError) as cm:
            parser.deduplicate_entries()
        self.assertTrue(
            str(cm.exception).startswith(
                "Incompatible 'elf_build_id' value between "
            )
        )

        # Check that the input manifest is unchanged when there are no duplicates.
        manifest = [
            {
                "label": "//src:label_1",
                "debug": "../../prebuilt/.build-id/12/3456789.debug",
                "elf_build_id": "123456789",
            },
            {
                "label": "//src:label_2",
                "debug": "../../prebuilt/.build-id/55/67676767.debug",
                "elf_build_id": "5567676767",
            },
            {
                "label": "//src:label_3",
                "debug": "../../prebuilt/.build-id/00/11223344.debug",
                "elf_build_id": "0011223344",
            },
        ]
        parser = DebugSymbolsManifestParser(self._root)
        parser.parse_manifest_json(manifest, "manifest.json")
        parser.deduplicate_entries()
        self.assertListEqual(parser.entries, manifest)


class CommandPoolTest(unittest.TestCase):
    def test_run(self) -> None:
        max_running = 0
        running_commands: set[int] = set()
        events_log: list[tuple[int, str, int]] = []

        # A CommandRunnerType value to launch a command that sleeps for a specific
        # number of seconds.
        def command_runner(
            cmd_id: int, sleep_time: float
        ) -> subprocess.Popen[str]:
            cmd_args = [
                sys.executable,
                "-c",
                "import time; time.sleep({sleep_time})",
            ]
            running_commands.add(cmd_id)
            nonlocal max_running
            if len(running_commands) > max_running:
                max_running = len(running_commands)
            events_log.append((cmd_id, "start", len(running_commands)))
            return subprocess.Popen(
                cmd_args,
                stdout=subprocess.DEVNULL,
                stderr=subprocess.DEVNULL,
                text=True,
            )

        def process_result(
            cmd_id: int, sleep_time: float, proc: subprocess.Popen[str]
        ) -> int:
            events_log.append((cmd_id, "stop", len(running_commands)))
            running_commands.discard(cmd_id)
            return cmd_id

        depth = 4
        count = 16
        command_pool = CommandPool(depth)
        for n in range(count):
            command_pool.add_command(0.3, command_runner)

        self.assertSetEqual(running_commands, set())
        self.assertListEqual(events_log, [])

        result_ids = []
        for result_id in command_pool.run(process_result):
            self.assertTrue(len(running_commands) <= depth)
            result_ids.append(result_id)

        # Verify that each command run exactly once.
        self.assertListEqual(sorted(result_ids), list(range(count)))

        # Verify that no more than |depth| commands ran concurrently.
        self.assertLessEqual(max_running, depth)

        # Verify there are no running commands left.
        self.assertEqual(len(running_commands), 0)

        # Verify that each command was started and stopped once.
        self.assertEqual(len(events_log), count * 2)

        started_cmds = [
            cmd_id for cmd_id, what, _ in events_log if what == "start"
        ]
        stopped_cmds = [
            cmd_id for cmd_id, what, _ in events_log if what == "stop"
        ]

        self.assertListEqual(sorted(started_cmds), list(range(count)))
        self.assertListEqual(sorted(stopped_cmds), list(range(count)))


class DebugSymbolExporterTest(unittest.TestCase):
    def setUp(self) -> None:
        self._td = tempfile.TemporaryDirectory()
        self._root = Path(self._td.name)

        # Generate several empty ELF files with a .build-id value.
        # and a debug_symbols.json manifest to list them.
        self._debug_symbol_files = {}
        self._debug_manifest = self._root / "debug_symbols.json"

        self._manifest_entries = []

        for n in range(16):
            debug_symbol_filename = f"debug_{n + 1}.so"
            build_id = bytes.fromhex("4200000000%02x" % n)
            # entries 1 and 4 have a stripped value.
            entry = {
                "debug": debug_symbol_filename,
                "elf_build_id": build_id.hex(),
                "label": f"//some:label_{n + 1}",
                "os": "fuchsia",
            }
            # As a special case, entries 1 and 5 have a "stripped" file path/
            if n in (1, 5):
                entry["stripped"] = f"stripped_{n + 1}.so"
            # As a special case, entries 3 and 4 are Linux binaries, not Fuchsia ones.
            if n in (3, 4):
                entry["os"] = "linux"
            # As a special case, entry 2 has a breakpad file path.
            if n in (2,):
                entry["breakpad"] = f"breakpad_{n + 1}.sym"
                (self._root / entry["breakpad"]).write_text(f"BK{n + 1}")
            # As a special case, entry 6 has a GSYM file path.
            if n in (6,):
                entry["gsym"] = f"gsym_{n + 1}.gsym"
                (self._root / entry["gsym"]).write_text(f"G{n + 1}")
            self._manifest_entries.append(entry)
            (self._root / debug_symbol_filename).write_bytes(
                generate_elf_with_build_id(build_id)
            )
            self._debug_symbol_files[build_id.hex()] = debug_symbol_filename

        # Create a fake dump_syms tool that simply prints the path of
        # the input debug symbol file.
        self._dump_syms = self._root / "dump_syms"
        self._dump_syms.write_text(
            f"""#!{sys.executable}
import argparse

parser = argparse.ArgumentParser()
parser.add_argument("-r", action="store_true")
parser.add_argument("-n")
parser.add_argument("-o")
parser.add_argument("debug_symbol_file")

args = parser.parse_args()

print(args.debug_symbol_file)
"""
        )
        self._dump_syms.chmod(0o755)

        # Create a fake llvm-gsymutil tool that writes the path of
        # the input debug symbol file to the output.
        self._gsymutil = self._root / "gsymutil"
        self._gsymutil.write_text(
            f"""#!{sys.executable}
import argparse
import os

parser = argparse.ArgumentParser()
parser.add_argument("--convert", required=True, help="Input debug binary")
parser.add_argument("--out-file", required=True, help="Output file path")
args = parser.parse_args()

os.makedirs(os.path.dirname(args.out_file), exist_ok=True)
with open(args.out_file, "wt") as f:
    f.write(args.convert)
    f.write("\\n")
"""
        )
        self._gsymutil.chmod(0o755)

        # Custom logging hooks to capture logs and errors.
        self._log_lines: list[str] = []
        self._err_lines: list[str] = []

        def log(msg: str) -> None:
            self._log_lines.append(msg)

        def log_error(msg: str) -> None:
            self._err_lines.append(msg)

        self._log = log
        self._log_error = log_error

    def tearDown(self) -> None:
        self._td.cleanup()

    def test_export_debug_symbols_no_breakpad(self) -> None:
        exporter = DebugSymbolExporter(
            build_dir=self._root,
            dump_syms_tool=None,
            log=self._log,
            log_error=self._log_error,
        )

        exporter.parse_debug_symbols(self._manifest_entries)

        output_dir = self._root / "out"

        self.assertTrue(exporter.export_debug_symbols(output_dir))

        self.assertTrue((output_dir / ".build-id").is_dir())

        for build_id, symbol_filename in self._debug_symbol_files.items():
            debug_file = (
                output_dir
                / ".build-id"
                / build_id[0:2]
                / f"{build_id[2:]}.debug"
            )
            self.assertTrue(debug_file.exists(), msg=f"For {debug_file}")
            self.assertTrue(debug_file.is_symlink(), msg=f"For {debug_file}")
            self.assertEqual(
                debug_file.readlink(), self._root / symbol_filename
            )

        self.assertListEqual(self._err_lines, [])

        self.assertListEqual(
            self._log_lines,
            [
                f"Creating {output_dir}/build-ids.json",
                f"Creating {output_dir}/build-ids.txt",
                f"Creating 20 symlinks in {output_dir}",
                "Done!",
            ],
        )

        exported_debug_symbols_path = output_dir / "debug_symbols.json"
        self.assertTrue(exported_debug_symbols_path.is_file())
        with exported_debug_symbols_path.open("rt") as f:
            exported_debug_symbols = json.load(f)

        self.assertEqual(len(exported_debug_symbols), 16)

        self.assertDictEqual(
            exported_debug_symbols[0],
            {
                "breakpad": ".build-id/42/0000000000.sym",
                "debug": ".build-id/42/0000000000.debug",
                "elf_build_id": "420000000000",
                "label": "//some:label_1",
                "os": "fuchsia",
            },
        )

        self.assertDictEqual(
            exported_debug_symbols[1],
            {
                "breakpad": ".build-id/42/0000000001.sym",
                "debug": ".build-id/42/0000000001.debug",
                "elf_build_id": "420000000001",
                "label": "//some:label_2",
                "os": "fuchsia",
                "stripped": ".build-id/42/0000000001",
            },
        )

        self.assertDictEqual(
            exported_debug_symbols[2],
            {
                "breakpad": ".build-id/42/0000000002.sym",
                "debug": ".build-id/42/0000000002.debug",
                "elf_build_id": "420000000002",
                "label": "//some:label_3",
                "os": "fuchsia",
            },
        )

        self.assertDictEqual(
            exported_debug_symbols[3],
            {
                "breakpad": ".build-id/42/0000000003.sym",
                "debug": ".build-id/42/0000000003.debug",
                "elf_build_id": "420000000003",
                "label": "//some:label_4",
                "os": "linux",
            },
        )

        self.assertDictEqual(
            exported_debug_symbols[4],
            {
                "breakpad": ".build-id/42/0000000004.sym",
                "debug": ".build-id/42/0000000004.debug",
                "elf_build_id": "420000000004",
                "label": "//some:label_5",
                "os": "linux",
            },
        )

        self.assertDictEqual(
            exported_debug_symbols[5],
            {
                "breakpad": ".build-id/42/0000000005.sym",
                "debug": ".build-id/42/0000000005.debug",
                "elf_build_id": "420000000005",
                "label": "//some:label_6",
                "os": "fuchsia",
                "stripped": ".build-id/42/0000000005",
            },
        )

        build_ids_txt = output_dir / "build-ids.txt"
        self.assertTrue(build_ids_txt.is_file())
        self.assertEqual(
            build_ids_txt.read_text(),
            """\
420000000000
420000000001
420000000002
420000000005
420000000006
420000000007
420000000008
420000000009
42000000000a
42000000000b
42000000000c
42000000000d
42000000000e
42000000000f
""",
        )

        build_ids_json = output_dir / "build-ids.json"
        self.assertTrue(build_ids_json.is_file())
        self.assertDictEqual(
            json.loads(build_ids_json.read_text()),
            {
                "420000000000": "//some:label_1",
                "420000000001": "//some:label_2",
                "420000000002": "//some:label_3",
                "420000000003": "//some:label_4",
                "420000000004": "//some:label_5",
                "420000000005": "//some:label_6",
                "420000000006": "//some:label_7",
                "420000000007": "//some:label_8",
                "420000000008": "//some:label_9",
                "420000000009": "//some:label_10",
                "42000000000a": "//some:label_11",
                "42000000000b": "//some:label_12",
                "42000000000c": "//some:label_13",
                "42000000000d": "//some:label_14",
                "42000000000e": "//some:label_15",
                "42000000000f": "//some:label_16",
            },
        )

    def test_export_debug_symbols_with_breakpad(self) -> None:
        exporter = DebugSymbolExporter(
            build_dir=self._root,
            dump_syms_tool=self._dump_syms,
            log=self._log,
            log_error=self._log_error,
        )

        exporter.parse_debug_symbols(self._manifest_entries)

        output_dir = self._root / "out"
        self.assertTrue(exporter.export_debug_symbols(output_dir))

        self.assertTrue((output_dir / ".build-id").is_dir())

        for build_id, symbol_filename in self._debug_symbol_files.items():
            debug_file = (
                output_dir
                / ".build-id"
                / build_id[0:2]
                / f"{build_id[2:]}.debug"
            )
            self.assertTrue(debug_file.exists(), msg=f"For {debug_file}")
            self.assertTrue(debug_file.is_symlink(), msg=f"For {debug_file}")
            self.assertEqual(
                debug_file.readlink(), self._root / symbol_filename
            )

        self.assertListEqual(self._err_lines, [])

        rel_root = os.path.relpath(self._root)

        self.maxDiff = None
        self.assertListEqual(
            self._log_lines,
            [
                f"Creating {output_dir}/build-ids.json",
                f"Creating {output_dir}/build-ids.txt",
                f"Creating 20 symlinks in {output_dir}",
                f"Generating 13 breakpad symbols in {output_dir}",
                f"  - Creating .build-id/42/0000000000.sym FROM {rel_root}/debug_1.so",
                f"  - Creating .build-id/42/0000000001.sym FROM {rel_root}/debug_2.so",
                f"  - Creating .build-id/42/0000000005.sym FROM {rel_root}/debug_6.so",
                f"  - Creating .build-id/42/0000000006.sym FROM {rel_root}/debug_7.so",
                f"  - Creating .build-id/42/0000000007.sym FROM {rel_root}/debug_8.so",
                f"  - Creating .build-id/42/0000000008.sym FROM {rel_root}/debug_9.so",
                f"  - Creating .build-id/42/0000000009.sym FROM {rel_root}/debug_10.so",
                f"  - Creating .build-id/42/000000000a.sym FROM {rel_root}/debug_11.so",
                f"  - Creating .build-id/42/000000000b.sym FROM {rel_root}/debug_12.so",
                f"  - Creating .build-id/42/000000000c.sym FROM {rel_root}/debug_13.so",
                f"  - Creating .build-id/42/000000000d.sym FROM {rel_root}/debug_14.so",
                f"  - Creating .build-id/42/000000000e.sym FROM {rel_root}/debug_15.so",
                f"  - Creating .build-id/42/000000000f.sym FROM {rel_root}/debug_16.so",
                "Done!",
            ],
        )

        for bin_index in range(16):
            dst_file = output_dir / (
                ".build-id/42/00000000%02x.sym" % bin_index
            )
            src_file = self._root / f"debug_{bin_index + 1}.so"
            if bin_index in (3, 4):
                # No breakpad file for non-Fuchsia binaries and for pre-existing one.
                self.assertFalse(
                    dst_file.exists(), msg=f"breakpad_file={dst_file}"
                )
            else:
                self.assertTrue(
                    dst_file.exists(), msg=f"breakpad_file={dst_file}"
                )
                if bin_index in (2,):
                    self.assertEqual(
                        dst_file.read_text().strip(),
                        "BK3",
                        msg=f"bin_index={bin_index} src_file={src_file} dst_file={dst_file}",
                    )
                else:
                    self.assertEqual(
                        dst_file.read_text().strip(),
                        str(src_file),
                        msg=f"bin_index={bin_index} src_file={src_file} dst_file={dst_file}",
                    )

        build_ids_txt = output_dir / "build-ids.txt"
        self.assertTrue(build_ids_txt.is_file())
        self.assertEqual(
            build_ids_txt.read_text(),
            """\
420000000000
420000000001
420000000002
420000000005
420000000006
420000000007
420000000008
420000000009
42000000000a
42000000000b
42000000000c
42000000000d
42000000000e
42000000000f
""",
        )

        build_ids_json = output_dir / "build-ids.json"
        self.assertTrue(build_ids_json.is_file())
        self.assertDictEqual(
            json.loads(build_ids_json.read_text()),
            {
                "420000000000": "//some:label_1",
                "420000000001": "//some:label_2",
                "420000000002": "//some:label_3",
                "420000000003": "//some:label_4",
                "420000000004": "//some:label_5",
                "420000000005": "//some:label_6",
                "420000000006": "//some:label_7",
                "420000000007": "//some:label_8",
                "420000000008": "//some:label_9",
                "420000000009": "//some:label_10",
                "42000000000a": "//some:label_11",
                "42000000000b": "//some:label_12",
                "42000000000c": "//some:label_13",
                "42000000000d": "//some:label_14",
                "42000000000e": "//some:label_15",
                "42000000000f": "//some:label_16",
            },
        )

    def test_export_debug_symbols_with_gsymutil(self) -> None:
        exporter = DebugSymbolExporter(
            build_dir=self._root,
            gsymutil_tool=self._gsymutil,
            log=self._log,
            log_error=self._log_error,
        )

        exporter.parse_debug_symbols(self._manifest_entries)

        output_dir = self._root / "out"
        self.assertTrue(exporter.export_debug_symbols(output_dir))

        self.assertTrue((output_dir / ".build-id").is_dir())

        for build_id, symbol_filename in self._debug_symbol_files.items():
            debug_file = (
                output_dir
                / ".build-id"
                / build_id[0:2]
                / f"{build_id[2:]}.debug"
            )
            self.assertTrue(debug_file.exists(), msg=f"For {debug_file}")
            self.assertTrue(debug_file.is_symlink(), msg=f"For {debug_file}")
            self.assertEqual(
                debug_file.readlink(), self._root / symbol_filename
            )

        self.assertListEqual(self._err_lines, [])

        rel_root = os.path.relpath(self._root)

        self.maxDiff = None
        self.assertListEqual(
            self._log_lines,
            [
                f"Creating {output_dir}/build-ids.json",
                f"Creating {output_dir}/build-ids.txt",
                f"Creating 20 symlinks in {output_dir}",
                f"Generating 13 GSYM symbols in {output_dir}",
                f"  - Creating .build-id/42/0000000000.gsym FROM {rel_root}/debug_1.so",
                f"  - Creating .build-id/42/0000000001.gsym FROM {rel_root}/debug_2.so",
                f"  - Creating .build-id/42/0000000002.gsym FROM {rel_root}/debug_3.so",
                f"  - Creating .build-id/42/0000000005.gsym FROM {rel_root}/debug_6.so",
                f"  - Creating .build-id/42/0000000007.gsym FROM {rel_root}/debug_8.so",
                f"  - Creating .build-id/42/0000000008.gsym FROM {rel_root}/debug_9.so",
                f"  - Creating .build-id/42/0000000009.gsym FROM {rel_root}/debug_10.so",
                f"  - Creating .build-id/42/000000000a.gsym FROM {rel_root}/debug_11.so",
                f"  - Creating .build-id/42/000000000b.gsym FROM {rel_root}/debug_12.so",
                f"  - Creating .build-id/42/000000000c.gsym FROM {rel_root}/debug_13.so",
                f"  - Creating .build-id/42/000000000d.gsym FROM {rel_root}/debug_14.so",
                f"  - Creating .build-id/42/000000000e.gsym FROM {rel_root}/debug_15.so",
                f"  - Creating .build-id/42/000000000f.gsym FROM {rel_root}/debug_16.so",
                "Done!",
            ],
        )
        for bin_index in range(16):
            dst_file = output_dir / (
                ".build-id/42/00000000%02x.gsym" % bin_index
            )
            src_file = self._root / f"debug_{bin_index + 1}.so"
            if bin_index in (3, 4):
                # No GSYM symbols for non-Fuchsia binaries.
                self.assertFalse(dst_file.exists(), msg=f"gsym_file={dst_file}")
            else:
                self.assertTrue(dst_file.exists(), msg=f"gsym_file={dst_file}")
                if bin_index in (6,):
                    self.assertEqual(
                        dst_file.read_text().strip(),
                        "G7",
                        msg=f"bin_index={bin_index} src_file={src_file} dst_file={dst_file}",
                    )
                else:
                    self.assertEqual(
                        dst_file.read_text().strip(),
                        str(src_file),
                        msg=f"bin_index={bin_index} src_file={src_file} dst_file={dst_file}",
                    )

    def test_get_debug_symbols_to_build_id_copies(self) -> None:
        exporter = DebugSymbolExporter(
            build_dir=self._root,
            dump_syms_tool=None,
            log=self._log,
            log_error=self._log_error,
        )

        exporter.parse_debug_symbols(self._manifest_entries)

        output_dir = self._root / "out"
        with self.assertRaises(AssertionError) as cm:
            exporter.copy_debug_symbols_to_build_id(output_dir)
        self.assertEqual(
            str(cm.exception),
            f"Invalid output directory name (.../.build-id expected): {output_dir}",
        )

        build_id_dir = output_dir / ".build-id"
        copies = exporter.get_debug_symbols_to_build_id_copies(build_id_dir)

        self.assertListEqual(
            copies,
            [
                (
                    f"{self._root}/debug_1.so",
                    f"{build_id_dir}/42/0000000000.debug",
                ),
                (
                    f"{self._root}/debug_2.so",
                    f"{build_id_dir}/42/0000000001.debug",
                ),
                (
                    f"{self._root}/debug_3.so",
                    f"{build_id_dir}/42/0000000002.debug",
                ),
                (
                    f"{self._root}/debug_4.so",
                    f"{build_id_dir}/42/0000000003.debug",
                ),
                (
                    f"{self._root}/debug_5.so",
                    f"{build_id_dir}/42/0000000004.debug",
                ),
                (
                    f"{self._root}/debug_6.so",
                    f"{build_id_dir}/42/0000000005.debug",
                ),
                (
                    f"{self._root}/debug_7.so",
                    f"{build_id_dir}/42/0000000006.debug",
                ),
                (
                    f"{self._root}/debug_8.so",
                    f"{build_id_dir}/42/0000000007.debug",
                ),
                (
                    f"{self._root}/debug_9.so",
                    f"{build_id_dir}/42/0000000008.debug",
                ),
                (
                    f"{self._root}/debug_10.so",
                    f"{build_id_dir}/42/0000000009.debug",
                ),
                (
                    f"{self._root}/debug_11.so",
                    f"{build_id_dir}/42/000000000a.debug",
                ),
                (
                    f"{self._root}/debug_12.so",
                    f"{build_id_dir}/42/000000000b.debug",
                ),
                (
                    f"{self._root}/debug_13.so",
                    f"{build_id_dir}/42/000000000c.debug",
                ),
                (
                    f"{self._root}/debug_14.so",
                    f"{build_id_dir}/42/000000000d.debug",
                ),
                (
                    f"{self._root}/debug_15.so",
                    f"{build_id_dir}/42/000000000e.debug",
                ),
                (
                    f"{self._root}/debug_16.so",
                    f"{build_id_dir}/42/000000000f.debug",
                ),
            ],
        )

    def test_copy_debug_symbols_to_build_id(self) -> None:
        exporter = DebugSymbolExporter(
            build_dir=self._root,
            dump_syms_tool=None,
            log=self._log,
            log_error=self._log_error,
        )

        exporter.parse_debug_symbols(self._manifest_entries)

        output_dir = self._root / "out"
        with self.assertRaises(AssertionError) as cm:
            exporter.copy_debug_symbols_to_build_id(output_dir)
        self.assertEqual(
            str(cm.exception),
            f"Invalid output directory name (.../.build-id expected): {output_dir}",
        )

        build_id_dir = output_dir / ".build-id"
        exporter.copy_debug_symbols_to_build_id(build_id_dir)

        self.assertTrue(build_id_dir.is_dir())
        for build_id, symbol_filename in self._debug_symbol_files.items():
            debug_file = build_id_dir / build_id[0:2] / f"{build_id[2:]}.debug"
            self.assertTrue(debug_file.is_file())


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