.gitlab-ci.yml

@@ -33,7 +33,7 @@ codespell:
 pytest:
   stage: test
   script:
-    - "apk -q add git"
+    - "apk -q add git android-tools"
     - "su build -c 'git config --global user.email ci@ci'"
     - "su build -c 'git config --global user.name CI'"
     - "echo 'build ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers"

pmb/aportgen/device.py

@@ -142,37 +142,23 @@ def generate_deviceinfo_fastboot_content(bootimg: Bootimg | None = None) -> str:
     content = f"""\
         deviceinfo_kernel_cmdline="{bootimg["cmdline"]}"
         deviceinfo_generate_bootimg="true"
-        deviceinfo_bootimg_qcdt="{bootimg["qcdt"]}"
-        deviceinfo_bootimg_dtb_second="{bootimg["dtb_second"]}"
         deviceinfo_flash_pagesize="{bootimg["pagesize"]}"
         """
 
-    if "qcdt_type" in bootimg.keys():
-        content += f"""\
-        deviceinfo_bootimg_qcdt_type="{bootimg["qcdt_type"]}"
-        """
-
-    if "mtk_label_kernel" in bootimg.keys():
-        content += f"""\
-        deviceinfo_mtk_label_kernel="{bootimg["mtk_label_kernel"]}"
-        """
-    if "mtk_label_ramdisk" in bootimg.keys():
-        content += f"""\
-        deviceinfo_mtk_label_ramdisk="{bootimg["mtk_label_ramdisk"]}"
-        """
+    for k in ["qcdt_type", "dtb_second", "mtk_label_kernel", "mtk_label_ramdisk", "header_version"]:
+        v = bootimg[k]  # type: ignore
+        if v:
+            content += f"""\
+            deviceinfo_{k}="{v}"
+            """
 
-    if "header_version" in bootimg.keys():
+    if bootimg["header_version"] == "2":
         content += f"""\
-        deviceinfo_header_version="{bootimg["header_version"]}"
+        deviceinfo_append_dtb="false"
+        deviceinfo_flash_offset_dtb="{bootimg["dtb_offset"]}"
         """
 
