Gitiles
Code Review Sign In
realtimeroboticsgroup.org / RealtimeRoboticsGroup / test / f97244416c78a4cd37eb8e86e0d3e5c0386e0922 / . / motors / peripheral / uart_buffer_test.cc
blob: 5ab7c988c7efa1c952a40d08e3bef0df60b7533f [file] [log] [blame]
Brian Silverman55c62022018-09-03 19:13:44 -0700[diff] [blame]1#include "motors/peripheral/uart_buffer.h"
2
3#include "gtest/gtest.h"
4
5namespace frc971 {
6namespace teensy {
7namespace testing {
8
9// Tests that using PushSpan with single characters works correctly.
10TEST(UartBufferTest, PushSpanSingle) {
11 UartBuffer<1024> buffer;
12 ASSERT_TRUE(buffer.empty());
13
14 {
15 ::std::array<char, 1> data{{1}};
16 ASSERT_EQ(1, buffer.PushSpan(data));
17 }
18 ASSERT_FALSE(buffer.empty());
19 ASSERT_EQ(1, buffer.PopSingle());
20 ASSERT_TRUE(buffer.empty());
21
22 {
23 ::std::array<char, 1> data{{2}};
24 ASSERT_EQ(1, buffer.PushSpan(data));
25 }
26 ASSERT_FALSE(buffer.empty());
27 ASSERT_EQ(2, buffer.PopSingle());
28 ASSERT_TRUE(buffer.empty());
29}
30
31// Tests that using PushSpan with multiple characters works correctly.
32TEST(UartBufferTest, PushSpanMultiple) {
33 UartBuffer<1024> buffer;
34 ASSERT_TRUE(buffer.empty());
35
36 {
37 ::std::array<char, 4> data{{1, 2, 4, 8}};
38 ASSERT_EQ(4, buffer.PushSpan(data));
39 }
40 ASSERT_FALSE(buffer.empty());
41 ASSERT_EQ(1, buffer.PopSingle());
42 ASSERT_FALSE(buffer.empty());
43 ASSERT_EQ(2, buffer.PopSingle());
44 ASSERT_FALSE(buffer.empty());
45 ASSERT_EQ(4, buffer.PopSingle());
46 ASSERT_FALSE(buffer.empty());
47 ASSERT_EQ(8, buffer.PopSingle());
48 ASSERT_TRUE(buffer.empty());
49}
50
51// Tests that using PushSpan works correctly when wrapping with a
52// multiple-character push.
53TEST(UartBufferTest, PushSpanWrapMultiple) {
54 UartBuffer<4> buffer;
55 ASSERT_TRUE(buffer.empty());
56
57 {
58 ::std::array<char, 2> data{{10, 20}};
59 ASSERT_EQ(2, buffer.PushSpan(data));
60 }
61 ASSERT_FALSE(buffer.empty());
62 ASSERT_EQ(10, buffer.PopSingle());
63 ASSERT_FALSE(buffer.empty());
64 ASSERT_EQ(20, buffer.PopSingle());
65 ASSERT_TRUE(buffer.empty());
66
67 {
68 ::std::array<char, 4> data{{1, 2, 4, 8}};
69 ASSERT_EQ(4, buffer.PushSpan(data));
70 }
71 ASSERT_FALSE(buffer.empty());
72 ASSERT_EQ(1, buffer.PopSingle());
73 ASSERT_FALSE(buffer.empty());
74 ASSERT_EQ(2, buffer.PopSingle());
75 ASSERT_FALSE(buffer.empty());
76 ASSERT_EQ(4, buffer.PopSingle());
77 ASSERT_FALSE(buffer.empty());
78 ASSERT_EQ(8, buffer.PopSingle());
79 ASSERT_TRUE(buffer.empty());
80}
81
82// Tests that using PushSpan works correctly when wrapping with a
83// single-character push.
84TEST(UartBufferTest, PushSpanWrapSingle) {
85 UartBuffer<3> buffer;
86 ASSERT_TRUE(buffer.empty());
87
88 {
89 ::std::array<char, 3> data{{10, 20, 30}};
90 ASSERT_EQ(3, buffer.PushSpan(data));
91 }
92 ASSERT_FALSE(buffer.empty());
93 ASSERT_EQ(10, buffer.PopSingle());
94 ASSERT_FALSE(buffer.empty());
95
96 {
97 ::std::array<char, 1> data{{1}};
98 ASSERT_EQ(1, buffer.PushSpan(data));
99 }
100
101 ASSERT_EQ(20, buffer.PopSingle());
102 ASSERT_FALSE(buffer.empty());
103 ASSERT_EQ(30, buffer.PopSingle());
104 ASSERT_FALSE(buffer.empty());
105 ASSERT_EQ(1, buffer.PopSingle());
106 ASSERT_TRUE(buffer.empty());
107}
108
109// Tests that using PushSpan works correctly when overflowing with a
110// multiple-character push, where none of it fits.
111TEST(UartBufferTest, PushSpanOverflowAllMultiple) {
112 UartBuffer<2> buffer;
113 ASSERT_TRUE(buffer.empty());
114
115 {
116 ::std::array<char, 2> data{{10, 20}};
117 ASSERT_EQ(2, buffer.PushSpan(data));
118 }
119
120 {
121 ::std::array<char, 4> data{{1, 2, 4, 8}};
122 ASSERT_EQ(0, buffer.PushSpan(data));
123 }
124
125 ASSERT_FALSE(buffer.empty());
126 ASSERT_EQ(10, buffer.PopSingle());
127 ASSERT_FALSE(buffer.empty());
128 ASSERT_EQ(20, buffer.PopSingle());
129 ASSERT_TRUE(buffer.empty());
130}
131
132// Tests that using PushSpan works correctly when overflowing with a
133// multiple-character push, where some of it fits.
134TEST(UartBufferTest, PushSpanOverflowSomeMultiple) {
135 UartBuffer<4> buffer;
136 ASSERT_TRUE(buffer.empty());
137
138 {
139 ::std::array<char, 2> data{{10, 20}};
140 ASSERT_EQ(2, buffer.PushSpan(data));
141 }
142 ASSERT_FALSE(buffer.empty());
143
144 {
145 ::std::array<char, 4> data{{1, 2, 4, 8}};
146 ASSERT_EQ(2, buffer.PushSpan(data));
147 }
148
149 ASSERT_EQ(10, buffer.PopSingle());
150 ASSERT_FALSE(buffer.empty());
151 ASSERT_EQ(20, buffer.PopSingle());
152 ASSERT_FALSE(buffer.empty());
153 ASSERT_EQ(1, buffer.PopSingle());
154 ASSERT_FALSE(buffer.empty());
155 ASSERT_EQ(2, buffer.PopSingle());
156 ASSERT_TRUE(buffer.empty());
157}
158
159// Tests that using PushSpan works correctly when overflowing with a
160// single-character push.
161TEST(UartBufferTest, PushSpanOverflowSingle) {
162 UartBuffer<3> buffer;
163 ASSERT_TRUE(buffer.empty());
164
165 {
166 ::std::array<char, 3> data{{10, 20, 30}};
167 ASSERT_EQ(3, buffer.PushSpan(data));
168 }
169 ASSERT_FALSE(buffer.empty());
170
171 {
172 ::std::array<char, 1> data{{1}};
173 ASSERT_EQ(0, buffer.PushSpan(data));
174 }
175
176 ASSERT_EQ(10, buffer.PopSingle());
177 ASSERT_FALSE(buffer.empty());
178 ASSERT_EQ(20, buffer.PopSingle());
179 ASSERT_FALSE(buffer.empty());
180 ASSERT_EQ(30, buffer.PopSingle());
181 ASSERT_TRUE(buffer.empty());
182}
183
184} // namespace testing
185} // namespace teensy
186} // namespace frc971