PawletOS/external_libcamera
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lc-compliance: Refactor using Googletest

Browse Source 
Refactor lc-compliance using Googletest as the test framework.

Signed-off-by: Nícolas F. R. A. Prado <nfraprado@collabora.com>
Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>
Signed-off-by: Jacopo Mondi <jacopo@jmondi.org>
This commit is contained in:
Nícolas F. R. A. Prado
2021-07-02 09:21:13 -03:00
committed by Jacopo Mondi
parent e5c51e1fcf
commit bc87163779
9 changed files with 209 additions and 355 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
src/lc-compliance/capture_test.cpp Normal file
View File

@@ -0,0 +1,128 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2020, Google Inc.
* Copyright (C) 2021, Collabora Ltd.
*
* capture_test.cpp - Test camera capture
*/
#include <iostream>
#include <gtest/gtest.h>
#include "environment.h"
#include "simple_capture.h"
using namespace libcamera;
const std::vector<int> NUMREQUESTS = { 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
const std::vector<StreamRole> ROLES = { Raw, StillCapture, VideoRecording, Viewfinder };
class SingleStream : public testing::TestWithParam<std::tuple<StreamRole, int>>
{
public:
static std::string nameParameters(const testing::TestParamInfo<SingleStream::ParamType> &info);
protected:
void SetUp() override;
void TearDown() override;
std::shared_ptr<Camera> camera_;
};
/*
* We use gtest's SetUp() and TearDown() instead of constructor and destructor
* in order to be able to assert on them.
*/
void SingleStream::SetUp()
{
Environment *env = Environment::get();
camera_ = env->cm()->get(env->cameraId());
ASSERT_EQ(camera_->acquire(), 0);
}
void SingleStream::TearDown()
{
if (!camera_)
return;
camera_->release();
camera_.reset();
}
std::string SingleStream::nameParameters(const testing::TestParamInfo<SingleStream::ParamType> &info)
{
std::map<StreamRole, std::string> rolesMap = { { Raw, "Raw" },
{ StillCapture, "StillCapture" },
{ VideoRecording, "VideoRecording" },
{ Viewfinder, "Viewfinder" } };
std::string roleName = rolesMap[std::get<0>(info.param)];
std::string numRequestsName = std::to_string(std::get<1>(info.param));
return roleName + "_" + numRequestsName;
}
/*
* Test single capture cycles
*
* Makes sure the camera completes the exact number of requests queued. Example
* failure is a camera that completes less requests than the number of requests
* queued.
*/
TEST_P(SingleStream, Capture)
{
auto [role, numRequests] = GetParam();
SimpleCaptureBalanced capture(camera_);
capture.configure(role);
capture.capture(numRequests);
}
/*
* 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.
*/
TEST_P(SingleStream, CaptureStartStop)
{
auto [role, numRequests] = GetParam();
unsigned int numRepeats = 3;
SimpleCaptureBalanced capture(camera_);
capture.configure(role);
for (unsigned int starts = 0; starts < numRepeats; starts++)
capture.capture(numRequests);
}
/*
* Test unbalanced stop
*
* Makes sure the camera supports a stop with requests queued. Example failure
* is a camera that does not handle cancelation of buffers coming back from the
* video device while stopping.
*/
TEST_P(SingleStream, UnbalancedStop)
{
auto [role, numRequests] = GetParam();
SimpleCaptureUnbalanced capture(camera_);
capture.configure(role);
capture.capture(numRequests);
}
INSTANTIATE_TEST_SUITE_P(CaptureTests,
SingleStream,
testing::Combine(testing::ValuesIn(ROLES),
testing::ValuesIn(NUMREQUESTS)),
SingleStream::nameParameters);

107
src/lc-compliance/main.cpp
View File

@@ -1,6 +1,7 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2020, Google Inc.
* Copyright (C) 2021, Collabora Ltd.
*
* main.cpp - lc-compliance - The libcamera compliance tool
*/
@@ -9,10 +10,12 @@
#include <iostream>
#include <string.h>
#include <gtest/gtest.h>
#include <libcamera/libcamera.h>
#include "environment.h"
#include "../cam/options.h"
#include "tests.h"
using namespace libcamera;
@@ -21,97 +24,59 @@ enum {
OptHelp = 'h',
};
class Harness
/*
* Make asserts act like exceptions, otherwise they only fail (or skip) the
* current function. From gtest documentation:
* https://google.github.io/googletest/advanced.html#asserting-on-subroutines-with-an-exception
*/
class ThrowListener : public testing::EmptyTestEventListener
{
public:
Harness(const OptionsParser::Options &options);
~Harness();
int exec();
private:
int init();
void listCameras();
OptionsParser::Options options_;
std::unique_ptr<CameraManager> cm_;
std::shared_ptr<Camera> camera_;
void OnTestPartResult(const testing::TestPartResult &result) override
{
if (result.type() == testing::TestPartResult::kFatalFailure ||
result.type() == testing::TestPartResult::kSkip)
throw testing::AssertionException(result);
}
};
Harness::Harness(const OptionsParser::Options &options)
: options_(options)
static void listCameras(CameraManager *cm)
{
cm_ = std::make_unique<CameraManager>();
for (const std::shared_ptr<Camera> &cam : cm->cameras())
std::cout << "- " << cam.get()->id() << std::endl;
}
Harness::~Harness()
static int initCamera(CameraManager *cm, OptionsParser::Options options)
{
if (camera_) {
camera_->release();
camera_.reset();
}
std::shared_ptr<Camera> camera;
cm_->stop();
}
int Harness::exec()
{
int ret = init();
if (ret)
return ret;
std::vector<Results> results;
results.push_back(testSingleStream(camera_));
for (const Results &result : results) {
ret = result.summary();
if (ret)
return ret;
}
return 0;
}
int Harness::init()
{
int ret = cm_->start();
int ret = cm->start();
if (ret) {
std::cout << "Failed to start camera manager: "
<< strerror(-ret) << std::endl;
return ret;
}
if (!options_.isSet(OptCamera)) {
if (!options.isSet(OptCamera)) {
std::cout << "No camera specified, available cameras:" << std::endl;
listCameras();
listCameras(cm);
return -ENODEV;
}
const std::string &cameraId = options_[OptCamera];
camera_ = cm_->get(cameraId);
if (!camera_) {
const std::string &cameraId = options[OptCamera];
camera = cm->get(cameraId);
if (!camera) {
std::cout << "Camera " << cameraId << " not found, available cameras:" << std::endl;
listCameras();
listCameras(cm);
return -ENODEV;
}
if (camera_->acquire()) {
std::cout << "Failed to acquire camera" << std::endl;
return -EINVAL;
}
Environment::get()->setup(cm, cameraId);
std::cout << "Using camera " << cameraId << std::endl;
return 0;
}
void Harness::listCameras()
{
for (const std::shared_ptr<Camera> &cam : cm_->cameras())
std::cout << "- " << cam.get()->id() << std::endl;
}
static int parseOptions(int argc, char **argv, OptionsParser::Options *options)
{
OptionsParser parser;
@@ -142,7 +107,17 @@ int main(int argc, char **argv)
if (ret < 0)
return EXIT_FAILURE;
Harness harness(options);
std::unique_ptr<CameraManager> cm = std::make_unique<CameraManager>();
return harness.exec() ? EXIT_FAILURE : EXIT_SUCCESS;
ret = initCamera(cm.get(), options);
if (ret)
return ret;
testing::UnitTest::GetInstance()->listeners().Append(new ThrowListener);
ret = RUN_ALL_TESTS();
cm->stop();
return ret;
}

8
src/lc-compliance/meson.build
View File

@@ -1,8 +1,9 @@
# SPDX-License-Identifier: CC0-1.0
libevent = dependency('libevent_pthreads', required : get_option('lc-compliance'))
libgtest = dependency('gtest', required : get_option('lc-compliance'))
if not libevent.found()
if not (libevent.found() and libgtest.found())
lc_compliance_enabled = false
subdir_done()
endif
@@ -14,15 +15,16 @@ lc_compliance_sources = files([
'../cam/options.cpp',
'environment.cpp',
'main.cpp',
'results.cpp',
'simple_capture.cpp',
'single_stream.cpp',
'capture_test.cpp',
])
lc_compliance = executable('lc-compliance', lc_compliance_sources,
cpp_args : [ '-fexceptions' ],
dependencies : [
libatomic,
libcamera_public,
libevent,
libgtest,
],
install : true)

75
src/lc-compliance/results.cpp
View File

@@ -1,75 +0,0 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2020, Google Inc.
*
* results.cpp - Test result aggregator
*/
#include "results.h"
#include <iostream>
void Results::add(const Result &result)
{
if (result.first == Pass)
passed_++;
else if (result.first == Fail)
failed_++;
else if (result.first == Skip)
skipped_++;
printResult(result);
}
void Results::add(Status status, const std::string &message)
{
add({ status, message });
}
void Results::fail(const std::string &message)
{
add(Fail, message);
}
void Results::pass(const std::string &message)
{
add(Pass, message);
}
void Results::skip(const std::string &message)
{
add(Skip, message);
}
int Results::summary() const
{
if (failed_ + passed_ + skipped_ != planned_) {
std::cout << "Planned and executed number of tests differ "
<< failed_ + passed_ + skipped_ << " executed "
<< planned_ << " planned" << std::endl;
return -EINVAL;
}
std::cout << planned_ << " tests executed, "
<< passed_ << " tests passed, "
<< skipped_ << " tests skipped and "
<< failed_ << " tests failed " << std::endl;
return 0;
}
void Results::printResult(const Result &result)
{
std::string prefix;
/* \todo Make parsable as TAP. */
if (result.first == Pass)
prefix = "PASS";
else if (result.first == Fail)
prefix = "FAIL";
else if (result.first == Skip)
prefix = "SKIP";
std::cout << "- " << prefix << ": " << result.second << std::endl;
}

47
src/lc-compliance/results.h
View File

@@ -1,47 +0,0 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2020, Google Inc.
*
* results.h - Test result aggregator
*/
#ifndef __LC_COMPLIANCE_RESULTS_H__
#define __LC_COMPLIANCE_RESULTS_H__
#include <string>
#include <utility>
/* \todo Check if result aggregator can be shared with self tests in test/ */
class Results
{
public:
enum Status {
Fail,
Pass,
Skip,
};
using Result = std::pair<Status, std::string>;
Results(unsigned int planned)
: planned_(planned), passed_(0), failed_(0), skipped_(0)
{
}
void add(const Result &result);
void add(Status status, const std::string &message);
void fail(const std::string &message);
void pass(const std::string &message);
void skip(const std::string &message);
int summary() const;
private:
void printResult(const Result &result);
unsigned int planned_;
unsigned int passed_;
unsigned int failed_;
unsigned int skipped_;
};
#endif /* __LC_COMPLIANCE_RESULTS_H__ */

75
src/lc-compliance/simple_capture.cpp
View File

@@ -5,6 +5,8 @@
* simple_capture.cpp - Simple capture helper
*/
#include <gtest/gtest.h>
#include "simple_capture.h"
using namespace libcamera;
@@ -20,38 +22,37 @@ SimpleCapture::~SimpleCapture()
stop();
}
Results::Result SimpleCapture::configure(StreamRole role)
void SimpleCapture::configure(StreamRole role)
{
config_ = camera_->generateConfiguration({ role });
if (!config_)
return { Results::Skip, "Role not supported by camera" };
if (!config_) {
std::cout << "Role not supported by camera" << std::endl;
GTEST_SKIP();
}
if (config_->validate() != CameraConfiguration::Valid) {
config_.reset();
return { Results::Fail, "Configuration not valid" };
FAIL() << "Configuration not valid";
}
if (camera_->configure(config_.get())) {
config_.reset();
return { Results::Fail, "Failed to configure camera" };
FAIL() << "Failed to configure camera";
}
return { Results::Pass, "Configure camera" };
}
Results::Result SimpleCapture::start()
void SimpleCapture::start()
{
Stream *stream = config_->at(0).stream();
if (allocator_->allocate(stream) < 0)
return { Results::Fail, "Failed to allocate buffers" };
int count = allocator_->allocate(stream);
if (camera_->start())
return { Results::Fail, "Failed to start camera" };
ASSERT_GE(count, 0) << "Failed to allocate buffers";
EXPECT_EQ(count, config_->at(0).bufferCount) << "Allocated less buffers than expected";
camera_->requestCompleted.connect(this, &SimpleCapture::requestComplete);
return { Results::Pass, "Started camera" };
ASSERT_EQ(camera_->start(), 0) << "Failed to start camera";
}
void SimpleCapture::stop()
@@ -74,22 +75,19 @@ SimpleCaptureBalanced::SimpleCaptureBalanced(std::shared_ptr<Camera> camera)
{
}
Results::Result SimpleCaptureBalanced::capture(unsigned int numRequests)
void SimpleCaptureBalanced::capture(unsigned int numRequests)
{
Results::Result ret = start();
if (ret.first != Results::Pass)
return ret;
start();
Stream *stream = config_->at(0).stream();
const std::vector<std::unique_ptr<FrameBuffer>> &buffers = allocator_->buffers(stream);
/* No point in testing less requests then the camera depth. */
if (buffers.size() > numRequests) {
/* Cache buffers.size() before we destroy it in stop() */
int buffers_size = buffers.size();
return { Results::Skip, "Camera needs " + std::to_string(buffers_size)
+ " requests, can't test only " + std::to_string(numRequests) };
std::cout << "Camera needs " + std::to_string(buffers.size())
+ " requests, can't test only "
+ std::to_string(numRequests) << std::endl;
GTEST_SKIP();
}
queueCount_ = 0;
@@ -100,14 +98,11 @@ Results::Result SimpleCaptureBalanced::capture(unsigned int numRequests)
std::vector<std::unique_ptr<libcamera::Request>> requests;
for (const std::unique_ptr<FrameBuffer> &buffer : buffers) {
std::unique_ptr<Request> request = camera_->createRequest();
if (!request)
return { Results::Fail, "Can't create request" };
ASSERT_TRUE(request) << "Can't create request";
if (request->addBuffer(stream, buffer.get()))
return { Results::Fail, "Can't set buffer for request" };
ASSERT_EQ(request->addBuffer(stream, buffer.get()), 0) << "Can't set buffer for request";
if (queueRequest(request.get()) < 0)
return { Results::Fail, "Failed to queue request" };
ASSERT_EQ(queueRequest(request.get()), 0) << "Failed to queue request";
requests.push_back(std::move(request));
}
@@ -118,12 +113,7 @@ Results::Result SimpleCaptureBalanced::capture(unsigned int numRequests)
stop();
delete loop_;
if (captureCount_ != captureLimit_)
return { Results::Fail, "Got " + std::to_string(captureCount_) +
" request, wanted " + std::to_string(captureLimit_) };
return { Results::Pass, "Balanced capture of " +
std::to_string(numRequests) + " requests" };
ASSERT_EQ(captureCount_, captureLimit_);
}
int SimpleCaptureBalanced::queueRequest(Request *request)
@@ -155,11 +145,9 @@ SimpleCaptureUnbalanced::SimpleCaptureUnbalanced(std::shared_ptr<Camera> camera)
{
}
Results::Result SimpleCaptureUnbalanced::capture(unsigned int numRequests)
void SimpleCaptureUnbalanced::capture(unsigned int numRequests)
{
Results::Result ret = start();
if (ret.first != Results::Pass)
return ret;
start();
Stream *stream = config_->at(0).stream();
const std::vector<std::unique_ptr<FrameBuffer>> &buffers = allocator_->buffers(stream);
@@ -171,14 +159,11 @@ Results::Result SimpleCaptureUnbalanced::capture(unsigned int numRequests)
std::vector<std::unique_ptr<libcamera::Request>> requests;
for (const std::unique_ptr<FrameBuffer> &buffer : buffers) {
std::unique_ptr<Request> request = camera_->createRequest();
if (!request)
return { Results::Fail, "Can't create request" };
ASSERT_TRUE(request) << "Can't create request";
if (request->addBuffer(stream, buffer.get()))
return { Results::Fail, "Can't set buffer for request" };
ASSERT_EQ(request->addBuffer(stream, buffer.get()), 0) << "Can't set buffer for request";
if (camera_->queueRequest(request.get()) < 0)
return { Results::Fail, "Failed to queue request" };
ASSERT_EQ(camera_->queueRequest(request.get()), 0) << "Failed to queue request";
requests.push_back(std::move(request));
}
@@ -189,7 +174,7 @@ Results::Result SimpleCaptureUnbalanced::capture(unsigned int numRequests)
stop();
delete loop_;
return { status ? Results::Fail : Results::Pass, "Unbalanced capture of " + std::to_string(numRequests) + " requests" };
ASSERT_EQ(status, 0);
}
void SimpleCaptureUnbalanced::requestComplete(Request *request)

11
src/lc-compliance/simple_capture.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2020, Google Inc.
* Copyright (C) 2020-2021, Google Inc.
*
* simple_capture.h - Simple capture helper
*/
@@ -12,18 +12,17 @@
#include <libcamera/libcamera.h>
#include "../cam/event_loop.h"
#include "results.h"
class SimpleCapture
{
public:
Results::Result configure(libcamera::StreamRole role);
void configure(libcamera::StreamRole role);
protected:
SimpleCapture(std::shared_ptr<libcamera::Camera> camera);
virtual ~SimpleCapture();
Results::Result start();
void start();
void stop();
virtual void requestComplete(libcamera::Request *request) = 0;
@@ -40,7 +39,7 @@ class SimpleCaptureBalanced : public SimpleCapture
public:
SimpleCaptureBalanced(std::shared_ptr<libcamera::Camera> camera);
Results::Result capture(unsigned int numRequests);
void capture(unsigned int numRequests);
private:
int queueRequest(libcamera::Request *request);
@@ -56,7 +55,7 @@ class SimpleCaptureUnbalanced : public SimpleCapture
public:
SimpleCaptureUnbalanced(std::shared_ptr<libcamera::Camera> camera);
Results::Result capture(unsigned int numRequests);
void capture(unsigned int numRequests);
private:
void requestComplete(libcamera::Request *request) override;

97
src/lc-compliance/single_stream.cpp
View File

@@ -1,97 +0,0 @@
/* 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::Result testRequestUnbalance(std::shared_ptr<Camera> camera,
StreamRole role, unsigned int numRequests)
{
SimpleCaptureUnbalanced capture(camera);
Results::Result ret = capture.configure(role);
if (ret.first != Results::Pass)
return ret;
return capture.capture(numRequests);
}
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() * 3);
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));
/*
* Test unbalanced stop
*
* Makes sure the camera supports a stop with requests queued.
* Example failure is a camera that does not handle cancelation
* of buffers coming back from the video device while stopping.
*/
std::cout << "* Test unbalanced stop" << std::endl;
for (unsigned int num : numRequests)
results.add(testRequestUnbalance(camera, role.second, num));
}
return results;
}

16
src/lc-compliance/tests.h
View File

@@ -1,16 +0,0 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2020, Google Inc.
*
* tests.h - Test modules
*/
#ifndef __LC_COMPLIANCE_TESTS_H__
#define __LC_COMPLIANCE_TESTS_H__
#include <libcamera/libcamera.h>
#include "results.h"
Results testSingleStream(std::shared_ptr<libcamera::Camera> camera);
#endif /* __LC_COMPLIANCE_TESTS_H__ */