| // 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 "mock-registers.h" |
| |
| #include <lib/async-loop/cpp/loop.h> |
| |
| #include <zxtest/zxtest.h> |
| |
| namespace mock_registers { |
| |
| class MockRegistersTest : public zxtest::Test { |
| public: |
| void SetUp() override { |
| zx_status_t status; |
| |
| loop_.StartThread(); |
| |
| device_ = std::make_unique<MockRegistersDevice>(loop_.dispatcher()); |
| |
| zx::channel client_end, server_end; |
| if ((status = zx::channel::create(0, &client_end, &server_end)) != ZX_OK) { |
| printf("Could not create channel %d\n", status); |
| return; |
| } |
| device_->RegistersConnect(std::move(server_end)); |
| client_ = ::llcpp::fuchsia::hardware::registers::Device::SyncClient(std::move(client_end)); |
| } |
| |
| void TearDown() override { |
| EXPECT_OK(registers()->VerifyAll()); |
| loop_.Shutdown(); |
| } |
| |
| MockRegisters* registers() { return device_->fidl_service(); } |
| |
| protected: |
| std::unique_ptr<MockRegistersDevice> device_; |
| |
| ::llcpp::fuchsia::hardware::registers::Device::SyncClient client_; |
| async::Loop loop_{&kAsyncLoopConfigNeverAttachToThread}; |
| }; |
| |
| TEST_F(MockRegistersTest, ReadTest) { |
| // 8-bit |
| registers()->ExpectRead<uint8_t>(0, 1, 2); |
| auto read8_res = client_.ReadRegister8(0, 1); |
| EXPECT_TRUE(read8_res.ok()); |
| EXPECT_TRUE(read8_res->result.is_response()); |
| EXPECT_EQ(read8_res->result.response().value, 2); |
| |
| // 16-bit |
| registers()->ExpectRead<uint16_t>(5, 15, 3); |
| auto read16_res = client_.ReadRegister16(5, 15); |
| EXPECT_TRUE(read16_res.ok()); |
| EXPECT_TRUE(read16_res->result.is_response()); |
| EXPECT_EQ(read16_res->result.response().value, 3); |
| |
| // 32-bit |
| registers()->ExpectRead<uint32_t>(145, 127, 25); |
| auto read32_res = client_.ReadRegister32(145, 127); |
| EXPECT_TRUE(read32_res.ok()); |
| EXPECT_TRUE(read32_res->result.is_response()); |
| EXPECT_EQ(read32_res->result.response().value, 25); |
| |
| // 64-bit |
| registers()->ExpectRead<uint64_t>(325, 54, 136); |
| auto read64_res = client_.ReadRegister64(325, 54); |
| EXPECT_TRUE(read64_res.ok()); |
| EXPECT_TRUE(read64_res->result.is_response()); |
| EXPECT_EQ(read64_res->result.response().value, 136); |
| |
| // Multiple Reads |
| registers()->ExpectRead<uint32_t>(25, 63, 46); |
| registers()->ExpectRead<uint32_t>(25, 84, 53); |
| registers()->ExpectRead<uint32_t>(102, 57, 7); |
| registers()->ExpectRead<uint32_t>(3, 24, 299); |
| registers()->ExpectRead<uint32_t>(102, 67, 38); |
| auto res1 = client_.ReadRegister32(25, 63); |
| EXPECT_TRUE(res1.ok()); |
| EXPECT_TRUE(res1->result.is_response()); |
| EXPECT_EQ(res1->result.response().value, 46); |
| auto res2 = client_.ReadRegister32(25, 84); |
| EXPECT_TRUE(res2.ok()); |
| EXPECT_TRUE(res2->result.is_response()); |
| EXPECT_EQ(res2->result.response().value, 53); |
| auto res3 = client_.ReadRegister32(102, 57); |
| EXPECT_TRUE(res3.ok()); |
| EXPECT_TRUE(res3->result.is_response()); |
| EXPECT_EQ(res3->result.response().value, 7); |
| auto res4 = client_.ReadRegister32(3, 24); |
| EXPECT_TRUE(res4.ok()); |
| EXPECT_TRUE(res4->result.is_response()); |
| EXPECT_EQ(res4->result.response().value, 299); |
| auto res5 = client_.ReadRegister32(102, 67); |
| EXPECT_TRUE(res5.ok()); |
| EXPECT_TRUE(res5->result.is_response()); |
| EXPECT_EQ(res5->result.response().value, 38); |
| } |
| |
| TEST_F(MockRegistersTest, WriteTest) { |
| // 8-bit |
| registers()->ExpectWrite<uint8_t>(0, 1, 2); |
| auto write8_res = client_.WriteRegister8(0, 1, 2); |
| EXPECT_TRUE(write8_res.ok()); |
| EXPECT_TRUE(write8_res->result.is_response()); |
| |
| // 16-bit |
| registers()->ExpectWrite<uint16_t>(5, 15, 3); |
| auto write16_res = client_.WriteRegister16(5, 15, 3); |
| EXPECT_TRUE(write16_res.ok()); |
| EXPECT_TRUE(write16_res->result.is_response()); |
| |
| // 32-bit |
| registers()->ExpectWrite<uint32_t>(145, 127, 25); |
| auto write32_res = client_.WriteRegister32(145, 127, 25); |
| EXPECT_TRUE(write32_res.ok()); |
| EXPECT_TRUE(write32_res->result.is_response()); |
| |
| // 64-bit |
| registers()->ExpectWrite<uint64_t>(325, 54, 136); |
| auto write64_res = client_.WriteRegister64(325, 54, 136); |
| EXPECT_TRUE(write64_res.ok()); |
| EXPECT_TRUE(write64_res->result.is_response()); |
| |
| // Multiple Writes |
| registers()->ExpectWrite<uint32_t>(25, 63, 46); |
| registers()->ExpectWrite<uint32_t>(25, 84, 53); |
| registers()->ExpectWrite<uint32_t>(102, 57, 7); |
| registers()->ExpectWrite<uint32_t>(3, 24, 299); |
| registers()->ExpectWrite<uint32_t>(102, 67, 38); |
| auto res1 = client_.WriteRegister32(25, 63, 46); |
| EXPECT_TRUE(res1.ok()); |
| EXPECT_TRUE(res1->result.is_response()); |
| auto res2 = client_.WriteRegister32(25, 84, 53); |
| EXPECT_TRUE(res2.ok()); |
| EXPECT_TRUE(res2->result.is_response()); |
| auto res3 = client_.WriteRegister32(102, 57, 7); |
| EXPECT_TRUE(res3.ok()); |
| EXPECT_TRUE(res3->result.is_response()); |
| auto res4 = client_.WriteRegister32(3, 24, 299); |
| EXPECT_TRUE(res4.ok()); |
| EXPECT_TRUE(res4->result.is_response()); |
| auto res5 = client_.WriteRegister32(102, 67, 38); |
| EXPECT_TRUE(res5.ok()); |
| EXPECT_TRUE(res5->result.is_response()); |
| } |
| |
| } // namespace mock_registers |