| // Copyright 2020 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "i2c-child.h" |
| |
| #include <fidl/fuchsia.hardware.i2cimpl/cpp/driver/wire.h> |
| #include <lib/async-loop/cpp/loop.h> |
| #include <lib/async_patterns/testing/cpp/dispatcher_bound.h> |
| #include <lib/ddk/metadata.h> |
| #include <lib/fit/result.h> |
| #include <lib/stdcompat/span.h> |
| #include <lib/zx/result.h> |
| |
| #include <algorithm> |
| #include <utility> |
| |
| #include <zxtest/zxtest.h> |
| |
| #include "fake-incoming-namespace.h" |
| #include "i2c.h" |
| #include "src/devices/testing/mock-ddk/mock-device.h" |
| |
| namespace i2c { |
| namespace fi2cimpl = fuchsia_hardware_i2cimpl; |
| |
| constexpr uint8_t kTestWrite0 = 0x99; |
| constexpr uint8_t kTestWrite1 = 0x88; |
| constexpr uint8_t kTestWrite2 = 0x77; |
| constexpr uint8_t kTestRead0 = 0x12; |
| constexpr uint8_t kTestRead1 = 0x34; |
| constexpr uint8_t kTestRead2 = 0x56; |
| |
| class I2cChildTest : public zxtest::Test { |
| protected: |
| // Because this test is using a fidl::WireSyncClient, we need to run any ops on the client on |
| // their own thread because the testing thread is shared with the fidl::Server<fi2c::Device>. An |
| // alternative strategy would be to port this to using an async client instead. |
| static void RunSyncClientTask(fit::closure task) { |
| async::Loop loop{&kAsyncLoopConfigNeverAttachToThread}; |
| loop.StartThread(); |
| zx::result result = fdf::RunOnDispatcherSync(loop.dispatcher(), std::move(task)); |
| ASSERT_EQ(ZX_OK, result.status_value()); |
| } |
| |
| static constexpr char kDefaultName[] = ""; |
| |
| fidl::WireSyncClient<fuchsia_hardware_i2c::Device> GetI2cChildClient( |
| const char* name = kDefaultName, const uint32_t bus_id = 0) { |
| fidl::WireSyncClient<fuchsia_hardware_i2c::Device> client{}; |
| GetI2cChildClient(name, &client, bus_id); |
| return client; |
| } |
| |
| void SetMetadata(const char* name, const uint32_t bus_id) { |
| fidl::Arena<> arena; |
| |
| fidl::VectorView<fuchsia_hardware_i2c_businfo::wire::I2CChannel> channels(arena, 1); |
| channels[0] = fuchsia_hardware_i2c_businfo::wire::I2CChannel::Builder(arena) |
| .address(0x10) |
| .name(name) |
| .Build(); |
| auto metadata = fuchsia_hardware_i2c_businfo::wire::I2CBusMetadata::Builder(arena) |
| .channels(channels) |
| .bus_id(bus_id) |
| .Build(); |
| |
| auto bytes = fidl::Persist(metadata); |
| ASSERT_TRUE(bytes.is_ok()); |
| |
| fake_root_->SetMetadata(DEVICE_METADATA_I2C_CHANNELS, bytes->data(), bytes->size()); |
| } |
| |
| // Helper function that returns void to allow ASSERT and EXPECT calls. |
| void GetI2cChildClient(const char* name, |
| fidl::WireSyncClient<fuchsia_hardware_i2c::Device>* client, |
| const uint32_t bus_id) { |
| auto io_eps = fidl::Endpoints<fuchsia_io::Directory>::Create(); |
| namespace_.SyncCall(&FakeIncomingNamespace::AddI2cImplService, std::move(io_eps.server)); |
| fake_root_->AddFidlService(fi2cimpl::Service::Name, std::move(io_eps.client)); |
| |
| SetMetadata(name, bus_id); |
| |
| auto i2c_eps = fidl::Endpoints<fuchsia_hardware_i2c::Device>::Create(); |
| |
| *client = fidl::WireSyncClient<fuchsia_hardware_i2c::Device>(std::move(i2c_eps.client)); |
| |
| EXPECT_OK(I2cDevice::Create(nullptr, fake_root_.get())); |
| ASSERT_EQ(fake_root_->child_count(), 1); |
| |
| zx_device_t* i2c_root = fake_root_->GetLatestChild(); |
| auto* const i2c_child = i2c_root->GetLatestChild()->GetDeviceContext<I2cChild>(); |
| i2c_child->Bind(std::move(i2c_eps.server)); |
| } |
| |
| async_dispatcher_t* dispatcher() { return dispatcher_->async_dispatcher(); } |
| fdf_testing::DriverRuntime& runtime() { return *fdf_testing::DriverRuntime::GetInstance(); } |
| |
| std::shared_ptr<zx_device> fake_root_{MockDevice::FakeRootParent()}; |
| fdf::UnownedSynchronizedDispatcher dispatcher_ = runtime().StartBackgroundDispatcher(); |
| async_patterns::TestDispatcherBound<FakeIncomingNamespace> namespace_{dispatcher(), std::in_place, |
| 1024}; |
| }; |
| |
| TEST_F(I2cChildTest, Write3BytesOnce) { |
| auto on_transact = [](FakeI2cImpl::TransactRequestView req, fdf::Arena& arena, |
| FakeI2cImpl::TransactCompleter::Sync& comp) { |
| fidl::VectorView<fi2cimpl::wire::I2cImplOp>& ops = req->op; |
| |
| if (ops.count() != 1) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| |
| const auto& op = ops[0]; |
| if (op.type.is_read_size()) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| |
| auto write_data = op.type.write_data(); |
| if (write_data.count() != 3 || write_data[0] != kTestWrite0 || write_data[1] != kTestWrite1 || |
| write_data[2] != kTestWrite2) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| |
| // No read data. |
| comp.buffer(arena).ReplySuccess({}); |
| }; |
| namespace_.SyncCall(&FakeIncomingNamespace::set_on_transact, std::move(on_transact)); |
| |
| auto client_wrap = GetI2cChildClient(); |
| ASSERT_TRUE(client_wrap.is_valid()); |
| |
| // 3 bytes in 1 write transaction. |
| size_t n_write_bytes = 3; |
| auto write_buffer = std::make_unique<uint8_t[]>(n_write_bytes); |
| write_buffer[0] = kTestWrite0; |
| write_buffer[1] = kTestWrite1; |
| write_buffer[2] = kTestWrite2; |
| auto write_data = fidl::VectorView<uint8_t>::FromExternal(write_buffer.get(), n_write_bytes); |
| |
| fidl::Arena arena; |
| auto write_transfer = fidl_i2c::wire::DataTransfer::WithWriteData(arena, write_data); |
| |
| auto transactions = fidl::VectorView<fidl_i2c::wire::Transaction>(arena, 1); |
| transactions[0] = |
| fidl_i2c::wire::Transaction::Builder(arena).data_transfer(write_transfer).Build(); |
| |
| RunSyncClientTask([&]() { |
| auto read = client_wrap->Transfer(transactions); |
| ASSERT_OK(read.status()); |
| ASSERT_FALSE(read->is_error()); |
| }); |
| } |
| |
| TEST_F(I2cChildTest, Read3BytesOnce) { |
| auto on_transact = [](FakeI2cImpl::TransactRequestView req, fdf::Arena& arena, |
| FakeI2cImpl::TransactCompleter::Sync& comp) { |
| fidl::VectorView<fi2cimpl::wire::I2cImplOp>& ops = req->op; |
| |
| if (ops.count() != 1) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| |
| const auto& op = ops[0]; |
| if (op.type.is_write_data() || !op.stop || op.type.read_size() != 3) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| |
| std::vector<uint8_t> data{kTestRead0, kTestRead1, kTestRead2}; |
| |
| fidl::VectorView<fi2cimpl::wire::ReadData> read{arena, 1}; |
| read[0].data = fidl::VectorView<uint8_t>{arena, data}; |
| comp.buffer(arena).ReplySuccess(read); |
| }; |
| namespace_.SyncCall(&FakeIncomingNamespace::set_on_transact, std::move(on_transact)); |
| |
| auto client_wrap = GetI2cChildClient(); |
| ASSERT_TRUE(client_wrap.is_valid()); |
| |
| // 1 read transaction expecting 3 bytes. |
| constexpr size_t n_bytes = 3; |
| |
| fidl::Arena arena; |
| auto read_transfer = fidl_i2c::wire::DataTransfer::WithReadSize(n_bytes); |
| |
| auto transactions = fidl::VectorView<fidl_i2c::wire::Transaction>(arena, 1); |
| transactions[0] = |
| fidl_i2c::wire::Transaction::Builder(arena).data_transfer(read_transfer).Build(); |
| |
| RunSyncClientTask([&]() { |
| auto read = client_wrap->Transfer(transactions); |
| ASSERT_OK(read.status()); |
| ASSERT_FALSE(read->is_error()); |
| ASSERT_EQ(read->value()->read_data.count(), 1); |
| ASSERT_EQ(read->value()->read_data[0][0], kTestRead0); |
| ASSERT_EQ(read->value()->read_data[0][1], kTestRead1); |
| ASSERT_EQ(read->value()->read_data[0][2], kTestRead2); |
| }); |
| } |
| |
| TEST_F(I2cChildTest, Write1ByteOnceRead1Byte3Times) { |
| auto on_transact = [](FakeI2cImpl::TransactRequestView req, fdf::Arena& arena, |
| FakeI2cImpl::TransactCompleter::Sync& comp) { |
| fidl::VectorView<fi2cimpl::wire::I2cImplOp>& ops = req->op; |
| |
| if (ops.count() != 4) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| |
| const auto& op1 = ops[0]; |
| const auto& op2 = ops[1]; |
| const auto& op3 = ops[2]; |
| const auto& op4 = ops[3]; |
| |
| if (op1.type.is_read_size()) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| const auto& op1_write_data = op1.type.write_data(); |
| if (op1_write_data.count() != 1 || op1_write_data[0] != kTestWrite0) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| |
| if (op2.type.is_write_data() || op2.type.read_size() != 1 || op3.type.is_write_data() || |
| op3.type.read_size() != 1 || op4.type.is_write_data() || op4.type.read_size() != 1) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| |
| std::vector<uint8_t> data0{kTestRead0}; |
| std::vector<uint8_t> data1{kTestRead1}; |
| std::vector<uint8_t> data2{kTestRead2}; |
| |
| fidl::VectorView<fi2cimpl::wire::ReadData> read{arena, 3}; |
| read[0].data = fidl::VectorView<uint8_t>{arena, data0}; |
| read[1].data = fidl::VectorView<uint8_t>{arena, data1}; |
| read[2].data = fidl::VectorView<uint8_t>{arena, data2}; |
| |
| comp.buffer(arena).ReplySuccess(read); |
| }; |
| namespace_.SyncCall(&FakeIncomingNamespace::set_on_transact, std::move(on_transact)); |
| |
| auto client_wrap = GetI2cChildClient(); |
| ASSERT_TRUE(client_wrap.is_valid()); |
| |
| // 1 byte in 1 write transaction. |
| size_t n_write_bytes = 1; |
| auto write_buffer = std::make_unique<uint8_t[]>(n_write_bytes); |
| write_buffer[0] = kTestWrite0; |
| auto write_data = fidl::VectorView<uint8_t>::FromExternal(write_buffer.get(), n_write_bytes); |
| |
| fidl::Arena arena; |
| auto transactions = fidl::VectorView<fidl_i2c::wire::Transaction>(arena, 4); |
| |
| transactions[0] = |
| fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithWriteData(arena, write_data)) |
| .Build(); |
| |
| // 3 read transaction expecting 1 byte each. |
| transactions[1] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithReadSize(1)) |
| .Build(); |
| |
| transactions[2] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithReadSize(1)) |
| .Build(); |
| |
| transactions[3] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithReadSize(1)) |
| .Build(); |
| |
| RunSyncClientTask([&]() { |
| auto read = client_wrap->Transfer(transactions); |
| ASSERT_OK(read.status()); |
| ASSERT_FALSE(read->is_error()); |
| |
| ASSERT_EQ(read->value()->read_data[0][0], kTestRead0); |
| ASSERT_EQ(read->value()->read_data[1][0], kTestRead1); |
| ASSERT_EQ(read->value()->read_data[2][0], kTestRead2); |
| }); |
| } |
| |
| TEST_F(I2cChildTest, StopFlagPropagates) { |
| auto on_transact = [](FakeI2cImpl::TransactRequestView req, fdf::Arena& arena, |
| FakeI2cImpl::TransactCompleter::Sync& comp) { |
| fidl::VectorView<fi2cimpl::wire::I2cImplOp>& ops = req->op; |
| |
| if (ops.count() != 4) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| |
| // Verify that the I2C child driver set the stop flags correctly based on the transaction |
| // list passed in below. |
| if (!ops[0].stop || ops[1].stop || ops[2].stop || !ops[3].stop) { |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| return; |
| } |
| |
| std::vector<uint8_t> data0{kTestRead0}; |
| std::vector<uint8_t> data1{kTestRead1}; |
| std::vector<uint8_t> data2{kTestRead2}; |
| std::vector<uint8_t> data3{kTestRead0}; |
| |
| fidl::VectorView<fi2cimpl::wire::ReadData> read{arena, 4}; |
| read[0].data = fidl::VectorView<uint8_t>{arena, data0}; |
| read[1].data = fidl::VectorView<uint8_t>{arena, data1}; |
| read[2].data = fidl::VectorView<uint8_t>{arena, data2}; |
| read[2].data = fidl::VectorView<uint8_t>{arena, data3}; |
| |
| comp.buffer(arena).ReplySuccess(read); |
| }; |
| namespace_.SyncCall(&FakeIncomingNamespace::set_on_transact, std::move(on_transact)); |
| |
| auto client_wrap = GetI2cChildClient(); |
| ASSERT_TRUE(client_wrap.is_valid()); |
| |
| fidl::Arena arena; |
| auto transactions = fidl::VectorView<fidl_i2c::wire::Transaction>(arena, 4); |
| |
| // Specified and set to true: the stop flag should be set to true. |
| transactions[0] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithReadSize(1)) |
| .stop(true) |
| .Build(); |
| |
| // Specified and set to false: the stop flag should be set to false. |
| transactions[1] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithReadSize(1)) |
| .stop(false) |
| .Build(); |
| |
| // Unspecified: the stop flag should be set to false. |
| transactions[2] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithReadSize(1)) |
| .Build(); |
| |
| // Final transaction: the stop flag should be set to true. |
| transactions[3] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithReadSize(1)) |
| .stop(false) |
| .Build(); |
| |
| RunSyncClientTask([&]() { |
| auto read = client_wrap->Transfer(transactions); |
| ASSERT_OK(read.status()); |
| ASSERT_FALSE(read.value().is_error()); |
| }); |
| } |
| |
| TEST_F(I2cChildTest, BadTransfers) { |
| auto on_transact = [](FakeI2cImpl::TransactRequestView req, fdf::Arena& arena, |
| FakeI2cImpl::TransactCompleter::Sync& comp) { |
| // Won't be called into, but in case it is, error out. |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| }; |
| namespace_.SyncCall(&FakeIncomingNamespace::set_on_transact, std::move(on_transact)); |
| |
| auto client_wrap = GetI2cChildClient(); |
| ASSERT_TRUE(client_wrap.is_valid()); |
| |
| { |
| // There must be at least one Transaction. |
| fidl::Arena arena; |
| auto transactions = fidl::VectorView<fidl_i2c::wire::Transaction>(arena, 0); |
| |
| RunSyncClientTask([&]() { |
| auto read = client_wrap->Transfer(transactions); |
| ASSERT_OK(read.status()); |
| ASSERT_TRUE(read->is_error()); |
| }); |
| } |
| |
| { |
| // Each Transaction must have data_transfer set. |
| fidl::Arena arena; |
| auto transactions = fidl::VectorView<fidl_i2c::wire::Transaction>(arena, 2); |
| |
| transactions[0] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithReadSize(1)) |
| .Build(); |
| |
| transactions[1] = fidl_i2c::wire::Transaction::Builder(arena).stop(true).Build(); |
| |
| RunSyncClientTask([&]() { |
| auto read = client_wrap->Transfer(transactions); |
| ASSERT_OK(read.status()); |
| ASSERT_TRUE(read->is_error()); |
| }); |
| } |
| |
| { |
| // Read transfers must be at least one byte. |
| fidl::Arena arena; |
| auto transactions = fidl::VectorView<fidl_i2c::wire::Transaction>(arena, 2); |
| |
| transactions[0] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithReadSize(1)) |
| .Build(); |
| |
| transactions[1] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithReadSize(0)) |
| .Build(); |
| |
| RunSyncClientTask([&]() { |
| auto read = client_wrap->Transfer(transactions); |
| ASSERT_OK(read.status()); |
| ASSERT_TRUE(read->is_error()); |
| }); |
| } |
| |
| { |
| // Each Transaction must have data_transfer set. |
| fidl::Arena arena; |
| auto transactions = fidl::VectorView<fidl_i2c::wire::Transaction>(arena, 2); |
| |
| auto write0 = fidl::VectorView<uint8_t>(arena, 1); |
| write0[0] = 0xff; |
| |
| auto write1 = fidl::VectorView<uint8_t>(arena, 0); |
| |
| transactions[0] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithWriteData(arena, write0)) |
| .Build(); |
| |
| transactions[1] = fidl_i2c::wire::Transaction::Builder(arena) |
| .data_transfer(fidl_i2c::wire::DataTransfer::WithWriteData(arena, write1)) |
| .Build(); |
| |
| RunSyncClientTask([&]() { |
| auto read = client_wrap->Transfer(transactions); |
| ASSERT_OK(read.status()); |
| ASSERT_TRUE(read->is_error()); |
| }); |
| } |
| } |
| |
| TEST_F(I2cChildTest, GetNameTest) { |
| const std::string kTestName = "foo"; |
| |
| auto on_transact = [](FakeI2cImpl::TransactRequestView req, fdf::Arena& arena, |
| FakeI2cImpl::TransactCompleter::Sync& comp) { |
| // Won't be called into, but in case it is, error out. |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| }; |
| namespace_.SyncCall(&FakeIncomingNamespace::set_on_transact, std::move(on_transact)); |
| |
| auto client_wrap = GetI2cChildClient(kTestName.c_str()); |
| ASSERT_TRUE(client_wrap.is_valid()); |
| |
| RunSyncClientTask([&]() { |
| auto name = client_wrap->GetName(); |
| ASSERT_OK(name.status()); |
| ASSERT_FALSE(name->is_error()); |
| |
| ASSERT_EQ(std::string(name->value()->name.get()), kTestName); |
| }); |
| } |
| |
| TEST_F(I2cChildTest, GetEmptyNameTest) { |
| auto on_transact = [](FakeI2cImpl::TransactRequestView req, fdf::Arena& arena, |
| FakeI2cImpl::TransactCompleter::Sync& comp) { |
| // Won't be called into, but in case it is, error out. |
| comp.buffer(arena).ReplyError(ZX_ERR_INTERNAL); |
| }; |
| namespace_.SyncCall(&FakeIncomingNamespace::set_on_transact, std::move(on_transact)); |
| |
| auto client_wrap = GetI2cChildClient(); |
| ASSERT_TRUE(client_wrap.is_valid()); |
| |
| RunSyncClientTask([&]() { |
| auto name = client_wrap->GetName(); |
| ASSERT_OK(name.status()); |
| |
| // Empty string here means this endpoint returns an error. |
| ASSERT_TRUE(name->is_error()); |
| }); |
| } |
| |
| TEST_F(I2cChildTest, HugeTransfer) { |
| auto on_transact = [](FakeI2cImpl::TransactRequestView req, fdf::Arena& arena, |
| FakeI2cImpl::TransactCompleter::Sync& comp) { |
| fidl::VectorView<fi2cimpl::wire::I2cImplOp>& ops = req->op; |
| constexpr size_t kReadCount = 1024; |
| |
| std::vector<fi2cimpl::wire::ReadData> reads; |
| for (auto& op : ops) { |
| if (op.type.is_read_size() > 0) { |
| if (op.type.read_size() != kReadCount) { |
| comp.buffer(arena).ReplyError(ZX_ERR_IO); |
| } |
| fi2cimpl::wire::ReadData read{{arena, kReadCount}}; |
| memset(read.data.data(), 'r', kReadCount); |
| reads.push_back(read); |
| } else { |
| auto& write_data = op.type.write_data(); |
| if (std::any_of(write_data.begin(), write_data.end(), [](uint8_t b) { return b != 'w'; })) { |
| comp.buffer(arena).ReplyError(ZX_ERR_IO); |
| return; |
| } |
| } |
| } |
| |
| comp.buffer(arena).ReplySuccess({arena, reads}); |
| }; |
| namespace_.SyncCall(&FakeIncomingNamespace::set_on_transact, std::move(on_transact)); |
| |
| auto client_wrap = GetI2cChildClient(); |
| ASSERT_TRUE(client_wrap.is_valid()); |
| |
| auto write_buffer = std::make_unique<uint8_t[]>(1024); |
| auto write_data = fidl::VectorView<uint8_t>::FromExternal(write_buffer.get(), 1024); |
| memset(write_data.data(), 'w', write_data.count()); |
| |
| fidl::Arena arena; |
| auto write_transfer = fidl_i2c::wire::DataTransfer::WithWriteData(arena, write_data); |
| auto read_transfer = fidl_i2c::wire::DataTransfer::WithReadSize(1024); |
| |
| auto transactions = fidl::VectorView<fidl_i2c::wire::Transaction>(arena, 2); |
| transactions[0] = |
| fidl_i2c::wire::Transaction::Builder(arena).data_transfer(write_transfer).Build(); |
| transactions[1] = |
| fidl_i2c::wire::Transaction::Builder(arena).data_transfer(read_transfer).Build(); |
| |
| RunSyncClientTask([&]() { |
| auto read = client_wrap->Transfer(transactions); |
| |
| ASSERT_OK(read.status()); |
| ASSERT_FALSE(read->is_error()); |
| |
| ASSERT_EQ(read->value()->read_data.count(), 1); |
| ASSERT_EQ(read->value()->read_data[0].count(), 1024); |
| cpp20::span data(read->value()->read_data[0].data(), read->value()->read_data[0].count()); |
| EXPECT_TRUE(std::all_of(data.begin(), data.end(), [](uint8_t b) { return b == 'r'; })); |
| }); |
| } |
| |
| } // namespace i2c |
