Test Jobs for V4L2 Compliance (New)

providers/base/bin/v4l2_compliance_test.py

@@ -0,0 +1,74 @@
+#! /usr/bin/python3
+
+import argparse
+import sys
+from checkbox_support.parsers.v4l2_compliance import parse_v4l2_compliance
+
+"""
+class Input:
+    ioctl: T.List[str]
+    device: str
+"""
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--device",
+        help="The device to test, if not specified, "
+        "we will let v4l2-compliance infer the default device "
+        "(usually /dev/video0)",
+        type=str,
+    )
+    parser.add_argument(
+        "--ioctl",
+        nargs="+",
+        help=(
+            "List of ioctl requests. "
+            "If any of them is listed under FAIL in v4l2-compliance, "
+            "the entire test cases fails. "
+            "ioctl requests should start with VIDIOC_, "
+            "for example VIDIOC_ENUM_FMT "
+            "NOTE: VIDIOC_QUERYCAP is always required"
+        ),
+        default=["VIDIOC_QUERYCAP"],
+    )
+    parser.add_argument(
+        "--treat-unsupported-as-fail",
+        action="store_true",
+        help="If specified, and if any of the ioctls are in unsupported, "
+        "they are treated as fail and will fail the test case",
+        default=False,
+    )
+    return parser.parse_args()  # type: ignore
+
+
+def main():
+    args = parse_args()
+    print(
+        "Testing if all of the following ioctl requests",
+        args.ioctl,
+        "are supported on",
+        args.device or "/dev/video0",
+    )
+
+    _, details = parse_v4l2_compliance(args.device)
+
+    return_code = 0
+
+    if "VIDIOC_QUERYCAP" in details["failed"]:
+        return_code = 1
+    for ioctl_request in args.ioctl:
+        if ioctl_request in details["failed"]:
+            print(ioctl_request, "failed the test", file=sys.stderr)
+            return_code = 1
+
+    if return_code == 0:
+        print(args.ioctl, "are all supported")
+
+    return return_code
+
+
+if __name__ == "__main__":
+    return_code = main()
+    exit(return_code)

providers/base/tests/test_v4l2_compliance_test.py

@@ -0,0 +1,116 @@
+import unittest as ut
+from unittest.mock import MagicMock, call, patch
+from v4l2_compliance_test import main as main_under_test
+from shlex import split as sh_split
+
+
+class TestV4L2ComplianceTest(ut.TestCase):
+
+    @patch("v4l2_compliance_test.parse_v4l2_compliance")
+    def test_failed_query_cap(self, mock_parser: MagicMock):
+        with patch(
+            "sys.argv",
+            sh_split("v4l2_compliance_test.py --ioctl VIDIOC_QUERYCAP"),
+        ):
+            # query cap failure should always fail the test case
+            mock_parser.return_value = (
+                {},
+                {
+                    "succeeded": [],
+                    "failed": ["VIDIOC_QUERYCAP"],
+                    "not_supported": [],
+                },
+            )
+
+            self.assertEqual(main_under_test(), 1)
+
+        with patch(
+            "sys.argv",
+            sh_split("v4l2_compliance_test.py --ioctl VIDIOC_ENUM_FMT"),
+        ):
+            mock_parser.return_value = (
+                {},
+                {
+                    "succeeded": [],
+                    "failed": ["VIDIOC_QUERYCAP", "VIDIOC_ENUM_FMT"],
+                    "not_supported": [],
+                },
+            )
+            # also fail even if query cap is not listed in the args
+            self.assertEqual(main_under_test(), 1)
+
+    @patch(
+        "sys.argv",
+        sh_split(
+            "v4l2_compliance_test.py "
+            + "--ioctl VIDIOC_ENUM_FMT VIDIOC_QUERYCTRL --device /dev/video1"
+        ),
+    )
+    @patch("sys.stderr")
+    @patch("builtins.print")
+    @patch("v4l2_compliance_test.parse_v4l2_compliance")
+    def test_report_correct_failures(
+        self,
+        mock_parser: MagicMock,
+        mock_print: MagicMock,
+        mock_stderr: MagicMock,
+    ):
+        mock_parser.return_value = (
+            {},
+            {
+                "succeeded": [],
+                "failed": ["VIDIOC_ENUM_FMT"],
+                "not_supported": [],
+            },
+        )
+
+        self.assertEqual(main_under_test(), 1)
+        mock_print.assert_called_with(
+            "VIDIOC_ENUM_FMT", "failed the test", file=mock_stderr
+        )
+
+        mock_print.reset_mock()
+        mock_parser.return_value = (
+            {},
+            {
+                "succeeded": [],
+                "failed": ["VIDIOC_QUERYCTRL"],
+                "not_supported": [],
+            },
+        )
+
+        self.assertEqual(main_under_test(), 1)
+        mock_print.assert_called_with(
+            "VIDIOC_QUERYCTRL", "failed the test", file=mock_stderr
+        )
+
+        mock_print.reset_mock()
+        mock_parser.return_value = (
+            {},
+            {
+                "succeeded": [],
+                "failed": ["VIDIOC_QUERYCTRL", "VIDIOC_ENUM_FMT"],
+                "not_supported": [],
+            },
+        )
+
+        self.assertEqual(main_under_test(), 1)
+        mock_print.assert_has_calls(
+            [
+                call(
+                    "Testing if all of the following ioctl requests",
+                    [
+                        "VIDIOC_ENUM_FMT",
+                        "VIDIOC_QUERYCTRL",
+                    ],
+                    "are supported on",
+                    "/dev/video1",
+                ),
+                call("VIDIOC_ENUM_FMT", "failed the test", file=mock_stderr),
+                call("VIDIOC_QUERYCTRL", "failed the test", file=mock_stderr),
+            ]
+        )
+
+
+if __name__ == "__main__":
+    ut.main()

