19 files changed, 490 insertions, 68 deletions

diff --git a/test/camera/buffer_import.cpp b/test/camera/buffer_import.cpp
index 92884004..815d1cae 100644
--- a/test/camera/buffer_import.cpp
+++ b/test/camera/buffer_import.cpp
@@ -63,6 +63,8 @@ protected:
 		request->reuse();
 		request->addBuffer(stream, buffer);
 		camera_->queueRequest(request);
+
+		dispatcher_->interrupt();
 	}
 
 	int init() override
@@ -76,6 +78,8 @@ protected:
 			return TestFail;
 		}
 
+		dispatcher_ = Thread::current()->eventDispatcher();
+
 		return TestPass;
 	}
 
@@ -133,17 +137,20 @@ protected:
 			}
 		}
 
-		EventDispatcher *dispatcher = Thread::current()->eventDispatcher();
+		const unsigned int nFrames = cfg.bufferCount * 2;
 
 		Timer timer;
-		timer.start(1000ms);
-		while (timer.isRunning())
-			dispatcher->processEvents();
+		timer.start(500ms * nFrames);
+		while (timer.isRunning()) {
+			dispatcher_->processEvents();
+			if (completeRequestsCount_ > nFrames)
+				break;
+		}
 
-		if (completeRequestsCount_ < cfg.bufferCount * 2) {
+		if (completeRequestsCount_ < nFrames) {
 			std::cout << "Failed to capture enough frames (got "
 				  << completeRequestsCount_ << " expected at least "
-				  << cfg.bufferCount * 2 << ")" << std::endl;
+				  << nFrames << ")" << std::endl;
 			return TestFail;
 		}
 
@@ -161,6 +168,8 @@ protected:
 	}
 
 private:
+	EventDispatcher *dispatcher_;
+
 	std::vector<std::unique_ptr<Request>> requests_;
 
 	unsigned int completeBuffersCount_;
diff --git a/test/camera/capture.cpp b/test/camera/capture.cpp
index de824083..8766fb19 100644
--- a/test/camera/capture.cpp
+++ b/test/camera/capture.cpp
@@ -59,6 +59,8 @@ protected:
 		request->reuse();
 		request->addBuffer(stream, buffer);
 		camera_->queueRequest(request);
+
+		dispatcher_->interrupt();
 	}
 
 	int init() override
@@ -73,6 +75,7 @@ protected:
 		}
 
 		allocator_ = new FrameBufferAllocator(camera_);
+		dispatcher_ = Thread::current()->eventDispatcher();
 
 		return TestPass;
 	}
@@ -135,19 +138,20 @@ protected:
 			}
 		}
 
-		EventDispatcher *dispatcher = Thread::current()->eventDispatcher();
+		unsigned int nFrames = allocator_->buffers(stream).size() * 2;
 
 		Timer timer;
-		timer.start(1000ms);
-		while (timer.isRunning())
-			dispatcher->processEvents();
-
-		unsigned int nbuffers = allocator_->buffers(stream).size();
+		timer.start(500ms * nFrames);
+		while (timer.isRunning()) {
+			dispatcher_->processEvents();
+			if (completeRequestsCount_ > nFrames)
+				break;
+		}
 
-		if (completeRequestsCount_ < nbuffers * 2) {
+		if (completeRequestsCount_ < nFrames) {
 			cout << "Failed to capture enough frames (got "
 			     << completeRequestsCount_ << " expected at least "
-			     << nbuffers * 2 << ")" << endl;
+			     << nFrames * 2 << ")" << endl;
 			return TestFail;
 		}
 
@@ -164,6 +168,8 @@ protected:
 		return TestPass;
 	}
 
+	EventDispatcher *dispatcher_;
+
 	std::vector<std::unique_ptr<Request>> requests_;
 
 	std::unique_ptr<CameraConfiguration> config_;
diff --git a/test/fence.cpp b/test/fence.cpp
index ada650ff..8095b228 100644
--- a/test/fence.cpp
+++ b/test/fence.cpp
@@ -43,7 +43,6 @@ private:
 
 	void signalFence();
 
-	std::unique_ptr<Fence> fence_;
 	EventDispatcher *dispatcher_;
 	UniqueFD eventFd_;
 	UniqueFD eventFd2_;
@@ -58,8 +57,11 @@ private:
 	bool expectedCompletionResult_ = true;
 	bool setFence_ = true;
 
