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/initiator_mock.h"
16
17 #include <array>
18 #include <chrono>
19
20 #include "pw_bytes/array.h"
21 #include "pw_bytes/span.h"
22 #include "pw_chrono/system_clock.h"
23 #include "pw_containers/algorithm.h"
24 #include "pw_i2c/address.h"
25 #include "pw_span/span.h"
26 #include "pw_unit_test/framework.h"
27
28 using namespace std::literals::chrono_literals;
29
30 namespace pw::i2c {
31 namespace {
32
33 constexpr auto kI2cTransactionTimeout = chrono::SystemClock::for_at_least(2ms);
34
TEST(Transaction,Read)35 TEST(Transaction, Read) {
36 static constexpr Address kAddress1 = Address::SevenBit<0x01>();
37 constexpr auto kExpectRead1 = bytes::Array<1, 2, 3, 4, 5>();
38
39 static constexpr Address kAddress2 = Address::SevenBit<0x02>();
40 constexpr auto kExpectRead2 = bytes::Array<3, 4, 5>();
41
42 auto expected_transactions = MakeExpectedTransactionArray(
43 {ReadTransaction(
44 OkStatus(), kAddress1, kExpectRead1, kI2cTransactionTimeout),
45 ReadTransaction(
46 OkStatus(), kAddress2, kExpectRead2, kI2cTransactionTimeout)});
47
48 MockInitiator mocked_i2c(expected_transactions);
49
50 std::array<std::byte, kExpectRead1.size()> read1;
51 EXPECT_EQ(mocked_i2c.ReadFor(kAddress1, read1, kI2cTransactionTimeout),
52 OkStatus());
53 EXPECT_TRUE(pw::containers::Equal(read1, kExpectRead1));
54
55 std::array<std::byte, kExpectRead2.size()> read2;
56 EXPECT_EQ(mocked_i2c.ReadFor(kAddress2, read2, kI2cTransactionTimeout),
57 OkStatus());
58 EXPECT_TRUE(pw::containers::Equal(read2, kExpectRead2));
59
60 EXPECT_EQ(mocked_i2c.Finalize(), OkStatus());
61 }
62
TEST(Transaction,Write)63 TEST(Transaction, Write) {
64 static constexpr Address kAddress1 = Address::SevenBit<0x01>();
65 constexpr auto kExpectWrite1 = bytes::Array<1, 2, 3, 4, 5>();
66
67 static constexpr Address kAddress2 = Address::SevenBit<0x02>();
68 constexpr auto kExpectWrite2 = bytes::Array<3, 4, 5>();
69
70 auto expected_transactions = MakeExpectedTransactionArray(
71 {WriteTransaction(
72 OkStatus(), kAddress1, kExpectWrite1, kI2cTransactionTimeout),
73 WriteTransaction(
74 OkStatus(), kAddress2, kExpectWrite2, kI2cTransactionTimeout)});
75
76 MockInitiator mocked_i2c(expected_transactions);
77
78 EXPECT_EQ(
79 mocked_i2c.WriteFor(kAddress1, kExpectWrite1, kI2cTransactionTimeout),
80 OkStatus());
81
82 EXPECT_EQ(
83 mocked_i2c.WriteFor(kAddress2, kExpectWrite2, kI2cTransactionTimeout),
84 OkStatus());
85
86 EXPECT_EQ(mocked_i2c.Finalize(), OkStatus());
87 }
88
TEST(Transaction,WriteRead)89 TEST(Transaction, WriteRead) {
90 static constexpr Address kAddress1 = Address::SevenBit<0x01>();
91 constexpr auto kExpectWrite1 = bytes::Array<1, 2, 3, 4, 5>();
92 constexpr auto kExpectRead1 = bytes::Array<1, 2>();
93
94 static constexpr Address kAddress2 = Address::SevenBit<0x02>();
95 constexpr auto kExpectWrite2 = bytes::Array<3, 4, 5>();
96 constexpr const auto kExpectRead2 = bytes::Array<3, 4>();
97
98 auto expected_transactions = MakeExpectedTransactionArray({
99 Transaction(OkStatus(),
100 kAddress1,
101 kExpectWrite1,
102 kExpectRead1,
103 kI2cTransactionTimeout),
104 Transaction(OkStatus(),
105 kAddress2,
106 kExpectWrite2,
107 kExpectRead2,
108 kI2cTransactionTimeout),
109 });
110
111 MockInitiator mocked_i2c(expected_transactions);
112
113 std::array<std::byte, kExpectRead1.size()> read1;
114 EXPECT_EQ(mocked_i2c.WriteReadFor(
115 kAddress1, kExpectWrite1, read1, kI2cTransactionTimeout),
116 OkStatus());
117 EXPECT_TRUE(pw::containers::Equal(read1, kExpectRead1));
118
119 std::array<std::byte, kExpectRead1.size()> read2;
120 EXPECT_EQ(mocked_i2c.WriteReadFor(
121 kAddress2, kExpectWrite2, read2, kI2cTransactionTimeout),
122 OkStatus());
123 EXPECT_TRUE(pw::containers::Equal(read2, kExpectRead2));
124
125 EXPECT_EQ(mocked_i2c.Finalize(), OkStatus());
126 }
127
TEST(Transaction,Probe)128 TEST(Transaction, Probe) {
129 static constexpr Address kAddress1 = Address::SevenBit<0x01>();
130
131 auto expected_transactions = MakeExpectedTransactionArray({
132 ProbeTransaction(OkStatus(), kAddress1, kI2cTransactionTimeout),
133 });
134
135 MockInitiator mock_initiator(expected_transactions);
136
137 EXPECT_EQ(mock_initiator.ProbeDeviceFor(kAddress1, kI2cTransactionTimeout),
138 OkStatus());
139 EXPECT_EQ(mock_initiator.Finalize(), OkStatus());
140 }
141
142 } // namespace
143 } // namespace pw::i2c
144