pw_digital_io_linux/digital_io_test.cc - pigweed/pigweed - Git at Google

 // Copyright 2024 The Pigweed Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
 // use this file except in compliance with the License. You may obtain a copy of
 // the License at
 //
 //     https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 // License for the specific language governing permissions and limitations under
 // the License.
 #include "pw_digital_io/digital_io.h"

 #include <linux/gpio.h>

 #include <algorithm>
 #include <functional>
 #include <memory>
 #include <vector>

 #include "mock_vfs.h"
 #include "pw_digital_io_linux/digital_io.h"
 #include "pw_log/log.h"
 #include "pw_result/result.h"
 #include "pw_unit_test/framework.h"
 #include "test_utils.h"

 namespace pw::digital_io {
 namespace {

 class DigitalIoTest;

 // Represents a mocked in-kernel GPIO line object.
 class Line {
  public:
   //
   // Harness-side interface: Intended for use by DigitalIoTest and the
   // MockFile subclasses.
   //

   explicit Line(uint32_t index) : index_(index) {}

   // Get the logical value of the line, respecting active_low.
   Result<bool> GetValue() const {
     // Linux lets you read the value of an output.
     if (requested_ == RequestedState::kNone) {
       PW_LOG_ERROR("Cannot get value of unrequested line");
       return Status::FailedPrecondition();
     }
     return physical_state_ ^ active_low_;
   }

   // Set the logical value of the line, respecting active_low.
   // Returns OK on success; FAILED_PRECONDITION if not requested as output.
   Status SetValue(bool value) {
     if (requested_ != RequestedState::kOutput) {
       PW_LOG_ERROR("Cannot set value of line not requested as output");
       return Status::FailedPrecondition();
     }

     physical_state_ = value ^ active_low_;

     PW_LOG_DEBUG("Set line %u to physical %u", index_, physical_state_);
     return OkStatus();
   }

   Status RequestInput(bool active_low) {
     return DoRequest(RequestedState::kInput, active_low);
   }

   Status RequestOutput(bool active_low) {
     return DoRequest(RequestedState::kOutput, active_low);
   }

   void ClearRequest() { requested_ = RequestedState::kNone; }

   //
   // Test-side interface: Intended for use by the tests themselves.
   //

   enum class RequestedState {
     kNone,    // Not requested by "userspace"
     kInput,   // Requested by "userspace" as an input
     kOutput,  // Requested by "userspace" as an output
   };

   RequestedState requested() const { return requested_; }

   void ForcePhysicalState(bool state) { physical_state_ = state; }

   bool physical_state() const { return physical_state_; }

  private:
   const uint32_t index_;
   bool physical_state_ = false;

   RequestedState requested_ = RequestedState::kNone;
   bool active_low_ = false;

   Status DoRequest(RequestedState request, bool active_low) {
     if (requested_ != RequestedState::kNone) {
       PW_LOG_ERROR("Cannot request already-requested line");
       return Status::FailedPrecondition();
     }
     requested_ = request;
     active_low_ = active_low;
     return OkStatus();
   }
 };

 // Represents a GPIO line handle, the result of issuing
 // GPIO_GET_LINEHANDLE_IOCTL to an open chip file.
 class LineHandleFile : public MockFile {
  public:
   LineHandleFile(MockVfs& vfs, const std::string& name, Line& line)
       : MockFile(vfs, name), line_(line) {}

  private:
   Line& line_;

   //
   // MockFile impl.
   //

   int DoClose() override {
     line_.ClearRequest();
     return 0;
   }

   int DoIoctl(unsigned long request, void* arg) override {
     switch (request) {
       case GPIOHANDLE_GET_LINE_VALUES_IOCTL:
         return DoIoctlGetValues(static_cast<struct gpiohandle_data*>(arg));
       case GPIOHANDLE_SET_LINE_VALUES_IOCTL:
         return DoIoctlSetValues(static_cast<struct gpiohandle_data*>(arg));
       default:
         PW_LOG_ERROR("%s: Unhandled request=0x%lX", __FUNCTION__, request);
         return -1;
     }
   }

   // Handle GPIOHANDLE_GET_LINE_VALUES_IOCTL
   int DoIoctlGetValues(struct gpiohandle_data* data) {
     auto result = line_.GetValue();
     if (!result.ok()) {
       return -1;
     }

     data->values[0] = *result;
     return 0;
   }

   // Handle GPIOHANDLE_SET_LINE_VALUES_IOCTL
   int DoIoctlSetValues(struct gpiohandle_data* data) {
     auto status = line_.SetValue(data->values[0]);
     if (!status.ok()) {
       return -1;
     }

     return 0;
   }
 };

 // Represents an open GPIO chip file, the result of opening /dev/gpiochip*.
 class ChipFile : public MockFile {
  public:
   ChipFile(MockVfs& vfs, const std::string& name, std::vector<Line>& lines)
       : MockFile(vfs, name), lines_(lines) {}

  private:
   std::vector<Line>& lines_;

   //
   // MockFile impl.
   //

   int DoIoctl(unsigned long request, void* arg) override {
     switch (request) {
       case GPIO_GET_LINEHANDLE_IOCTL:
         return DoLinehandleIoctl(static_cast<struct gpiohandle_request*>(arg));
       default:
         PW_LOG_ERROR("%s: Unhandled request=0x%lX", __FUNCTION__, request);
         return -1;
     }
   }

   // Handle GPIO_GET_LINEHANDLE_IOCTL
   int DoLinehandleIoctl(struct gpiohandle_request* req) {
     uint32_t const direction =
         req->flags & (GPIOHANDLE_REQUEST_OUTPUT | GPIOHANDLE_REQUEST_INPUT);

     // Validate flags.
     if (direction == (GPIOHANDLE_REQUEST_OUTPUT | GPIOHANDLE_REQUEST_INPUT)) {
       PW_LOG_ERROR("%s: OUTPUT and INPUT are mutually exclusive", __FUNCTION__);
       return -1;
     }

     // Only support requesting one line at at time.
     if (req->lines != 1) {
       PW_LOG_ERROR("%s: Unsupported req->lines=%u", __FUNCTION__, req->lines);
       return -1;
     }

     uint32_t const offset = req->lineoffsets[0];
     uint8_t const default_value = req->default_values[0];
     bool const active_low = req->flags & GPIOHANDLE_REQUEST_ACTIVE_LOW;

     if (offset >= lines_.size()) {
       PW_LOG_ERROR("%s: Invalid line offset: %u", __FUNCTION__, offset);
       return -1;
     }
     Line& line = lines_[offset];

     Status status = OkStatus();
     switch (direction) {
       case GPIOHANDLE_REQUEST_OUTPUT:
         status.Update(line.RequestOutput(active_low));
         status.Update(line.SetValue(default_value));
         break;
       case GPIOHANDLE_REQUEST_INPUT:
         status.Update(line.RequestInput(active_low));
         break;
     }
     if (!status.ok()) {
       return -1;
     }

     req->fd = vfs_.InstallNewFile<LineHandleFile>("line-handle", line);
     return 0;
   }
 };

 // Test fixture for all digtal io tests.
 class DigitalIoTest : public ::testing::Test {
  protected:
   void SetUp() override { GetMockVfs().Reset(); }

   void TearDown() override { EXPECT_TRUE(GetMockVfs().AllFdsClosed()); }

   LinuxDigitalIoChip OpenChip() {
     int fd = GetMockVfs().InstallNewFile<ChipFile>("chip", lines_);
     return LinuxDigitalIoChip(fd);
   }

   Line& line0() { return lines_[0]; }
   Line& line1() { return lines_[1]; }

  private:
   std::vector<Line> lines_ = std::vector<Line>{
       Line(0),  // Input
       Line(1),  // Output
   };
 };

 //
 // Tests
 //

 TEST_F(DigitalIoTest, DoInput) {
   LinuxDigitalIoChip chip = OpenChip();

   auto& line = line0();
   LinuxInputConfig config(
       /* index= */ 0,
       /* polarity= */ Polarity::kActiveHigh);

   ASSERT_OK_AND_ASSIGN(auto input, chip.GetInputLine(config));

   // Enable the input, and ensure it is requested.
   ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
   ASSERT_OK(input.Enable());
   ASSERT_EQ(line.requested(), Line::RequestedState::kInput);

   Result<State> state;

   // Force the line high and assert it is seen as active (active high).
   line.ForcePhysicalState(true);
   state = input.GetState();
   ASSERT_OK(state.status());
   ASSERT_EQ(State::kActive, state.value());

   // Force the line low and assert it is seen as inactive (active high).
   line.ForcePhysicalState(false);
   state = input.GetState();
   ASSERT_OK(state.status());
   ASSERT_EQ(State::kInactive, state.value());

   // Disable the line and ensure it is no longer requested.
   ASSERT_OK(input.Disable());
   ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
 }

 TEST_F(DigitalIoTest, DoInputInvert) {
   LinuxDigitalIoChip chip = OpenChip();

   auto& line = line0();
   LinuxInputConfig config(
       /* index= */ 0,
       /* polarity= */ Polarity::kActiveLow);

   ASSERT_OK_AND_ASSIGN(auto input, chip.GetInputLine(config));

   // Enable the input, and ensure it is requested.
   ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
   ASSERT_OK(input.Enable());
   ASSERT_EQ(line.requested(), Line::RequestedState::kInput);

   Result<State> state;

   // Force the line high and assert it is seen as inactive (active low).
   line.ForcePhysicalState(true);
   state = input.GetState();
   ASSERT_OK(state.status());
   ASSERT_EQ(State::kInactive, state.value());

   // Force the line low and assert it is seen as active (active low).
   line.ForcePhysicalState(false);
   state = input.GetState();
   ASSERT_OK(state.status());
   ASSERT_EQ(State::kActive, state.value());

   // Disable the line and ensure it is no longer requested.
   ASSERT_OK(input.Disable());
   ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
 }

 TEST_F(DigitalIoTest, DoOutput) {
   LinuxDigitalIoChip chip = OpenChip();

   auto& line = line1();
   LinuxOutputConfig config(
       /* index= */ 1,
       /* polarity= */ Polarity::kActiveHigh,
       /* default_state= */ State::kActive);

   ASSERT_OK_AND_ASSIGN(auto output, chip.GetOutputLine(config));

   // Enable the output, and ensure it is requested.
   ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
   ASSERT_OK(output.Enable());
   ASSERT_EQ(line.requested(), Line::RequestedState::kOutput);

   // Expect the line to go high, due to default_state=kActive (active high).
   ASSERT_TRUE(line.physical_state());

   // Set the output's state to inactive, and assert it goes low (active high).
   ASSERT_OK(output.SetStateInactive());
   ASSERT_FALSE(line.physical_state());

   // Set the output's state to active, and assert it goes high (active high).
   ASSERT_OK(output.SetStateActive());
   ASSERT_TRUE(line.physical_state());

   // Disable the line and ensure it is no longer requested.
   ASSERT_OK(output.Disable());
   ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
   // NOTE: We do not assert line.physical_state() here.
   // See the warning on LinuxDigitalOut in docs.rst.
 }

 TEST_F(DigitalIoTest, DoOutputInvert) {
   LinuxDigitalIoChip chip = OpenChip();

   auto& line = line1();
   LinuxOutputConfig config(
       /* index= */ 1,
       /* polarity= */ Polarity::kActiveLow,
       /* default_state= */ State::kActive);

   ASSERT_OK_AND_ASSIGN(auto output, chip.GetOutputLine(config));

   // Enable the output, and ensure it is requested.
   ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
   ASSERT_OK(output.Enable());
   ASSERT_EQ(line.requested(), Line::RequestedState::kOutput);

   // Expect the line to stay low, due to default_state=kActive (active low).
   ASSERT_FALSE(line.physical_state());

   // Set the output's state to inactive, and assert it goes high (active low).
   ASSERT_OK(output.SetStateInactive());
   ASSERT_TRUE(line.physical_state());

   // Set the output's state to active, and assert it goes low (active low).
   ASSERT_OK(output.SetStateActive());
   ASSERT_FALSE(line.physical_state());

   // Disable the line and ensure it is no longer requested.
   ASSERT_OK(output.Disable());
   ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
   // NOTE: We do not assert line.physical_state() here.
   // See the warning on LinuxDigitalOut in docs.rst.
 }

 // Verify we can get the state of an output.
 TEST_F(DigitalIoTest, OutputGetState) {
   LinuxDigitalIoChip chip = OpenChip();

   auto& line = line1();
   LinuxOutputConfig config(
       /* index= */ 1,
       /* polarity= */ Polarity::kActiveHigh,
       /* default_state= */ State::kInactive);

   ASSERT_OK_AND_ASSIGN(auto output, chip.GetOutputLine(config));

   ASSERT_OK(output.Enable());

   // Expect the line to stay low, due to default_state=kInactive (active high).
   ASSERT_FALSE(line.physical_state());

   Result<State> state;

   // Verify GetState() returns the expected state: inactive (default_state).
   state = output.GetState();
   ASSERT_OK(state.status());
   ASSERT_EQ(State::kInactive, state.value());

   // Set the output's state to active, then verify GetState() returns the
   // new expected state.
   ASSERT_OK(output.SetStateActive());
   state = output.GetState();
   ASSERT_OK(state.status());
   ASSERT_EQ(State::kActive, state.value());
 }

 }  // namespace
 }  // namespace pw::digital_io
	// Copyright 2024 The Pigweed Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License"); you may not
	// use this file except in compliance with the License. You may obtain a copy of
	// the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	// License for the specific language governing permissions and limitations under
	// the License.
	#include "pw_digital_io/digital_io.h"

	#include <linux/gpio.h>

	#include <algorithm>
	#include <functional>
	#include <memory>
	#include <vector>

	#include "mock_vfs.h"
	#include "pw_digital_io_linux/digital_io.h"
	#include "pw_log/log.h"
	#include "pw_result/result.h"
	#include "pw_unit_test/framework.h"
	#include "test_utils.h"

	namespace pw::digital_io {
	namespace {

	class DigitalIoTest;

	// Represents a mocked in-kernel GPIO line object.
	class Line {
	public:
	//
	// Harness-side interface: Intended for use by DigitalIoTest and the
	// MockFile subclasses.
	//

	explicit Line(uint32_t index) : index_(index) {}

	// Get the logical value of the line, respecting active_low.
	Result<bool> GetValue() const {
	// Linux lets you read the value of an output.
	if (requested_ == RequestedState::kNone) {
	PW_LOG_ERROR("Cannot get value of unrequested line");
	return Status::FailedPrecondition();
	}
	return physical_state_ ^ active_low_;
	}

	// Set the logical value of the line, respecting active_low.
	// Returns OK on success; FAILED_PRECONDITION if not requested as output.
	Status SetValue(bool value) {
	if (requested_ != RequestedState::kOutput) {
	PW_LOG_ERROR("Cannot set value of line not requested as output");
	return Status::FailedPrecondition();
	}

	physical_state_ = value ^ active_low_;

	PW_LOG_DEBUG("Set line %u to physical %u", index_, physical_state_);
	return OkStatus();
	}

	Status RequestInput(bool active_low) {
	return DoRequest(RequestedState::kInput, active_low);
	}

	Status RequestOutput(bool active_low) {
	return DoRequest(RequestedState::kOutput, active_low);
	}

	void ClearRequest() { requested_ = RequestedState::kNone; }

	//
	// Test-side interface: Intended for use by the tests themselves.
	//

	enum class RequestedState {
	kNone, // Not requested by "userspace"
	kInput, // Requested by "userspace" as an input
	kOutput, // Requested by "userspace" as an output
	};

	RequestedState requested() const { return requested_; }

	void ForcePhysicalState(bool state) { physical_state_ = state; }

	bool physical_state() const { return physical_state_; }

	private:
	const uint32_t index_;
	bool physical_state_ = false;

	RequestedState requested_ = RequestedState::kNone;
	bool active_low_ = false;

	Status DoRequest(RequestedState request, bool active_low) {
	if (requested_ != RequestedState::kNone) {
	PW_LOG_ERROR("Cannot request already-requested line");
	return Status::FailedPrecondition();
	}
	requested_ = request;
	active_low_ = active_low;
	return OkStatus();
	}
	};

	// Represents a GPIO line handle, the result of issuing
	// GPIO_GET_LINEHANDLE_IOCTL to an open chip file.
	class LineHandleFile : public MockFile {
	public:
	LineHandleFile(MockVfs& vfs, const std::string& name, Line& line)
	: MockFile(vfs, name), line_(line) {}

	private:
	Line& line_;

	//
	// MockFile impl.
	//

	int DoClose() override {
	line_.ClearRequest();
	return 0;
	}

	int DoIoctl(unsigned long request, void* arg) override {
	switch (request) {
	case GPIOHANDLE_GET_LINE_VALUES_IOCTL:
	return DoIoctlGetValues(static_cast<struct gpiohandle_data*>(arg));
	case GPIOHANDLE_SET_LINE_VALUES_IOCTL:
	return DoIoctlSetValues(static_cast<struct gpiohandle_data*>(arg));
	default:
	PW_LOG_ERROR("%s: Unhandled request=0x%lX", __FUNCTION__, request);
	return -1;
	}
	}

	// Handle GPIOHANDLE_GET_LINE_VALUES_IOCTL
	int DoIoctlGetValues(struct gpiohandle_data* data) {
	auto result = line_.GetValue();
	if (!result.ok()) {
	return -1;
	}

	data->values[0] = *result;
	return 0;
	}

	// Handle GPIOHANDLE_SET_LINE_VALUES_IOCTL
	int DoIoctlSetValues(struct gpiohandle_data* data) {
	auto status = line_.SetValue(data->values[0]);
	if (!status.ok()) {
	return -1;
	}

	return 0;
	}
	};

	// Represents an open GPIO chip file, the result of opening /dev/gpiochip*.
	class ChipFile : public MockFile {
	public:
	ChipFile(MockVfs& vfs, const std::string& name, std::vector<Line>& lines)
	: MockFile(vfs, name), lines_(lines) {}

	private:
	std::vector<Line>& lines_;

	//
	// MockFile impl.
	//

	int DoIoctl(unsigned long request, void* arg) override {
	switch (request) {
	case GPIO_GET_LINEHANDLE_IOCTL:
	return DoLinehandleIoctl(static_cast<struct gpiohandle_request*>(arg));
	default:
	PW_LOG_ERROR("%s: Unhandled request=0x%lX", __FUNCTION__, request);
	return -1;
	}
	}

	// Handle GPIO_GET_LINEHANDLE_IOCTL
	int DoLinehandleIoctl(struct gpiohandle_request* req) {
	uint32_t const direction =
	req->flags & (GPIOHANDLE_REQUEST_OUTPUT \| GPIOHANDLE_REQUEST_INPUT);

	// Validate flags.
	if (direction == (GPIOHANDLE_REQUEST_OUTPUT \| GPIOHANDLE_REQUEST_INPUT)) {
	PW_LOG_ERROR("%s: OUTPUT and INPUT are mutually exclusive", __FUNCTION__);
	return -1;
	}

	// Only support requesting one line at at time.
	if (req->lines != 1) {
	PW_LOG_ERROR("%s: Unsupported req->lines=%u", __FUNCTION__, req->lines);
	return -1;
	}

	uint32_t const offset = req->lineoffsets[0];
	uint8_t const default_value = req->default_values[0];
	bool const active_low = req->flags & GPIOHANDLE_REQUEST_ACTIVE_LOW;

	if (offset >= lines_.size()) {
	PW_LOG_ERROR("%s: Invalid line offset: %u", __FUNCTION__, offset);
	return -1;
	}
	Line& line = lines_[offset];

	Status status = OkStatus();
	switch (direction) {
	case GPIOHANDLE_REQUEST_OUTPUT:
	status.Update(line.RequestOutput(active_low));
	status.Update(line.SetValue(default_value));
	break;
	case GPIOHANDLE_REQUEST_INPUT:
	status.Update(line.RequestInput(active_low));
	break;
	}
	if (!status.ok()) {
	return -1;
	}

	req->fd = vfs_.InstallNewFile<LineHandleFile>("line-handle", line);
	return 0;
	}
	};

	// Test fixture for all digtal io tests.
	class DigitalIoTest : public ::testing::Test {
	protected:
	void SetUp() override { GetMockVfs().Reset(); }

	void TearDown() override { EXPECT_TRUE(GetMockVfs().AllFdsClosed()); }

	LinuxDigitalIoChip OpenChip() {
	int fd = GetMockVfs().InstallNewFile<ChipFile>("chip", lines_);
	return LinuxDigitalIoChip(fd);
	}

	Line& line0() { return lines_[0]; }
	Line& line1() { return lines_[1]; }

	private:
	std::vector<Line> lines_ = std::vector<Line>{
	Line(0), // Input
	Line(1), // Output
	};
	};

	//
	// Tests
	//

	TEST_F(DigitalIoTest, DoInput) {
	LinuxDigitalIoChip chip = OpenChip();

	auto& line = line0();
	LinuxInputConfig config(
	/* index= */ 0,
	/* polarity= */ Polarity::kActiveHigh);

	ASSERT_OK_AND_ASSIGN(auto input, chip.GetInputLine(config));

	// Enable the input, and ensure it is requested.
	ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
	ASSERT_OK(input.Enable());
	ASSERT_EQ(line.requested(), Line::RequestedState::kInput);

	Result<State> state;

	// Force the line high and assert it is seen as active (active high).
	line.ForcePhysicalState(true);
	state = input.GetState();
	ASSERT_OK(state.status());
	ASSERT_EQ(State::kActive, state.value());

	// Force the line low and assert it is seen as inactive (active high).
	line.ForcePhysicalState(false);
	state = input.GetState();
	ASSERT_OK(state.status());
	ASSERT_EQ(State::kInactive, state.value());

	// Disable the line and ensure it is no longer requested.
	ASSERT_OK(input.Disable());
	ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
	}

	TEST_F(DigitalIoTest, DoInputInvert) {
	LinuxDigitalIoChip chip = OpenChip();

	auto& line = line0();
	LinuxInputConfig config(
	/* index= */ 0,
	/* polarity= */ Polarity::kActiveLow);

	ASSERT_OK_AND_ASSIGN(auto input, chip.GetInputLine(config));

	// Enable the input, and ensure it is requested.
	ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
	ASSERT_OK(input.Enable());
	ASSERT_EQ(line.requested(), Line::RequestedState::kInput);

	Result<State> state;

	// Force the line high and assert it is seen as inactive (active low).
	line.ForcePhysicalState(true);
	state = input.GetState();
	ASSERT_OK(state.status());
	ASSERT_EQ(State::kInactive, state.value());

	// Force the line low and assert it is seen as active (active low).
	line.ForcePhysicalState(false);
	state = input.GetState();
	ASSERT_OK(state.status());
	ASSERT_EQ(State::kActive, state.value());

	// Disable the line and ensure it is no longer requested.
	ASSERT_OK(input.Disable());
	ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
	}

	TEST_F(DigitalIoTest, DoOutput) {
	LinuxDigitalIoChip chip = OpenChip();

	auto& line = line1();
	LinuxOutputConfig config(
	/* index= */ 1,
	/* polarity= */ Polarity::kActiveHigh,
	/* default_state= */ State::kActive);

	ASSERT_OK_AND_ASSIGN(auto output, chip.GetOutputLine(config));

	// Enable the output, and ensure it is requested.
	ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
	ASSERT_OK(output.Enable());
	ASSERT_EQ(line.requested(), Line::RequestedState::kOutput);

	// Expect the line to go high, due to default_state=kActive (active high).
	ASSERT_TRUE(line.physical_state());

	// Set the output's state to inactive, and assert it goes low (active high).
	ASSERT_OK(output.SetStateInactive());
	ASSERT_FALSE(line.physical_state());

	// Set the output's state to active, and assert it goes high (active high).
	ASSERT_OK(output.SetStateActive());
	ASSERT_TRUE(line.physical_state());

	// Disable the line and ensure it is no longer requested.
	ASSERT_OK(output.Disable());
	ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
	// NOTE: We do not assert line.physical_state() here.
	// See the warning on LinuxDigitalOut in docs.rst.
	}

	TEST_F(DigitalIoTest, DoOutputInvert) {
	LinuxDigitalIoChip chip = OpenChip();

	auto& line = line1();
	LinuxOutputConfig config(
	/* index= */ 1,
	/* polarity= */ Polarity::kActiveLow,
	/* default_state= */ State::kActive);

	ASSERT_OK_AND_ASSIGN(auto output, chip.GetOutputLine(config));

	// Enable the output, and ensure it is requested.
	ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
	ASSERT_OK(output.Enable());
	ASSERT_EQ(line.requested(), Line::RequestedState::kOutput);

	// Expect the line to stay low, due to default_state=kActive (active low).
	ASSERT_FALSE(line.physical_state());

	// Set the output's state to inactive, and assert it goes high (active low).
	ASSERT_OK(output.SetStateInactive());
	ASSERT_TRUE(line.physical_state());

	// Set the output's state to active, and assert it goes low (active low).
	ASSERT_OK(output.SetStateActive());
	ASSERT_FALSE(line.physical_state());

	// Disable the line and ensure it is no longer requested.
	ASSERT_OK(output.Disable());
	ASSERT_EQ(line.requested(), Line::RequestedState::kNone);
	// NOTE: We do not assert line.physical_state() here.
	// See the warning on LinuxDigitalOut in docs.rst.
	}

	// Verify we can get the state of an output.
	TEST_F(DigitalIoTest, OutputGetState) {
	LinuxDigitalIoChip chip = OpenChip();

	auto& line = line1();
	LinuxOutputConfig config(
	/* index= */ 1,
	/* polarity= */ Polarity::kActiveHigh,
	/* default_state= */ State::kInactive);

	ASSERT_OK_AND_ASSIGN(auto output, chip.GetOutputLine(config));

	ASSERT_OK(output.Enable());

	// Expect the line to stay low, due to default_state=kInactive (active high).
	ASSERT_FALSE(line.physical_state());

	Result<State> state;

	// Verify GetState() returns the expected state: inactive (default_state).
	state = output.GetState();
	ASSERT_OK(state.status());
	ASSERT_EQ(State::kInactive, state.value());

	// Set the output's state to active, then verify GetState() returns the
	// new expected state.
	ASSERT_OK(output.SetStateActive());
	state = output.GetState();
	ASSERT_OK(state.status());
	ASSERT_EQ(State::kActive, state.value());
	}

	} // namespace
	} // namespace pw::digital_io