-	unsigned int completedRequest_;
-
+	/*
+	 * Request IDs track the number of requests that have completed. They
+	 * are one-based, and don't wrap.
+	 */
+	unsigned int completedRequestId_;
 	unsigned int signalledRequestId_;
 	unsigned int expiredRequestId_;
 	unsigned int nbuffers_;
@@ -127,8 +129,19 @@ int FenceTest::init()
 		return TestFail;
 	}
 
-	signalledRequestId_ = nbuffers_ - 2;
-	expiredRequestId_ = nbuffers_ - 1;
+	completedRequestId_ = 0;
+
+	/*
+	 * All but two requests are queued without a fence. Request
+	 * expiredRequestId_ will be queued with a fence that we won't signal
+	 * (which is then expected to expire), and request signalledRequestId_
+	 * will be queued with a fence that gets signalled. Select nbuffers_
+	 * and nbuffers_ * 2 for those two requests, to space them by a few
+	 * frames while still not requiring a long time for the test to
+	 * complete.
+	 */
+	expiredRequestId_ = nbuffers_;
+	signalledRequestId_ = nbuffers_ * 2;
 
 	return TestPass;
 }
@@ -190,16 +203,16 @@ void FenceTest::requestRequeue(Request *request)
 	const Request::BufferMap &buffers = request->buffers();
 	const Stream *stream = buffers.begin()->first;
 	FrameBuffer *buffer = buffers.begin()->second;
-	uint64_t cookie = request->cookie();
 
 	request->reuse();
 
