bindings/cxx/examples/gpiod_cxx_tests.cpp - manifest_repos/libgpiod - Git at Google

 // SPDX-License-Identifier: LGPL-2.1-or-later
 /*
  * This file is part of libgpiod.
  *
  * Copyright (C) 2017-2018 Bartosz Golaszewski <bartekgola@gmail.com>
  */

 /*
  * Misc tests/examples of the C++ API.
  *
  * These tests assume that at least one dummy gpiochip is present in the
  * system and that it's detected as gpiochip0.
  */

 #include <gpiod.hpp>

 #include <stdexcept>
 #include <cstdlib>
 #include <iostream>
 #include <fstream>
 #include <map>
 #include <cstring>
 #include <cerrno>
 #include <functional>

 #include <poll.h>

 namespace {

 using test_func = ::std::function<void (void)>;

 ::std::vector<::std::pair<::std::string, test_func>> test_funcs;

 struct test_case
 {
 	test_case(const ::std::string& name, test_func& func)
 	{
 		test_funcs.push_back(::std::make_pair(name, func));
 	}
 };

 #define TEST_CASE(_func)						\
 	test_func _test_func_##_func(_func);				\
 	test_case _test_case_##_func(#_func, _test_func_##_func)

 std::string boolstr(bool b)
 {
 	return b ? "true" : "false";
 }

 void fire_line_event(const ::std::string& chip, unsigned int offset, bool rising)
 {
 	::std::string path;

 	path = "/sys/kernel/debug/gpio-mockup-event/" + chip + "/" + ::std::to_string(offset);

 	::std::ofstream out(path);
 	if (!out)
 		throw ::std::runtime_error("unable to open " + path);

 	out << ::std::to_string(rising ? 1 : 0) << ::std::endl;
 }

 void print_event(const ::gpiod::line_event& event)
 {
 	::std::cerr << "type: "
 		    << (event.event_type == ::gpiod::line_event::RISING_EDGE ? "rising" : "falling")
 		    << "\n"
 		    << "timestamp: "
 		    << ::std::chrono::duration_cast<::std::chrono::seconds>(event.timestamp).count()
 		    << "."
 		    << event.timestamp.count() % 1000000000
 		    << "\n"
 		    << "source line offset: "
 		    << event.source.offset()
 		    << ::std::endl;
 }

 void chip_open_default_lookup(void)
 {
 	::gpiod::chip by_name("gpiochip0");
 	::gpiod::chip by_path("/dev/gpiochip0");
 	::gpiod::chip by_label("gpio-mockup-A");
 	::gpiod::chip by_number("0");

 	::std::cerr << "all good" << ::std::endl;
 }
 TEST_CASE(chip_open_default_lookup);

 void chip_open_different_modes(void)
 {
 	::gpiod::chip by_name("gpiochip0", ::gpiod::chip::OPEN_BY_NAME);
 	::gpiod::chip by_path("/dev/gpiochip0", ::gpiod::chip::OPEN_BY_PATH);
 	::gpiod::chip by_label("gpio-mockup-A", ::gpiod::chip::OPEN_BY_LABEL);
 	::gpiod::chip by_number("0", ::gpiod::chip::OPEN_BY_NUMBER);

 	::std::cerr << "all good" << ::std::endl;
 }
 TEST_CASE(chip_open_different_modes);

 void chip_open_nonexistent(void)
 {
 	try {
 		::gpiod::chip chip("/nonexistent_gpiochip");
 	} catch (const ::std::system_error& exc) {
 		::std::cerr << "system_error thrown as expected: " << exc.what() << ::std::endl;
 		return;
 	}

 	throw ::std::runtime_error("system_error should have been thrown");
 }
 TEST_CASE(chip_open_nonexistent);

 void chip_open_method(void)
 {
 	::gpiod::chip chip;

 	if (chip)
 		throw ::std::runtime_error("chip should be empty");

 	chip.open("gpiochip0");

 	::std::cerr << "all good" << ::std::endl;
 }
 TEST_CASE(chip_open_method);

 void chip_reset(void)
 {
 	::gpiod::chip chip("gpiochip0");

 	if (!chip)
 		throw ::std::runtime_error("chip object is not valid");

 	chip.reset();

 	if (chip)
 		throw ::std::runtime_error("chip should be invalid");

 	::std::cerr << "all good" << ::std::endl;
 }
 TEST_CASE(chip_reset);

 void chip_info(void)
 {
 	::gpiod::chip chip("gpiochip0");

 	::std::cerr << "chip name: " << chip.name() << ::std::endl;
 	::std::cerr << "chip label: " << chip.label() << ::std::endl;
 	::std::cerr << "number of lines " << chip.num_lines() << ::std::endl;
 }
 TEST_CASE(chip_info);

 void chip_operators(void)
 {
 	::gpiod::chip chip1("gpiochip0");
 	auto chip2 = chip1;

 	if ((chip1 != chip2) || !(chip1 == chip2))
 		throw ::std::runtime_error("chip objects should be equal");

 	::std::cerr << "all good" << ::std::endl;
 }
 TEST_CASE(chip_operators);

 void chip_line_ops(void)
 {
 	::gpiod::chip chip("gpiochip0");

 	auto line = chip.get_line(3);
 	::std::cerr << "Got line by offset: " << line.offset() << ::std::endl;

 	line = chip.find_line("gpio-mockup-A-4");
 	::std::cerr << "Got line by name: " << line.name() << ::std::endl;

 	auto lines = chip.get_lines({ 1, 2, 3, 6, 6 });
 	::std::cerr << "Got multiple lines by offset: ";
 	for (auto& it: lines)
 		::std::cerr << it.offset() << " ";
 	::std::cerr << ::std::endl;

 	lines = chip.find_lines({ "gpio-mockup-A-1", "gpio-mockup-A-4", "gpio-mockup-A-7" });
 	::std::cerr << "Got multiple lines by name: ";
 	for (auto& it: lines)
 		::std::cerr << it.name() << " ";
 	::std::cerr << ::std::endl;
 }
 TEST_CASE(chip_line_ops);

 void chip_find_lines_nonexistent(void)
 {
 	::gpiod::chip chip("gpiochip0");

 	auto lines = chip.find_lines({ "gpio-mockup-A-1", "nonexistent", "gpio-mockup-A-4" });
 	if (lines)
 		throw ::std::logic_error("line_bulk object should be invalid");

 	::std::cerr << "line_bulk invalid as expected" << ::std::endl;
 }
 TEST_CASE(chip_find_lines_nonexistent);

 void line_info(void)
 {
 	::gpiod::chip chip("gpiochip0");
 	::gpiod::line line = chip.get_line(2);

 	::std::cerr << "line offset: " << line.offset() << ::std::endl;
 	::std::cerr << "line name: " << line.name() << ::std::endl;
 	::std::cerr << "line direction: "
 		    << (line.direction() == ::gpiod::line::DIRECTION_INPUT ?
 			"input" : "output") << ::std::endl;
 	::std::cerr << "line active state: "
 		    << (line.active_state() == ::gpiod::line::ACTIVE_LOW ?
 			"active low" : "active high") << :: std::endl;
 }
 TEST_CASE(line_info);

 void empty_objects(void)
 {
 	::std::cerr << "Are initialized line & chip objects 'false'?" << ::std::endl;

 	::gpiod::line line;
 	if (line)
 		throw ::std::logic_error("line built with a default constructor should be 'false'");

 	::gpiod::chip chip;
 	if (chip)
 		throw ::std::logic_error("chip built with a default constructor should be 'false'");

 	::std::cerr << "YES" << ::std::endl;
 }
 TEST_CASE(empty_objects);

 void line_bulk_iterator(void)
 {
 	::std::cerr << "Checking line_bulk iterators" << ::std::endl;

 	::gpiod::chip chip("gpiochip0");
 	::gpiod::line_bulk bulk = chip.get_lines({ 0, 1, 2, 3, 4 });

 	for (auto& it: bulk)
 		::std::cerr << it.name() << ::std::endl;

 	::std::cerr << "DONE" << ::std::endl;
 }
 TEST_CASE(line_bulk_iterator);

 void single_line_test(void)
 {
 	const ::std::string line_name("gpio-mockup-A-4");

 	::std::cerr << "Looking up a GPIO line by name (" << line_name << ")" << ::std::endl;

 	auto line = ::gpiod::find_line(line_name);
 	if (!line)
 		throw ::std::runtime_error(line_name + " line not found");

 	::std::cerr << "Requesting a single line" << ::std::endl;

 	::gpiod::line_request conf;
 	conf.consumer = "gpiod_cxx_tests";
 	conf.request_type = ::gpiod::line_request::DIRECTION_OUTPUT;

 	line.request(conf, 1);
 	::std::cerr << "Reading value" << ::std::endl;
 	::std::cerr << line.get_value() << ::std::endl;
 	::std::cerr << "Changing value to 0" << ::std::endl;
 	line.set_value(0);
 	::std::cerr << "Reading value again" << ::std::endl;
 	::std::cerr << line.get_value() << ::std::endl;
 }
 TEST_CASE(single_line_test);

 void line_flags(void)
 {
 	::gpiod::chip chip("gpiochip0");

 	auto line = chip.get_line(0);

 	::std::cerr << "line is used: " << boolstr(line.is_used()) << ::std::endl;
 	::std::cerr << "line is requested: " << boolstr(line.is_requested()) << ::std::endl;

 	::std::cerr << "requesting line" << ::std::endl;

 	::gpiod::line_request config;
 	config.consumer = "gpiod_cxx_tests";
 	config.request_type = ::gpiod::line_request::DIRECTION_OUTPUT;
 	config.flags = ::gpiod::line_request::FLAG_OPEN_DRAIN;
 	line.request(config);

 	::std::cerr << "line is used: " << boolstr(line.is_used()) << ::std::endl;
 	::std::cerr << "line is open drain: " << boolstr(line.is_open_drain()) << ::std::endl;
 	::std::cerr << "line is open source: " << boolstr(line.is_open_source()) << ::std::endl;
 	::std::cerr << "line is requested: " << boolstr(line.is_requested()) << ::std::endl;

 	if (!line.is_open_drain())
 		throw ::std::logic_error("line should be open-drain");
 }
 TEST_CASE(line_flags);

 void multiple_lines_test(void)
 {
 	::gpiod::chip chip("gpiochip0");

 	::std::cerr << "Getting multiple lines by offsets" << ::std::endl;

 	auto lines = chip.get_lines({ 0, 2, 3, 4, 6 });

 	::std::cerr << "Requesting them for output" << ::std::endl;

 	::gpiod::line_request config;
 	config.consumer = "gpiod_cxx_tests";
 	config.request_type = ::gpiod::line_request::DIRECTION_OUTPUT;

 	lines.request(config);

 	::std::cerr << "Setting values" << ::std::endl;

 	lines.set_values({ 0, 1, 1, 0, 1});

 	::std::cerr << "Requesting the lines for input" << ::std::endl;

 	config.request_type = ::gpiod::line_request::DIRECTION_INPUT;
 	lines.release();
 	lines.request(config);

 	::std::cerr << "Reading the values" << ::std::endl;

 	auto vals = lines.get_values();

 	for (auto& it: vals)
 		::std::cerr << it << " ";
 	::std::cerr << ::std::endl;
 }
 TEST_CASE(multiple_lines_test);

 void chip_get_all_lines(void)
 {
 	::gpiod::chip chip("gpiochip0");

 	::std::cerr << "Getting all lines from a chip" << ::std::endl;

 	auto lines = chip.get_all_lines();

 	for (auto& it: lines)
 		::std::cerr << "Offset: " << it.offset() << ::std::endl;
 }
 TEST_CASE(chip_get_all_lines);

 void line_event_single_line(void)
 {
 	::gpiod::chip chip("gpiochip0");

 	auto line = chip.get_line(1);

 	::gpiod::line_request config;
 	config.consumer = "gpiod_cxx_tests";
 	config.request_type = ::gpiod::line_request::EVENT_BOTH_EDGES;

 	::std::cerr << "requesting line for events" << ::std::endl;
 	line.request(config);

 	::std::cerr << "generating a line event" << ::std::endl;
 	fire_line_event("gpiochip0", 1, true);

 	if (!line.event_wait(::std::chrono::nanoseconds(1000000000)))
 		throw ::std::runtime_error("waiting for event timed out");

 	auto event = line.event_read();

 	::std::cerr << "event received:" << ::std::endl;
 	print_event(event);
 }
 TEST_CASE(line_event_single_line);

 void line_event_multiple_lines(void)
 {
 	::gpiod::chip chip("gpiochip0");

 	auto lines = chip.get_lines({ 1, 2, 3, 4, 5 });

 	::gpiod::line_request config;
 	config.consumer = "gpiod_cxx_tests";
 	config.request_type = ::gpiod::line_request::EVENT_BOTH_EDGES;

 	::std::cerr << "requesting lines for events" << ::std::endl;
 	lines.request(config);

 	::std::cerr << "generating two line events" << ::std::endl;
 	fire_line_event("gpiochip0", 1, true);
 	fire_line_event("gpiochip0", 2, true);

 	auto event_lines = lines.event_wait(::std::chrono::nanoseconds(1000000000));
 	if (!event_lines || event_lines.size() != 2)
 		throw ::std::runtime_error("expected two line events");

 	::std::vector<::gpiod::line_event> events;
 	for (auto& line: event_lines) {
 		auto event = line.event_read();
 		events.push_back(event);
 	}

 	::std::cerr << "events received:" << ::std::endl;
 	for (auto& event: events)
 		print_event(event);
 }
 TEST_CASE(line_event_multiple_lines);

 void line_event_poll_fd(void)
 {
 	::std::map<int, ::gpiod::line> fd_line_map;

 	::gpiod::chip chip("gpiochip0");
 	auto lines = chip.get_lines({ 1, 2, 3, 4, 5, 6 });

 	::gpiod::line_request config;
 	config.consumer = "gpiod_cxx_tests";
 	config.request_type = ::gpiod::line_request::EVENT_BOTH_EDGES;

 	::std::cerr << "requesting lines for events" << ::std::endl;
 	lines.request(config);

 	::std::cerr << "generating three line events" << ::std::endl;
 	fire_line_event("gpiochip0", 2, true);
 	fire_line_event("gpiochip0", 3, true);
 	fire_line_event("gpiochip0", 5, false);

 	fd_line_map[lines[1].event_get_fd()] = lines[1];
 	fd_line_map[lines[2].event_get_fd()] = lines[2];
 	fd_line_map[lines[4].event_get_fd()] = lines[4];

 	pollfd fds[3];
 	fds[0].fd = lines[1].event_get_fd();
 	fds[1].fd = lines[2].event_get_fd();
 	fds[2].fd = lines[4].event_get_fd();

 	fds[0].events = fds[1].events = fds[2].events = POLLIN | POLLPRI;

 	int rv = poll(fds, 3, 1000);
 	if (rv < 0)
 		throw ::std::runtime_error("error polling for events: "
 						+ ::std::string(::strerror(errno)));
 	else if (rv == 0)
 		throw ::std::runtime_error("poll() timed out while waiting for events");

 	if (rv != 3)
 		throw ::std::runtime_error("expected three line events");

 	::std::cerr << "events received:" << ::std::endl;
 	for (unsigned int i = 0; i < 3; i++) {
 		if (fds[i].revents)
 			print_event(fd_line_map[fds[i].fd].event_read());
 	}
 }
 TEST_CASE(line_event_poll_fd);

 void chip_iterator(void)
 {
 	::std::cerr << "iterating over all GPIO chips in the system:" << ::std::endl;

 	for (auto& it: ::gpiod::make_chip_iter())
 		::std::cerr << it.name() << ::std::endl;
 }
 TEST_CASE(chip_iterator);

 void line_iterator(void)
 {
 	::std::cerr << "iterating over all lines exposed by a GPIO chip:" << ::std::endl;

 	::gpiod::chip chip("gpiochip0");

 	for (auto& it: ::gpiod::line_iter(chip))
 		::std::cerr << it.offset() << ": " << it.name() << ::std::endl;
 }
 TEST_CASE(line_iterator);

 } /* namespace */

 int main(int, char **)
 {
 	for (auto& it: test_funcs) {
 		::std::cerr << "=================================================" << ::std::endl;
 		::std::cerr << it.first << ":\n" << ::std::endl;
 		it.second();
 	}

 	return EXIT_SUCCESS;
 }
	// SPDX-License-Identifier: LGPL-2.1-or-later
	/*
	* This file is part of libgpiod.
	*
	* Copyright (C) 2017-2018 Bartosz Golaszewski <bartekgola@gmail.com>
	*/

	/*
	* Misc tests/examples of the C++ API.
	*
	* These tests assume that at least one dummy gpiochip is present in the
	* system and that it's detected as gpiochip0.
	*/

	#include <gpiod.hpp>

	#include <stdexcept>
	#include <cstdlib>
	#include <iostream>
	#include <fstream>
	#include <map>
	#include <cstring>
	#include <cerrno>
	#include <functional>

	#include <poll.h>

	namespace {

	using test_func = ::std::function<void (void)>;

	::std::vector<::std::pair<::std::string, test_func>> test_funcs;

	struct test_case
	{
	test_case(const ::std::string& name, test_func& func)
	{
	test_funcs.push_back(::std::make_pair(name, func));
	}
	};

	#define TEST_CASE(_func) \
	test_func _test_func_##_func(_func); \
	test_case _test_case_##_func(#_func, _test_func_##_func)

	std::string boolstr(bool b)
	{
	return b ? "true" : "false";
	}

	void fire_line_event(const ::std::string& chip, unsigned int offset, bool rising)
	{
	::std::string path;

	path = "/sys/kernel/debug/gpio-mockup-event/" + chip + "/" + ::std::to_string(offset);

	::std::ofstream out(path);
	if (!out)
	throw ::std::runtime_error("unable to open " + path);

	out << ::std::to_string(rising ? 1 : 0) << ::std::endl;
	}

	void print_event(const ::gpiod::line_event& event)
	{
	::std::cerr << "type: "
	<< (event.event_type == ::gpiod::line_event::RISING_EDGE ? "rising" : "falling")
	<< "\n"
	<< "timestamp: "
	<< ::std::chrono::duration_cast<::std::chrono::seconds>(event.timestamp).count()
	<< "."
	<< event.timestamp.count() % 1000000000
	<< "\n"
	<< "source line offset: "
	<< event.source.offset()
	<< ::std::endl;
	}

	void chip_open_default_lookup(void)
	{
	::gpiod::chip by_name("gpiochip0");
	::gpiod::chip by_path("/dev/gpiochip0");
	::gpiod::chip by_label("gpio-mockup-A");
	::gpiod::chip by_number("0");

	::std::cerr << "all good" << ::std::endl;
	}
	TEST_CASE(chip_open_default_lookup);

	void chip_open_different_modes(void)
	{
	::gpiod::chip by_name("gpiochip0", ::gpiod::chip::OPEN_BY_NAME);
	::gpiod::chip by_path("/dev/gpiochip0", ::gpiod::chip::OPEN_BY_PATH);
	::gpiod::chip by_label("gpio-mockup-A", ::gpiod::chip::OPEN_BY_LABEL);
	::gpiod::chip by_number("0", ::gpiod::chip::OPEN_BY_NUMBER);

	::std::cerr << "all good" << ::std::endl;
	}
	TEST_CASE(chip_open_different_modes);

	void chip_open_nonexistent(void)
	{
	try {
	::gpiod::chip chip("/nonexistent_gpiochip");
	} catch (const ::std::system_error& exc) {
	::std::cerr << "system_error thrown as expected: " << exc.what() << ::std::endl;
	return;
	}

	throw ::std::runtime_error("system_error should have been thrown");
	}
	TEST_CASE(chip_open_nonexistent);

	void chip_open_method(void)
	{
	::gpiod::chip chip;

	if (chip)
	throw ::std::runtime_error("chip should be empty");

	chip.open("gpiochip0");

	::std::cerr << "all good" << ::std::endl;
	}
	TEST_CASE(chip_open_method);

	void chip_reset(void)
	{
	::gpiod::chip chip("gpiochip0");

	if (!chip)
	throw ::std::runtime_error("chip object is not valid");

	chip.reset();

	if (chip)
	throw ::std::runtime_error("chip should be invalid");

	::std::cerr << "all good" << ::std::endl;
	}
	TEST_CASE(chip_reset);

	void chip_info(void)
	{
	::gpiod::chip chip("gpiochip0");

	::std::cerr << "chip name: " << chip.name() << ::std::endl;
	::std::cerr << "chip label: " << chip.label() << ::std::endl;
	::std::cerr << "number of lines " << chip.num_lines() << ::std::endl;
	}
	TEST_CASE(chip_info);

	void chip_operators(void)
	{
	::gpiod::chip chip1("gpiochip0");
	auto chip2 = chip1;

	if ((chip1 != chip2) \|\| !(chip1 == chip2))
	throw ::std::runtime_error("chip objects should be equal");

	::std::cerr << "all good" << ::std::endl;
	}
	TEST_CASE(chip_operators);

	void chip_line_ops(void)
	{
	::gpiod::chip chip("gpiochip0");

	auto line = chip.get_line(3);
	::std::cerr << "Got line by offset: " << line.offset() << ::std::endl;

	line = chip.find_line("gpio-mockup-A-4");
	::std::cerr << "Got line by name: " << line.name() << ::std::endl;

	auto lines = chip.get_lines({ 1, 2, 3, 6, 6 });
	::std::cerr << "Got multiple lines by offset: ";
	for (auto& it: lines)
	::std::cerr << it.offset() << " ";
	::std::cerr << ::std::endl;

	lines = chip.find_lines({ "gpio-mockup-A-1", "gpio-mockup-A-4", "gpio-mockup-A-7" });
	::std::cerr << "Got multiple lines by name: ";
	for (auto& it: lines)
	::std::cerr << it.name() << " ";
	::std::cerr << ::std::endl;
	}
	TEST_CASE(chip_line_ops);

	void chip_find_lines_nonexistent(void)
	{
	::gpiod::chip chip("gpiochip0");

	auto lines = chip.find_lines({ "gpio-mockup-A-1", "nonexistent", "gpio-mockup-A-4" });
	if (lines)
	throw ::std::logic_error("line_bulk object should be invalid");

	::std::cerr << "line_bulk invalid as expected" << ::std::endl;
	}
	TEST_CASE(chip_find_lines_nonexistent);

	void line_info(void)
	{
	::gpiod::chip chip("gpiochip0");
	::gpiod::line line = chip.get_line(2);

	::std::cerr << "line offset: " << line.offset() << ::std::endl;
	::std::cerr << "line name: " << line.name() << ::std::endl;
	::std::cerr << "line direction: "
	<< (line.direction() == ::gpiod::line::DIRECTION_INPUT ?
	"input" : "output") << ::std::endl;
	::std::cerr << "line active state: "
	<< (line.active_state() == ::gpiod::line::ACTIVE_LOW ?
	"active low" : "active high") << :: std::endl;
	}
	TEST_CASE(line_info);

	void empty_objects(void)
	{
	::std::cerr << "Are initialized line & chip objects 'false'?" << ::std::endl;

	::gpiod::line line;
	if (line)
	throw ::std::logic_error("line built with a default constructor should be 'false'");

	::gpiod::chip chip;
	if (chip)
	throw ::std::logic_error("chip built with a default constructor should be 'false'");

	::std::cerr << "YES" << ::std::endl;
	}
	TEST_CASE(empty_objects);

	void line_bulk_iterator(void)
	{
	::std::cerr << "Checking line_bulk iterators" << ::std::endl;

	::gpiod::chip chip("gpiochip0");
	::gpiod::line_bulk bulk = chip.get_lines({ 0, 1, 2, 3, 4 });

	for (auto& it: bulk)
	::std::cerr << it.name() << ::std::endl;

	::std::cerr << "DONE" << ::std::endl;
	}
	TEST_CASE(line_bulk_iterator);

	void single_line_test(void)
	{
	const ::std::string line_name("gpio-mockup-A-4");

	::std::cerr << "Looking up a GPIO line by name (" << line_name << ")" << ::std::endl;

	auto line = ::gpiod::find_line(line_name);
	if (!line)
	throw ::std::runtime_error(line_name + " line not found");

	::std::cerr << "Requesting a single line" << ::std::endl;

	::gpiod::line_request conf;
	conf.consumer = "gpiod_cxx_tests";
	conf.request_type = ::gpiod::line_request::DIRECTION_OUTPUT;

	line.request(conf, 1);
	::std::cerr << "Reading value" << ::std::endl;
	::std::cerr << line.get_value() << ::std::endl;
	::std::cerr << "Changing value to 0" << ::std::endl;
	line.set_value(0);
	::std::cerr << "Reading value again" << ::std::endl;
	::std::cerr << line.get_value() << ::std::endl;
	}
	TEST_CASE(single_line_test);

	void line_flags(void)
	{
	::gpiod::chip chip("gpiochip0");

	auto line = chip.get_line(0);

	::std::cerr << "line is used: " << boolstr(line.is_used()) << ::std::endl;
	::std::cerr << "line is requested: " << boolstr(line.is_requested()) << ::std::endl;

	::std::cerr << "requesting line" << ::std::endl;

	::gpiod::line_request config;
	config.consumer = "gpiod_cxx_tests";
	config.request_type = ::gpiod::line_request::DIRECTION_OUTPUT;
	config.flags = ::gpiod::line_request::FLAG_OPEN_DRAIN;
	line.request(config);

	::std::cerr << "line is used: " << boolstr(line.is_used()) << ::std::endl;
	::std::cerr << "line is open drain: " << boolstr(line.is_open_drain()) << ::std::endl;
	::std::cerr << "line is open source: " << boolstr(line.is_open_source()) << ::std::endl;
	::std::cerr << "line is requested: " << boolstr(line.is_requested()) << ::std::endl;

	if (!line.is_open_drain())
	throw ::std::logic_error("line should be open-drain");
	}
	TEST_CASE(line_flags);

	void multiple_lines_test(void)
	{
	::gpiod::chip chip("gpiochip0");

	::std::cerr << "Getting multiple lines by offsets" << ::std::endl;

	auto lines = chip.get_lines({ 0, 2, 3, 4, 6 });

	::std::cerr << "Requesting them for output" << ::std::endl;

	::gpiod::line_request config;
	config.consumer = "gpiod_cxx_tests";
	config.request_type = ::gpiod::line_request::DIRECTION_OUTPUT;

	lines.request(config);

	::std::cerr << "Setting values" << ::std::endl;

	lines.set_values({ 0, 1, 1, 0, 1});

	::std::cerr << "Requesting the lines for input" << ::std::endl;

	config.request_type = ::gpiod::line_request::DIRECTION_INPUT;
	lines.release();
	lines.request(config);

	::std::cerr << "Reading the values" << ::std::endl;

	auto vals = lines.get_values();

	for (auto& it: vals)
	::std::cerr << it << " ";
	::std::cerr << ::std::endl;
	}
	TEST_CASE(multiple_lines_test);

	void chip_get_all_lines(void)
	{
	::gpiod::chip chip("gpiochip0");

	::std::cerr << "Getting all lines from a chip" << ::std::endl;

	auto lines = chip.get_all_lines();

	for (auto& it: lines)
	::std::cerr << "Offset: " << it.offset() << ::std::endl;
	}
	TEST_CASE(chip_get_all_lines);

	void line_event_single_line(void)
	{
	::gpiod::chip chip("gpiochip0");

	auto line = chip.get_line(1);

	::gpiod::line_request config;
	config.consumer = "gpiod_cxx_tests";
	config.request_type = ::gpiod::line_request::EVENT_BOTH_EDGES;

	::std::cerr << "requesting line for events" << ::std::endl;
	line.request(config);

	::std::cerr << "generating a line event" << ::std::endl;
	fire_line_event("gpiochip0", 1, true);

	if (!line.event_wait(::std::chrono::nanoseconds(1000000000)))
	throw ::std::runtime_error("waiting for event timed out");

	auto event = line.event_read();

	::std::cerr << "event received:" << ::std::endl;
	print_event(event);
	}
	TEST_CASE(line_event_single_line);

	void line_event_multiple_lines(void)
	{
	::gpiod::chip chip("gpiochip0");

	auto lines = chip.get_lines({ 1, 2, 3, 4, 5 });

	::gpiod::line_request config;
	config.consumer = "gpiod_cxx_tests";
	config.request_type = ::gpiod::line_request::EVENT_BOTH_EDGES;

	::std::cerr << "requesting lines for events" << ::std::endl;
	lines.request(config);

	::std::cerr << "generating two line events" << ::std::endl;
	fire_line_event("gpiochip0", 1, true);
	fire_line_event("gpiochip0", 2, true);

	auto event_lines = lines.event_wait(::std::chrono::nanoseconds(1000000000));
	if (!event_lines \|\| event_lines.size() != 2)
	throw ::std::runtime_error("expected two line events");

	::std::vector<::gpiod::line_event> events;
	for (auto& line: event_lines) {
	auto event = line.event_read();
	events.push_back(event);
	}

	::std::cerr << "events received:" << ::std::endl;
	for (auto& event: events)
	print_event(event);
	}
	TEST_CASE(line_event_multiple_lines);

	void line_event_poll_fd(void)
	{
	::std::map<int, ::gpiod::line> fd_line_map;

	::gpiod::chip chip("gpiochip0");
	auto lines = chip.get_lines({ 1, 2, 3, 4, 5, 6 });

	::gpiod::line_request config;
	config.consumer = "gpiod_cxx_tests";
	config.request_type = ::gpiod::line_request::EVENT_BOTH_EDGES;

	::std::cerr << "requesting lines for events" << ::std::endl;
	lines.request(config);

	::std::cerr << "generating three line events" << ::std::endl;
	fire_line_event("gpiochip0", 2, true);
	fire_line_event("gpiochip0", 3, true);
	fire_line_event("gpiochip0", 5, false);

	fd_line_map[lines[1].event_get_fd()] = lines[1];
	fd_line_map[lines[2].event_get_fd()] = lines[2];
	fd_line_map[lines[4].event_get_fd()] = lines[4];

	pollfd fds[3];
	fds[0].fd = lines[1].event_get_fd();
	fds[1].fd = lines[2].event_get_fd();
	fds[2].fd = lines[4].event_get_fd();

	fds[0].events = fds[1].events = fds[2].events = POLLIN \| POLLPRI;

	int rv = poll(fds, 3, 1000);
	if (rv < 0)
	throw ::std::runtime_error("error polling for events: "
	+ ::std::string(::strerror(errno)));
	else if (rv == 0)
	throw ::std::runtime_error("poll() timed out while waiting for events");

	if (rv != 3)
	throw ::std::runtime_error("expected three line events");

	::std::cerr << "events received:" << ::std::endl;
	for (unsigned int i = 0; i < 3; i++) {
	if (fds[i].revents)
	print_event(fd_line_map[fds[i].fd].event_read());
	}
	}
	TEST_CASE(line_event_poll_fd);

	void chip_iterator(void)
	{
	::std::cerr << "iterating over all GPIO chips in the system:" << ::std::endl;

	for (auto& it: ::gpiod::make_chip_iter())
	::std::cerr << it.name() << ::std::endl;
	}
	TEST_CASE(chip_iterator);

	void line_iterator(void)
	{
	::std::cerr << "iterating over all lines exposed by a GPIO chip:" << ::std::endl;

	::gpiod::chip chip("gpiochip0");

	for (auto& it: ::gpiod::line_iter(chip))
	::std::cerr << it.offset() << ": " << it.name() << ::std::endl;
	}
	TEST_CASE(line_iterator);

	} /* namespace */

	int main(int, char **)
	{
	for (auto& it: test_funcs) {
	::std::cerr << "=================================================" << ::std::endl;
	::std::cerr << it.first << ":\n" << ::std::endl;
	it.second();
	}

	return EXIT_SUCCESS;
	}