1 // Copyright 2021 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "pw_i2c/device.h"
16
17 #include <chrono>
18
19 #include "pw_bytes/byte_builder.h"
20 #include "pw_containers/algorithm.h"
21 #include "pw_i2c/initiator_mock.h"
22 #include "pw_unit_test/framework.h"
23
24 using namespace std::literals::chrono_literals;
25
26 namespace pw::i2c {
27 namespace {
28
29 constexpr auto kI2cTransactionTimeout = chrono::SystemClock::for_at_least(2ms);
30
TEST(Device,WriteReadForOk)31 TEST(Device, WriteReadForOk) {
32 constexpr Address kTestDeviceAddress = Address::SevenBit<0x3F>();
33
34 constexpr auto kExpectWrite1 = bytes::Array<1, 2, 3>();
35 constexpr auto kExpectRead1 = bytes::Array<1, 2>();
36
37 auto expected_transactions =
38 MakeExpectedTransactionArray({Transaction(OkStatus(),
39 kTestDeviceAddress,
40 kExpectWrite1,
41 kExpectRead1,
42 kI2cTransactionTimeout)});
43
44 MockInitiator initiator(expected_transactions);
45
46 Device device = Device(initiator, kTestDeviceAddress);
47
48 std::array<std::byte, kExpectRead1.size()> read1;
49 EXPECT_EQ(device.WriteReadFor(kExpectWrite1, read1, kI2cTransactionTimeout),
50 OkStatus());
51 EXPECT_TRUE(pw::containers::Equal(read1, kExpectRead1));
52 EXPECT_EQ(initiator.Finalize(), OkStatus());
53 }
54
TEST(Device,WriteForOk)55 TEST(Device, WriteForOk) {
56 constexpr Address kTestDeviceAddress = Address::SevenBit<0x3F>();
57
58 constexpr auto kExpectWrite1 = bytes::Array<1, 2, 3>();
59
60 auto expected_transactions = MakeExpectedTransactionArray({WriteTransaction(
61 OkStatus(), kTestDeviceAddress, kExpectWrite1, kI2cTransactionTimeout)});
62
63 MockInitiator initiator(expected_transactions);
64 Device device = Device(initiator, kTestDeviceAddress);
65
66 EXPECT_EQ(device.WriteFor(kExpectWrite1, kI2cTransactionTimeout), OkStatus());
67 EXPECT_EQ(initiator.Finalize(), OkStatus());
68 }
69
TEST(Device,ReadForOk)70 TEST(Device, ReadForOk) {
71 constexpr Address kTestDeviceAddress = Address::SevenBit<0x3F>();
72
73 constexpr auto kExpectRead1 = bytes::Array<1, 2, 3>();
74
75 auto expected_transactions = MakeExpectedTransactionArray({ReadTransaction(
76 OkStatus(), kTestDeviceAddress, kExpectRead1, kI2cTransactionTimeout)});
77
78 MockInitiator initiator(expected_transactions);
79 Device device = Device(initiator, kTestDeviceAddress);
80
81 std::array<std::byte, kExpectRead1.size()> read1;
82 EXPECT_EQ(device.ReadFor(read1, kI2cTransactionTimeout), OkStatus());
83 EXPECT_EQ(initiator.Finalize(), OkStatus());
84 }
85
TEST(Device,ProbeDeviceForOk)86 TEST(Device, ProbeDeviceForOk) {
87 constexpr Address kTestDeviceAddress = Address::SevenBit<0x3F>();
88
89 auto expected_transactions = MakeExpectedTransactionArray({ProbeTransaction(
90 OkStatus(), kTestDeviceAddress, kI2cTransactionTimeout)});
91
92 MockInitiator initiator(expected_transactions);
93 Device device = Device(initiator, kTestDeviceAddress);
94
95 EXPECT_EQ(
96 initiator.ProbeDeviceFor(kTestDeviceAddress, kI2cTransactionTimeout),
97 OkStatus());
98 EXPECT_EQ(initiator.Finalize(), OkStatus());
99 }
100
101 } // namespace
102 } // namespace pw::i2c
103