-	if (cookie == signalledRequestId_ && setFence_) {
+	if (completedRequestId_ == signalledRequestId_ - nbuffers_ && setFence_) {
 		/*
-		 * The second time this request is queued add a fence to it.
-		 *
-		 * The main loop signals it by using a timer to write to the
-		 * efd2_ file descriptor before the fence expires.
+		 * This is the request that will be used to test fence
+		 * signalling when it completes next time. Add a fence to it,
+		 * using efd2_. The main loop will signal the fence by using a
+		 * timer to write to the efd2_ file descriptor before the fence
+		 * expires.
 		 */
 		std::unique_ptr<Fence> fence =
 			std::make_unique<Fence>(std::move(eventFd2_));
@@ -214,16 +227,15 @@ void FenceTest::requestRequeue(Request *request)
 
 void FenceTest::requestComplete(Request *request)
 {
-	uint64_t cookie = request->cookie();
-	completedRequest_ = cookie;
+	completedRequestId_++;
 
 	/*
-	 * The last request is expected to fail as its fence has not been
-	 * signaled.
+	 * Request expiredRequestId_ is expected to fail as its fence has not
+	 * been signalled.
 	 *
 	 * Validate the fence status but do not re-queue it.
 	 */
-	if (cookie == expiredRequestId_) {
+	if (completedRequestId_ == expiredRequestId_) {
 		if (validateExpiredRequest(request) != TestPass)
 			expectedCompletionResult_ = false;
 
@@ -231,7 +243,7 @@ void FenceTest::requestComplete(Request *request)
 		return;
 	}
 
-	/* Validate all requests but the last. */
+	/* Validate all other requests. */
 	if (validateRequest(request) != TestPass) {
 		expectedCompletionResult_ = false;
 
@@ -272,15 +284,16 @@ int FenceTest::run()
 		}
 
 		int ret;
-		if (i == expiredRequestId_) {
+		if (i == expiredRequestId_ - 1) {
 			/* This request will have a fence, and it will expire. */
-			fence_ = std::make_unique<Fence>(std::move(eventFd_));
-			if (!fence_->isValid()) {
+			std::unique_ptr<Fence> fence =
+				std::make_unique<Fence>(std::move(eventFd_));
+			if (!fence->isValid()) {
 				cerr << "Fence should be valid" << endl;
 				return TestFail;
 			}
 
-			ret = request->addBuffer(stream_, buffer.get(), std::move(fence_));
+			ret = request->addBuffer(stream_, buffer.get(), std::move(fence));
 		} else {
 			/* All other requests will have no Fence. */
 			ret = request->addBuffer(stream_, buffer.get());
@@ -314,15 +327,21 @@ int FenceTest::run()
 	Timer fenceTimer;
 	fenceTimer.timeout.connect(this, &FenceTest::signalFence);
 
-	/* Loop for one second. */
+	/*
+	 * Loop long enough for all requests to complete, allowing 500ms per
+	 * request.
+	 */
 	Timer timer;
-	timer.start(1000ms);
-	while (timer.isRunning() && expectedCompletionResult_) {
-		if (completedRequest_ == signalledRequestId_ && setFence_)
+	timer.start(500ms * (signalledRequestId_ + 1));
+	while (timer.isRunning() && expectedCompletionResult_ &&
+	       completedRequestId_ <= signalledRequestId_ + 1) {
+		if (completedRequestId_ == signalledRequestId_ - 1 && setFence_)
 			/*
-			 * signalledRequestId_ has just completed and it has
-			 * been re-queued with a fence. Start the timer to
-			 * signal the fence in 10 msec.
+			 * The request just before signalledRequestId_ has just
+			 * completed. Request signalledRequestId_ has been
+			 * queued with a fence, and libcamera is likely already
+			 * waiting on the fence, or will soon. Start the timer
+			 * to signal the fence in 10 msec.
 			 */
 			fenceTimer.start(10ms);
 
diff --git a/test/geometry.cpp b/test/geometry.cpp
index 64169206..5760fa3c 100644
--- a/test/geometry.cpp
+++ b/test/geometry.cpp
@@ -481,6 +481,20 @@ protected:
 			return TestFail;
 		}
 
+		Point topLeft(3, 3);
+		Point bottomRight(30, 30);
+		Point topRight(30, 3);
+		Point bottomLeft(3, 30);
+		Rectangle rect1(topLeft, bottomRight);
+		Rectangle rect2(topRight, bottomLeft);
+		Rectangle rect3(bottomRight, topLeft);
+		Rectangle rect4(bottomLeft, topRight);
+
+		if (rect1 != rect2 || rect1 != rect3 || rect1 != rect4) {
+			cout << "Point-to-point construction failed" << endl;
+			return TestFail;
+		}
+
 		return TestPass;
 	}
 };
diff --git a/test/gstreamer/gstreamer_memory_lifetime_test.cpp b/test/gstreamer/gstreamer_memory_lifetime_test.cpp
new file mode 100644
index 00000000..1738cf56
--- /dev/null
+++ b/test/gstreamer/gstreamer_memory_lifetime_test.cpp
@@ -0,0 +1,90 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2024, Nicolas Dufresne
+ *
+ * gstreamer_memory_lifetime_test.cpp - GStreamer memory lifetime test
+ */
+
+#include <iostream>
+#include <unistd.h>
+
+#include <gst/app/app.h>
+#include <gst/gst.h>
+
+#include "gstreamer_test.h"
+#include "test.h"
+
+using namespace std;
+
+class GstreamerMemoryLifetimeTest : public GstreamerTest, public Test
+{
+public:
+	GstreamerMemoryLifetimeTest()
+		: GstreamerTest()
+	{
+	}
+
+protected:
+	int init() override
+	{
+		if (status_ != TestPass)
+			return status_;
+
+		appsink_ = gst_element_factory_make("appsink", nullptr);
+		if (!appsink_) {
+			g_printerr("Your installation is missing 'appsink'\n");
+			return TestFail;
+		}
+		g_object_ref_sink(appsink_);
+
+		return createPipeline();
+	}
+
+	int run() override
+	{
+		/* Build the pipeline */
+		gst_bin_add_many(GST_BIN(pipeline_), libcameraSrc_, appsink_, nullptr);
+		if (gst_element_link(libcameraSrc_, appsink_) != TRUE) {
+			g_printerr("Elements could not be linked.\n");
+			return TestFail;
+		}
+
+		if (startPipeline() != TestPass)
+			return TestFail;
+
+		sample_ = gst_app_sink_try_pull_sample(GST_APP_SINK(appsink_), GST_SECOND * 5);
+		if (!sample_) {
+			/* Failed to obtain a sample. Abort the test */
+			gst_element_set_state(pipeline_, GST_STATE_NULL);
+			return TestFail;
+		}
+
+		/*
+		 * Keep the sample referenced and set the pipeline state to
+		 * NULL. This causes the libcamerasrc element to synchronously
+		 * release resources it holds. The sample will be released
+		 * later in cleanup().
+		 *
+		 * The test case verifies that libcamerasrc keeps alive long
+		 * enough all the resources that are needed until memory
+		 * allocated for frames gets freed. We return TestPass at this
+		 * stage, and any use-after-free will be caught by the test
+		 * crashing in cleanup().
+		 */
+		gst_element_set_state(pipeline_, GST_STATE_NULL);
+
+		return TestPass;
+	}
+
+	void cleanup() override
+	{
+		g_clear_pointer(&sample_, gst_sample_unref);
+		g_clear_object(&appsink_);
+	}
+
+private:
+	GstElement *appsink_;
+	GstSample *sample_;
+};
+
+TEST_REGISTER(GstreamerMemoryLifetimeTest)
diff --git a/test/gstreamer/gstreamer_test.cpp b/test/gstreamer/gstreamer_test.cpp
index e8119b85..a15fef0e 100644
--- a/test/gstreamer/gstreamer_test.cpp
+++ b/test/gstreamer/gstreamer_test.cpp
@@ -9,12 +9,17 @@
 
 #include <libcamera/base/utils.h>
 
+#if HAVE_ASAN
+#include <sanitizer/asan_interface.h>
+#endif
+
 #include "gstreamer_test.h"
 
 #include "test.h"
 
 using namespace std;
 
+#if HAVE_ASAN
 extern "C" {
 const char *__asan_default_options()
 {
@@ -26,6 +31,7 @@ const char *__asan_default_options()
 	return "detect_leaks=false";
 }
 }
+#endif
 
 GstreamerTest::GstreamerTest(unsigned int numStreams)
 	: pipeline_(nullptr), libcameraSrc_(nullptr)
diff --git a/test/gstreamer/meson.build b/test/gstreamer/meson.build
index f3ba5a23..e066c582 100644
--- a/test/gstreamer/meson.build
+++ b/test/gstreamer/meson.build
@@ -8,14 +8,24 @@ gstreamer_tests = [
     {'name': 'single_stream_test', 'sources': ['gstreamer_single_stream_test.cpp']},
     {'name': 'multi_stream_test', 'sources': ['gstreamer_multi_stream_test.cpp']},
     {'name': 'device_provider_test', 'sources': ['gstreamer_device_provider_test.cpp']},
+    {'name': 'memory_lifetime_test', 'sources': ['gstreamer_memory_lifetime_test.cpp']},
 ]
 gstreamer_dep = dependency('gstreamer-1.0', required : true)
+gstapp_dep = dependency('gstreamer-app-1.0', required : true)
+
+gstreamer_test_args = []
+
+if asan_enabled
+    gstreamer_test_args += ['-D', 'HAVE_ASAN=1']
+endif
 
 foreach test : gstreamer_tests
     exe = executable(test['name'], test['sources'], 'gstreamer_test.cpp',
-                     dependencies : [libcamera_private, gstreamer_dep],
+                     cpp_args : gstreamer_test_args,
+                     dependencies : [libcamera_private, gstreamer_dep, gstapp_dep],
                      link_with : test_libraries,
                      include_directories : test_includes_internal)
 
-    test(test['name'], exe, suite : 'gstreamer', is_parallel : false, env : gst_env)
+    test(test['name'], exe, suite : 'gstreamer', is_parallel : false,
+         env : gst_env, should_fail : test.get('should_fail', false))
 endforeach
diff --git a/test/ipa/ipa_interface_test.cpp b/test/ipa/ipa_interface_test.cpp
index e840f6ab..b8178366 100644
--- a/test/ipa/ipa_interface_test.cpp
+++ b/test/ipa/ipa_interface_test.cpp
@@ -20,11 +20,11 @@
 #include <libcamera/base/thread.h>
 #include <libcamera/base/timer.h>
 
+#include "libcamera/internal/camera_manager.h"
 #include "libcamera/internal/device_enumerator.h"
 #include "libcamera/internal/ipa_manager.h"
 #include "libcamera/internal/ipa_module.h"
 #include "libcamera/internal/pipeline_handler.h"
-#include "libcamera/internal/process.h"
 
 #include "test.h"
 
@@ -44,20 +44,20 @@ public:
 	{
 		delete notifier_;
 		ipa_.reset();
-		ipaManager_.reset();
+		cameraManager_.reset();
 	}
 
 protected:
 	int init() override
 	{
-		ipaManager_ = make_unique<IPAManager>();
+		cameraManager_ = make_unique<CameraManager>();
 
 		/* Create a pipeline handler for vimc. */
 		const std::vector<PipelineHandlerFactoryBase *> &factories =
 			PipelineHandlerFactoryBase::factories();
 		for (const PipelineHandlerFactoryBase *factory : factories) {
 			if (factory->name() == "vimc") {
-				pipe_ = factory->create(nullptr);
+				pipe_ = factory->create(cameraManager_.get());
 				break;
 			}
 		}
@@ -171,11 +171,9 @@ private:
 		}
 	}
 
-	ProcessManager processManager_;
-
 	std::shared_ptr<PipelineHandler> pipe_;
 	std::unique_ptr<ipa::vimc::IPAProxyVimc> ipa_;
-	std::unique_ptr<IPAManager> ipaManager_;
+	std::unique_ptr<CameraManager> cameraManager_;
 	enum ipa::vimc::IPAOperationCode trace_;
 	EventNotifier *notifier_;
 	int fd_;
diff --git a/test/ipa/libipa/interpolator.cpp b/test/ipa/libipa/interpolator.cpp
new file mode 100644
index 00000000..6abb7760
--- /dev/null
+++ b/test/ipa/libipa/interpolator.cpp
@@ -0,0 +1,54 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2024, Ideas on Board Oy
+ *
+ * Interpolator tests
+ */
+
+#include "../src/ipa/libipa/interpolator.h"
+
+#include <cmath>
+#include <iostream>
+#include <map>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "test.h"
+
+using namespace std;
+using namespace libcamera;
+using namespace ipa;
+
+#define ASSERT_EQ(a, b)                    \
+	if ((a) != (b)) {                  \
+		printf(#a " != " #b "\n"); \
+		return TestFail;           \
+	}
+
+class InterpolatorTest : public Test
+{
+protected:
+	int run()
+	{
+		Interpolator<int> interpolator;
+		interpolator.setData({ { 10, 100 }, { 20, 200 }, { 30, 300 } });
+
+		ASSERT_EQ(interpolator.getInterpolated(0), 100);
+		ASSERT_EQ(interpolator.getInterpolated(10), 100);
+		ASSERT_EQ(interpolator.getInterpolated(20), 200);
+		ASSERT_EQ(interpolator.getInterpolated(25), 250);
+		ASSERT_EQ(interpolator.getInterpolated(30), 300);
+		ASSERT_EQ(interpolator.getInterpolated(40), 300);
+
+		interpolator.setQuantization(10);
+		unsigned int q = 0;
+		ASSERT_EQ(interpolator.getInterpolated(25, &q), 300);
+		ASSERT_EQ(q, 30);
+		ASSERT_EQ(interpolator.getInterpolated(24, &q), 200);
+		ASSERT_EQ(q, 20);
+
+		return TestPass;
+	}
+};
+
+TEST_REGISTER(InterpolatorTest)
diff --git a/test/ipa/libipa/meson.build b/test/ipa/libipa/meson.build
new file mode 100644
index 00000000..4d2427db
--- /dev/null
+++ b/test/ipa/libipa/meson.build
@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: CC0-1.0
+
+libipa_test = [
+    {'name': 'interpolator', 'sources': ['interpolator.cpp']},
+]
+
+foreach test : libipa_test
+    exe = executable(test['name'], test['sources'],
+                     dependencies : [libcamera_private, libipa_dep],
+                     link_with : [test_libraries],
+                     include_directories : [test_includes_internal,
+                                            '../../../src/ipa/libipa/'])
+
+    test(test['name'], exe, suite : 'ipa')
+endforeach
diff --git a/test/ipa/meson.build b/test/ipa/meson.build
index 180b0da0..63820de5 100644
--- a/test/ipa/meson.build
+++ b/test/ipa/meson.build
@@ -1,15 +1,18 @@
 # SPDX-License-Identifier: CC0-1.0
 
+subdir('libipa')
+subdir('rkisp1')
+
 ipa_test = [
     {'name': 'ipa_module_test', 'sources': ['ipa_module_test.cpp']},
     {'name': 'ipa_interface_test', 'sources': ['ipa_interface_test.cpp']},
 ]
 
 foreach test : ipa_test
-    exe = executable(test['name'], test['sources'], libcamera_generated_ipa_headers,
-                     dependencies : libcamera_private,
-                     link_with : [libipa, test_libraries],
-                     include_directories : [libipa_includes, test_includes_internal])
+    exe = executable(test['name'], test['sources'],
+                     dependencies : [libcamera_private, libipa_dep],
+                     link_with : [test_libraries],
+                     include_directories : [test_includes_internal])
 
     test(test['name'], exe, suite : 'ipa')
 endforeach
diff --git a/test/ipa/rkisp1/meson.build b/test/ipa/rkisp1/meson.build
new file mode 100644
index 00000000..894523da
--- /dev/null
+++ b/test/ipa/rkisp1/meson.build
@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: CC0-1.0
+
+rkisp1_ipa_test = [
+    {'name': 'rkisp1-utils', 'sources': ['rkisp1-utils.cpp']},
+]
+
+foreach test : rkisp1_ipa_test
+    exe = executable(test['name'], test['sources'],
+                     dependencies : [libcamera_private, libipa_dep],
+                     link_with : [test_libraries],
+                     include_directories : [test_includes_internal,
+                                            '../../../src/ipa/rkisp1/'])
+
+    test(test['name'], exe, suite : 'ipa')
+endforeach
diff --git a/test/ipa/rkisp1/rkisp1-utils.cpp b/test/ipa/rkisp1/rkisp1-utils.cpp
new file mode 100644
index 00000000..b1863894
--- /dev/null
+++ b/test/ipa/rkisp1/rkisp1-utils.cpp
@@ -0,0 +1,108 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2024, Paul Elder <paul.elder@ideasonboard.com>
+ *
+ * Miscellaneous utility tests
+ */
+
+#include <cmath>
+#include <iostream>
+#include <map>
+#include <stdint.h>
+
+#include "../src/ipa/rkisp1/utils.h"
+
+#include "test.h"
+
+using namespace std;
+using namespace libcamera;
+using namespace ipa::rkisp1;
+
+class RkISP1UtilsTest : public Test
+{
+protected:
+	/* R for real, I for integer */
+	template<unsigned int IntPrec, unsigned int FracPrec, typename I, typename R>
+	int testFixedToFloat(I input, R expected)
+	{
+		R out = utils::fixedToFloatingPoint<IntPrec, FracPrec, R>(input);
+		R prec = 1.0 / (1 << FracPrec);
+		if (std::abs(out - expected) > prec) {
+			cerr << "Reverse conversion expected " << input
+			     << " to convert to " << expected
+			     << ", got " << out << std::endl;
+			return TestFail;
+		}
+
+		return TestPass;
+	}
+
+	template<unsigned int IntPrec, unsigned int FracPrec, typename T>
+	int testSingleFixedPoint(double input, T expected)
+	{
+		T ret = utils::floatingToFixedPoint<IntPrec, FracPrec, T>(input);
+		if (ret != expected) {
+			cerr << "Expected " << input << " to convert to "
+			     << expected << ", got " << ret << std::endl;
+			return TestFail;
+		}
+
+		/*
+		 * The precision check is fairly arbitrary but is based on what
+		 * the rkisp1 is capable of in the crosstalk module.
+		 */
+		double f = utils::fixedToFloatingPoint<IntPrec, FracPrec, double>(ret);
+		if (std::abs(f - input) > 0.005) {
+			cerr << "Reverse conversion expected " << ret
+			     << " to convert to " << input
+			     << ", got " << f << std::endl;
+			return TestFail;
+		}
+
+		return TestPass;
+	}
+
+	int testFixedPoint()
+	{
+		/*
+		 * The second 7.992 test is to test that unused bits don't
+		 * affect the result.
+		 */
+		std::map<double, uint16_t> testCases = {
+			{ 7.992, 0x3ff },
+			{   0.2, 0x01a },
+			{  -0.2, 0x7e6 },
+			{  -0.8, 0x79a },
+			{  -0.4, 0x7cd },
+			{  -1.4, 0x74d },
+			{    -8, 0x400 },
+			{     0, 0 },
+		};
+
+		int ret;
+		for (const auto &testCase : testCases) {
+			ret = testSingleFixedPoint<4, 7, uint16_t>(testCase.first,
+								   testCase.second);
+			if (ret != TestPass)
+				return ret;
+		}
+
+		/* Special case with a superfluous one in the unused bits */
+		ret = testFixedToFloat<4, 7, uint16_t, double>(0xbff, 7.992);
+		if (ret != TestPass)
+			return ret;
+
+		return TestPass;
+	}
+
+	int run()
+	{
+		/* fixed point conversion test */
+		if (testFixedPoint() != TestPass)
+			return TestFail;
+
+		return TestPass;
+	}
+};
+
+TEST_REGISTER(RkISP1UtilsTest)
diff --git a/test/ipc/unixsocket.cpp b/test/ipc/unixsocket.cpp
index f44ab9c9..f39bd986 100644
--- a/test/ipc/unixsocket.cpp
+++ b/test/ipc/unixsocket.cpp
@@ -15,6 +15,7 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <vector>
 
 #include <libcamera/base/event_dispatcher.h>
 #include <libcamera/base/thread.h>
@@ -34,6 +35,8 @@ using namespace libcamera;
 using namespace std;
 using namespace std::chrono_literals;
 
+namespace {
+
 int calculateLength(int fd)
 {
 	lseek(fd, 0, 0);
@@ -43,6 +46,8 @@ int calculateLength(int fd)
 	return size;
 }
 
+} /* namespace */
+
 class UnixSocketTestSlave
 {
 public:
@@ -336,14 +341,14 @@ protected:
 
 		for (unsigned int i = 0; i < std::size(strings); i++) {
 			unsigned int len = strlen(strings[i]);
-			char buf[len];
+			std::vector<char> buf(len);
 
 			close(fds[i]);
 
-			if (read(response.fds[0], &buf, len) <= 0)
+			if (read(response.fds[0], buf.data(), len) <= 0)
 				return TestFail;
 
-			if (memcmp(buf, strings[i], len))
+			if (memcmp(buf.data(), strings[i], len))
 				return TestFail;
 		}
 
diff --git a/test/serialization/generated_serializer/generated_serializer_test.cpp b/test/serialization/generated_serializer/generated_serializer_test.cpp
index 4b11d67f..dd696885 100644
--- a/test/serialization/generated_serializer/generated_serializer_test.cpp
+++ b/test/serialization/generated_serializer/generated_serializer_test.cpp
@@ -6,6 +6,7 @@
  */
 
 #include <algorithm>
+#include <iostream>
 #include <tuple>
 #include <vector>
 
diff --git a/test/serialization/generated_serializer/include/libcamera/ipa/meson.build b/test/serialization/generated_serializer/include/libcamera/ipa/meson.build
index 6f8794c1..ae08e9be 100644
--- a/test/serialization/generated_serializer/include/libcamera/ipa/meson.build
+++ b/test/serialization/generated_serializer/include/libcamera/ipa/meson.build
@@ -9,7 +9,8 @@ mojom = custom_target('test_mojom_module',
                           '--output-root', meson.project_build_root(),
                           '--input-root', meson.project_source_root(),
                           '--mojoms', '@INPUT@'
-                      ])
+                      ],
+                      env : py_build_env)
 
 # test_ipa_interface.h
 generated_test_header = custom_target('test_ipa_interface_h',
@@ -23,7 +24,8 @@ generated_test_header = custom_target('test_ipa_interface_h',
                            '--libcamera_generate_header',
                            '--libcamera_output_path=@OUTPUT@',
                            './' +'@INPUT@'
-                       ])
+                       ],
+                       env : py_build_env)
 
 # test_ipa_serializer.h
 generated_test_serializer = custom_target('test_ipa_serializer_h',
@@ -37,4 +39,5 @@ generated_test_serializer = custom_target('test_ipa_serializer_h',
                                '--libcamera_generate_serializer',
                                '--libcamera_output_path=@OUTPUT@',
                                './' +'@INPUT@'
-                           ])
+                           ],
+                           env : py_build_env)
diff --git a/test/utils.cpp b/test/utils.cpp
index 41af954b..d25475cb 100644
--- a/test/utils.cpp
+++ b/test/utils.cpp
@@ -176,6 +176,14 @@ protected:
 		std::ostringstream os;
 		std::string ref;
 
