lc-compliance: Add a libcamera compliance tool

Add a compliance tool to ease testing of cameras. In contrast to the
unit-tests under test/ that aims to test the internal components of
libcamera the compliance tool aims to test application use-cases and to
some extent the public API.

This change adds the boilerplate code of a simple framework for the
creation of tests. The tests aim both to demonstrate the tool and to
catch real problems. The tests added are:

 - Test that if one queues exactly N requests to a camera exactly N
   requests are eventually completed.

 - Test that a configured camera can be started and stopped multiple
   times in an attempt to exercise cleanup code paths otherwise not
   often tested with 'cam' for example.

Signed-off-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Acked-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
Tested-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Tested-by: Jean-Michel Hautbois <jeanmichel.hautbois@ideasonboard.com>

1 files changed, 74 insertions, 0 deletions

diff --git a/src/lc-compliance/single_stream.cpp b/src/lc-compliance/single_stream.cpp
new file mode 100644
index 00000000..e9ca1d58
--- /dev/null
+++ b/src/lc-compliance/single_stream.cpp
@@ -0,0 +1,74 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2020, Google Inc.
+ *
+ * single_stream.cpp - Test a single camera stream
+ */
+
+#include <iostream>
+
+#include "simple_capture.h"
+#include "tests.h"
+
+using namespace libcamera;
+
+Results::Result testRequestBalance(std::shared_ptr<Camera> camera,
+				   StreamRole role, unsigned int startCycles,
+				   unsigned int numRequests)
+{
+	SimpleCaptureBalanced capture(camera);
+
+	Results::Result ret = capture.configure(role);
+	if (ret.first != Results::Pass)
+		return ret;
+
+	for (unsigned int starts = 0; starts < startCycles; starts++) {
+		ret = capture.capture(numRequests);
+		if (ret.first != Results::Pass)
+			return ret;
+	}
+
+	return { Results::Pass, "Balanced capture of " +
+		std::to_string(numRequests) + " requests with " +
+		std::to_string(startCycles) + " start cycles" };
+}
+
+Results testSingleStream(std::shared_ptr<Camera> camera)
+{
+	static const std::vector<std::pair<std::string, StreamRole>> roles = {
+		{ "raw", Raw },
+		{ "still", StillCapture },
+		{ "video", VideoRecording },
+		{ "viewfinder", Viewfinder },
+	};
+	static const std::vector<unsigned int> numRequests = { 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
+
+	Results results(numRequests.size() * roles.size() * 2);
+
+	for (const auto &role : roles) {
+		std::cout << "= Test role " << role.first << std::endl;
+		/*
+		 * Test single capture cycles
+		 *
+		 * Makes sure the camera completes the exact number of requests queued.
+		 * Example failure is a camera that needs N+M requests queued to
+		 * complete N requests to the application.
+		 */
+		std::cout << "* Test single capture cycles" << std::endl;
+		for (unsigned int num : numRequests)
+			results.add(testRequestBalance(camera, role.second, 1, num));
+
+		/*
+		 * Test multiple start/stop cycles
+		 *
+		 * Makes sure the camera supports multiple start/stop cycles.
+		 * Example failure is a camera that does not clean up correctly in its
+		 * error path but is only tested by single-capture applications.
+		 */
+		std::cout << "* Test multiple start/stop cycles" << std::endl;
+		for (unsigned int num : numRequests)
+			results.add(testRequestBalance(camera, role.second, 3, num));
+	}
+
+	return results;
+}