providers/base/units/camera/jobs.pxu

@@ -22,6 +22,27 @@ command:
   udev_resource.py -f MMAL | grep "category: MMAL"
 _summary: Detect presence of a MMAL camera.
 
+id: camera/v4l2-ioctl_resource
+_summary: Generates ioctl names for v4l2 compliance test
+_description: Generates ioctl names for v4l2 compliance test
+estimated_duration: 0.02
+category_id: com.canonical.plainbox::camera
+plugin: resource
+command:
+  v4l2_ioctl_resource.py
+
+unit: template
+category_id: com.canonical.plainbox::camera
+template-resource: camera/v4l2-ioctl_resource
+template-unit: job
+template-id: camera/v4l2-compliance_ioctl_name
+_template-summary: To check if {ioctl_name} works on {name}
+id: camera/v4l2-compliance_{ioctl_name}
+_summary: v4l2 compliance for {ioctl_name} on {name}
+plugin: shell
+command:
+  v4l2_compliance_test.py --device /dev/{name} --ioctl {ioctl_name}
+
 unit: template
 template-resource: device
 template-filter: device.category == 'CAPTURE' and device.name != ''

providers/base/units/camera/test-plan.pxu

@@ -36,11 +36,13 @@ _description: Camera tests (automated)
 include:
  camera/detect                                     certification-status=blocker
  camera/multiple-resolution-images_.*              certification-status=blocker
+ camera/v4l2-compliance_.*                         certification-status=blocker
  camera/multiple-resolution-images-attachment_.*   certification-status=non-blocker
  camera/camera-quality_.*                          certification-status=non-blocker
  camera/camera-quality-image_.*                    certification-status=non-blocker
 bootstrap_include:
  device
+ camera/v4l2-ioctl_resource
 
 id: camera-cert-blockers
 unit: test plan

providers/resource/bin/v4l2_ioctl_resource.py

@@ -0,0 +1,23 @@
+#! /usr/bin/python3
+
+from checkbox_support.parsers.v4l2_compliance import TEST_NAME_TO_IOCTL_MAP
+import subprocess as sp
+
+
+def main():
+    udev_out = sp.check_output(
+        "udev_resource.py -f CAPTURE", universal_newlines=True, shell=True
+    )
+    lines = udev_out.splitlines()
+
+    for line in lines:
+        if line.startswith("name:"):
+            for ioctl_names in TEST_NAME_TO_IOCTL_MAP.values():
+                for name in ioctl_names:
+                    print(line)
+                    print("ioctl_name: {}".format(name))
+                    print()  # empty line to mark end of list item
+
+
+if __name__ == "__main__":
+    main()

providers/resource/tests/test_v4l2_compliance_resource.py

@@ -0,0 +1,55 @@
+import unittest as ut
+from unittest.mock import MagicMock, patch, call
+from v4l2_ioctl_resource import main as main_under_test
+from checkbox_support.parsers.v4l2_compliance import TEST_NAME_TO_IOCTL_MAP
+
+
+class TestV4L2IoctlResource(ut.TestCase):
+    @patch("v4l2_ioctl_resource.sp.check_output")
+    def test_all_ioctl_names_are_generated(self, mock_check_output: MagicMock):
+        mock_check_output.return_value = "\n".join(
+            [
+                "path: /devices/pci0000:00/0000:00:14.0/usb3/"
+                + "3-9/3-9:1.0/video4linux/video0",
+                "name: video0",
+                "bus: video4linux",
+                "category: CAPTURE",
+                "driver: uvcvideo",
+                "product_id: 22782",
+                "vendor_id: 3034",
+                "product: Integrated_Webcam_HD: Integrate",
+                "vendor: CN0PW36V8LG009BQA0YWA00",
+                "product_slug: Integrated_Webcam_HD__Integrate",
+                "vendor_slug: CN0PW36V8LG009BQA0YWA00",
+                "",
+                "path: /devices/pci0000:00/0000:00:14.0/usb3/"
+                + "3-9/3-9:1.0/video4linux/video1",
+                "name: video1",
+                "bus: video4linux",
+                "category: CAPTURE",
+                "driver: uvcvideo",
+                "product_id: 2312312",
+                "vendor_id: 12213",
+                "product: Integrated_Webcam_HD: Integrate",
+                "vendor: CN0PW36V3444438LG009BQA0YWA00",
+                "product_slug: Integrated_Webcam_HD__Integrate",
+                "vendor_slug: CN0PW36V8LG009BQA0YWA00",
+            ]
+        )
+
+        with patch("builtins.print") as mock_print:
+            main_under_test()
+            expected_calls = []
+            for name in "video0", "video1":
+                for ioctl_names in TEST_NAME_TO_IOCTL_MAP.values():
+                    for ioctl_name in ioctl_names:
+                        expected_calls.append(call("name: {}".format(name)))
+                        expected_calls.append(
+                            call("ioctl_name: {}".format(ioctl_name))
+                        )
+                        expected_calls.append(call())
+            mock_print.assert_has_calls(expected_calls)
+
+
+if __name__ == "__main__":
+    ut.main()