+		os << utils::hex(static_cast<int8_t>(0x42)) << " ";
+		ref += "0x42 ";
+		os << utils::hex(static_cast<uint8_t>(0x42)) << " ";
+		ref += "0x42 ";
+		os << utils::hex(static_cast<int16_t>(0x42)) << " ";
+		ref += "0x0042 ";
+		os << utils::hex(static_cast<uint16_t>(0x42)) << " ";
+		ref += "0x0042 ";
 		os << utils::hex(static_cast<int32_t>(0x42)) << " ";
 		ref += "0x00000042 ";
 		os << utils::hex(static_cast<uint32_t>(0x42)) << " ";
@@ -184,6 +192,15 @@ protected:
 		ref += "0x0000000000000042 ";
 		os << utils::hex(static_cast<uint64_t>(0x42)) << " ";
 		ref += "0x0000000000000042 ";
+
+		os << utils::hex(static_cast<int8_t>(0x42), 6) << " ";
+		ref += "0x000042 ";
+		os << utils::hex(static_cast<uint8_t>(0x42), 1) << " ";
+		ref += "0x42 ";
+		os << utils::hex(static_cast<int16_t>(0x42), 6) << " ";
+		ref += "0x000042 ";
+		os << utils::hex(static_cast<uint16_t>(0x42), 1) << " ";
+		ref += "0x42 ";
 		os << utils::hex(static_cast<int32_t>(0x42), 4) << " ";
 		ref += "0x0042 ";
 		os << utils::hex(static_cast<uint32_t>(0x42), 1) << " ";