-        if bootimg["header_version"] == "2":
-            content += f"""\
-            deviceinfo_append_dtb="false"
-            deviceinfo_flash_offset_dtb="{bootimg["dtb_offset"]}"
-            """
-
-    if "base" in bootimg.keys():
+    if bootimg["base"]:
         content += f"""\
         deviceinfo_flash_offset_base="{bootimg["base"]}"
         deviceinfo_flash_offset_kernel="{bootimg["kernel_offset"]}"

pmb/aportgen/test_device.py

+from pmb.types import Bootimg
+import pytest
+
+from .device import generate_deviceinfo_fastboot_content
+
+# Test case name -> (input, expected substrings, !expected substrings)
+test_data: dict[str, tuple[Bootimg | None, list[str], list[str]]] = {
+    "none": (None, ['kernel_cmdline=""', 'flash_pagesize="2048"'], []),
+    "header_v0": (
+        Bootimg(
+            cmdline="beep boop",
+            header_version="0",
+            qcdt="false",
+            base="0x80000000",
+            kernel_offset="0x8000",
+            tags_offset="0x100",
+            qcdt_type=None,
+            dtb_offset=None,
+            dtb_second="",
+            pagesize="2048",
+            ramdisk_offset="",
+            second_offset="",
+            mtk_label_kernel="",
+            mtk_label_ramdisk="",
+        ),
+        [
+            'kernel_cmdline="beep boop"',
+            'flash_pagesize="2048"',
+            'flash_offset_base="0x80000000"',
+            'flash_offset_kernel="0x8000"',
+            'flash_offset_tags="0x100"',
+        ],
+        [],
+    ),
+    "header_v2": (
+        Bootimg(
+            cmdline="console=ttyMSM0,115200n8",
+            header_version="2",
+            qcdt="false",
+            base="0x80000000",
+            kernel_offset="",
+            tags_offset="",
+            qcdt_type=None,
+            dtb_offset="0x101f00000",
+            dtb_second="",
+            pagesize="2048",
+            ramdisk_offset="",
+            second_offset="",
+            mtk_label_kernel="",
+            mtk_label_ramdisk="",
+        ),
+        [
+            'kernel_cmdline="console=ttyMSM0,115200n8"',
+            'flash_pagesize="2048"',
+            'append_dtb="false"',
+            'flash_offset_dtb="0x101f00000"',
+        ],
+        [
+            "qcdt",
+        ],
+    ),
+    "header_v3": (
+        Bootimg(
+            cmdline="console=ttyMSM0,115200n8",
+            header_version="3",
+            qcdt="false",
+            base="",
+            kernel_offset="",
+            tags_offset="",
+            qcdt_type=None,
+            dtb_offset="",
+            dtb_second="",
+            pagesize="4096",
+            ramdisk_offset="",
+            second_offset="",
+            mtk_label_kernel="",
+            mtk_label_ramdisk="",
+        ),
+        [
+            'kernel_cmdline="console=ttyMSM0,115200n8"',
+            'flash_pagesize="4096"',
+        ],
+        [
+            "flash_offset_base",
+        ],
+    ),
+}
+
+
+@pytest.mark.parametrize("case", [*test_data.keys()])
+def test_deviceinfo_fastboot(case):
+    bootimg = test_data[case][0]
+    expected_substrings = test_data[case][1]
+    unexpected_substrings = test_data[case][2]
+    content = generate_deviceinfo_fastboot_content(bootimg)
+
+    print(content)
+    for substring in expected_substrings:
+        assert substring in content, f"Expected substring not found: {substring}"
+
+    for substring in unexpected_substrings:
+        assert substring not in content, f"Unexpected substring found: {substring}"

pmb/conftest.py

@@ -12,6 +12,9 @@ from pmb.helpers.args import init as init_args
 _testdir = Path(__file__).parent / "data/tests"
 
 
+# request can be specified using parameterize from test cases
+# e.g. @pytest.mark.parametrize("config_file", ["no-repos"], indirect=True)
+# will set request.param to "no-repos"
 @pytest.fixture
 def config_file(tmp_path_factory, request):
     """Fixture to create a temporary pmbootstrap_v3.cfg file."""
@@ -158,14 +161,14 @@ def pmaports(pmb_args, monkeypatch):
 
     config = get_context().config
 
-    with monkeypatch.context() as m:
-        # Speed things up by cloning from the local checkout if it exists.
-        if Config.aports[0].exists():
-            m.setitem(pmb.config.git_repos, "pmaports", Config.aports)
+    if Config.aports[-1].exists():
+        pmb.config.git_repos["pmaports"] = [str(Config.aports[-1])]
 
+    if not config.aports[-1].exists():
         pmb.helpers.git.clone("pmaports")
-
-    assert pmb.helpers.run.user(["git", "checkout", "master"], working_dir=config.aports[0]) == 0
+        assert (
+            pmb.helpers.run.user(["git", "checkout", "master"], working_dir=config.aports[0]) == 0
+        )
 
 
 @pytest.fixture

pmb/parse/bootimg.py

@@ -171,7 +171,7 @@ def bootimg(path: Path) -> Bootimg:
             if value is not None
         }
     )
-    output["dtb_second"] = "true" if is_dtb(f"{bootimg_path}-second") else "false"
+    output["dtb_second"] = "true" if is_dtb(f"{bootimg_path}-second") else ""
 
     with open(f"{bootimg_path}-cmdline") as f:
         output["cmdline"] = trim_input(f)
@@ -185,11 +185,11 @@ def bootimg(path: Path) -> Bootimg:
         qcdt_type=output.get("qcdt_type"),
         dtb_offset=output.get("dtb_offset"),
         dtb_second=output["dtb_second"],
-        base=output["base"],
-        kernel_offset=output["kernel_offset"],
-        ramdisk_offset=output["ramdisk_offset"],
-        second_offset=output["second_offset"],
-        tags_offset=output["tags_offset"],
+        base=output.get("base", ""),
+        kernel_offset=output.get("kernel_offset", ""),
+        ramdisk_offset=output.get("ramdisk_offset", ""),
+        second_offset=output.get("second_offset", ""),
+        tags_offset=output.get("tags_offset", ""),
         pagesize=output["pagesize"],
         header_version=output.get("header_version"),
         mtk_label_kernel=output.get("mtk_label_kernel", ""),

pmb/parse/test_bootimg.py

+from pathlib import Path
+from collections.abc import Callable
+import pytest
+import shutil
+import subprocess
+
+from pmb.types import Bootimg
+
+from .bootimg import bootimg as parse_bootimg
+
+
+# This is the result of compiling a totally empty devicetree file
+empty_dtb = b"\xd0\r\xfe\xed\x00\x00\x00H\x00\x00\x008\x00\x00\x00H\x00\x00\x00(\x00\x00\x00\x11\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\t"
+
+
+@pytest.fixture
+def progs() -> dict[str, str]:
+    progs: dict[str, str] = {
+        # We expect the modern python version of mkbootimg from android-tools
+        "mkbootimg": "",
+    }
+    for k in progs.keys():
+        v = shutil.which(k)
+        if v is None:
+            pytest.skip(f"{k} not found")
+        else:
+            progs[k] = v
+
+    return progs
+
+
+@pytest.fixture
+def bootimg(progs: dict[str, str], tmp_path: Path) -> Callable:
+    path: Path = tmp_path / "boot.img"
+    cmd = [
+        progs["mkbootimg"],
+        "--kernel",
+        "/dev/null",
+        "--ramdisk",
+        "/dev/null",
+        "--output",
+        str(path),
+    ]
+
+    def with_args(**kwargs):
+        # Header version 2 requires a dtb file, be helpful and add one if it's missing
+        if kwargs.get("header_version", 0) == 2 and "dtb" not in kwargs:
+            with open(path.with_suffix(".dtb"), "wb") as f:
+                f.write(empty_dtb)
+            cmd.extend(["--dtb", str(path.with_suffix(".dtb"))])
+        for key, value in kwargs.items():
+            cmd.extend([f"--{key}", str(value)])
+        subprocess.run(cmd, check=True)
+        return tmp_path / "boot.img"
+
+    return with_args
+
+
+# Due to limitations in the test infrastructure (somehow we have to clone
+# all of pmaports for this!!) we stuff all the tests into one
+def test_bootimg(bootimg, pmb_args, pmaports):
+    bootimg_path = bootimg(base=0x80000000)
+
+    # Header v0
+    img: Bootimg = parse_bootimg(bootimg_path)
+    print(f"Header v0: {img}")
+    assert img["header_version"] == "0", "header v0 expected header version 0"
+    assert img["cmdline"] == "", "header v0 expected empty cmdline"
+    assert img["qcdt"] == "false", "header v0 expected qcdt false"
+    assert img["base"] == "0x80000000", "header v0 expected base 0x80000000"
+    assert int(img["kernel_offset"], 16) == 0x8000, "header v0 expected kernel offset 0x8000"
+    assert int(img["tags_offset"], 16) == 0x100, "header v0 expected tags offset 0x100"
+
+    # Header v2
+    bootimg_path = bootimg(base=0x80000000, header_version=2)
+
+    img = parse_bootimg(bootimg_path)
+    print(f"Header v2: {img}")
+    assert img["header_version"] == "2", "header v2 expected header version 2"
+    assert img["cmdline"] == "", "header v2 expected empty cmdline"
+    assert img["qcdt"] == "false", "header v2 expected qcdt false"
+    assert img["base"] == "0x80000000", "header v2 expected base 0x80000000"
+    assert int(img["kernel_offset"], 16) == 0x8000, "header v2 expected kernel offset 0x8000"
+    assert int(img["tags_offset"], 16) == 0x100, "header v2 expected tags offset 0x100"
+    assert img["dtb_offset"] is not None, "header v2 expected dtb offset"
+    assert int(img["dtb_offset"], 16) == 0x101F00000, "header v2 expected dtb offset 0x101f00000"
+    assert img["dtb_second"] == "", "header v2 expected dtb second empty"
+    assert img["pagesize"] == "2048", "header v2 expected pagesize 2048"
+
+    # Header v3, plus cmdline for fun
+    bootimg_path = bootimg(header_version=3, cmdline="bleep boop console=ttyMSM0,115200n8")
+
+    img = parse_bootimg(bootimg_path)
+    print(f"Header v3: {img}")
+    assert img["header_version"] == "3", "header v3 expected header version 3"
+    assert img["cmdline"] == "bleep boop console=ttyMSM0,115200n8", "header v3 expected cmdline"
+    assert img["kernel_offset"] == "", "header v3 expected empty kernel offset"
+    assert img["pagesize"] == "4096", "header v3 expected pagesize 4096"
+    assert img["ramdisk_offset"] == "", "header v3 expected empty ramdisk offset"
+
+
+def test_bootimg_deviceinfo():
+    # Test the deviceinfo file
+    pass