diff --git a/test/v4l2_videodevice/capture_async.cpp b/test/v4l2_videodevice/capture_async.cpp
index 42e1e671..67366461 100644
--- a/test/v4l2_videodevice/capture_async.cpp
+++ b/test/v4l2_videodevice/capture_async.cpp
@@ -61,10 +61,12 @@ protected:
 		if (ret)
 			return TestFail;
 
-		timeout.start(10000ms);
+		const unsigned int nFrames = 30;
+
+		timeout.start(500ms * nFrames);
 		while (timeout.isRunning()) {
 			dispatcher->processEvents();
-			if (frames > 30)
+			if (frames > nFrames)
 				break;
 		}
 
@@ -73,8 +75,9 @@ protected:
 			return TestFail;
 		}
 
-		if (frames < 30) {
-			std::cout << "Failed to capture 30 frames within timeout." << std::endl;
+		if (frames < nFrames) {
+			std::cout << "Failed to capture " << nFrames
+				  << " frames within timeout." << std::endl;
 			return TestFail;
 		}
 
diff --git a/test/yaml-parser.cpp b/test/yaml-parser.cpp
index 81c82983..1b22c87b 100644
--- a/test/yaml-parser.cpp
+++ b/test/yaml-parser.cpp
@@ -34,10 +34,12 @@ static const string testYaml =
 	"list:\n"
 	"  - James\n"
 	"  - Mary\n"
+	"  - \n"
 	"dictionary:\n"
 	"  a: 1\n"
 	"  c: 3\n"
 	"  b: 2\n"
+	"  empty:\n"
 	"level1:\n"
 	"  level2:\n"
 	"    - [1, 2]\n"
@@ -430,9 +432,10 @@ protected:
 		if (testObjectType(listObj, "list", Type::List) != TestPass)
 			return TestFail;
 
-		static constexpr std::array<const char *, 2> listValues{
+		static constexpr std::array<const char *, 3> listValues{
 			"James",
 			"Mary",
+			"",
 		};
 
 		if (listObj.size() != listValues.size()) {
@@ -465,16 +468,23 @@ protected:
 			i++;
 		}
 
+		/* Ensure that empty objects get parsed as empty strings. */
+		if (!listObj[2].isValue()) {
+			cerr << "Empty object is not a value" << std::endl;
+			return TestFail;
+		}
+
 		/* Test dictionary object */
 		auto &dictObj = (*root)["dictionary"];
 
 		if (testObjectType(dictObj, "dictionary", Type::Dictionary) != TestPass)
 			return TestFail;
 
-		static constexpr std::array<std::pair<const char *, int>, 3> dictValues{ {
+		static constexpr std::array<std::pair<const char *, int>, 4> dictValues{ {
 			{ "a", 1 },
 			{ "c", 3 },
 			{ "b", 2 },
+			{ "empty", -100 },
 		} };
 
 		size_t dictSize = dictValues.size();
@@ -505,7 +515,7 @@ protected:
 				return TestFail;
 			}
 
-			if (elem.get<int32_t>(0) != item.second) {
+			if (elem.get<int32_t>(-100) != item.second) {
 				std::cerr << "Dictionary element " << i << " has wrong value"
 					  << std::endl;
 				return TestFail;
@@ -514,6 +524,42 @@ protected:
 			i++;
 		}
 
+		/* Ensure that empty objects get parsed as empty strings. */
+		if (!dictObj["empty"].isValue()) {
+			cerr << "Empty object is not of type value" << std::endl;
+			return TestFail;
+		}
+
+		/* Ensure that keys without values are added to a dict. */
+		if (!dictObj.contains("empty")) {
+			cerr << "Empty element is missing in dict" << std::endl;
+			return TestFail;
+		}
+
+		/* Test access to nonexistent member. */
+		if (dictObj["nonexistent"].get<std::string>("default") != "default") {
+			cerr << "Accessing nonexistent dict entry fails to return default" << std::endl;
+			return TestFail;
+		}
+
+		/* Test nonexistent object has value type empty. */
+		if (!dictObj["nonexistent"].isEmpty()) {
+			cerr << "Accessing nonexistent object returns non-empty object" << std::endl;
+			return TestFail;
+		}
+
+		/* Test explicit cast to bool on an empty object returns true. */
+		if (!!dictObj["empty"] != true) {
+			cerr << "Casting empty entry to bool returns false" << std::endl;
+			return TestFail;
+		}
+
+		/* Test explicit cast to bool on nonexistent object returns false. */
+		if (!!dictObj["nonexistent"] != false) {
+			cerr << "Casting nonexistent dict entry to bool returns true" << std::endl;
+			return TestFail;
+		}
+
 		/* Make sure utils::map_keys() works on the adapter. */
 		(void)utils::map_keys(dictObj.asDict());