diff options
author | Joel Challis <git@zvecr.com> | 2021-10-07 02:32:05 +0100 |
---|---|---|
committer | GitHub <noreply@github.com> | 2021-10-07 12:32:05 +1100 |
commit | 1c0347b8b85de03691c7810f98f38bb245783985 (patch) | |
tree | abd0d58a1e2d5134f1c307ad392c8616cab3266a /quantum/serial_link/tests | |
parent | 60297a1099e5a310bd10a4d59fcb80bbc7fe4be5 (diff) | |
download | qmk_firmware-1c0347b8b85de03691c7810f98f38bb245783985.tar.gz qmk_firmware-1c0347b8b85de03691c7810f98f38bb245783985.zip |
Remove SERIAL_LINK feature (#14727)
* Remove SERIAL_LINK
* more stale paths in doxygen-todo
* Fix
* More refs
* Update testing docs
* Update doxygen-todo
Co-authored-by: Ryan <fauxpark@gmail.com>
Co-authored-by: Ryan <fauxpark@gmail.com>
Diffstat (limited to 'quantum/serial_link/tests')
-rw-r--r-- | quantum/serial_link/tests/Makefile | 61 | ||||
-rw-r--r-- | quantum/serial_link/tests/byte_stuffer_tests.cpp | 450 | ||||
-rw-r--r-- | quantum/serial_link/tests/frame_router_tests.cpp | 204 | ||||
-rw-r--r-- | quantum/serial_link/tests/frame_validator_tests.cpp | 100 | ||||
-rw-r--r-- | quantum/serial_link/tests/rules.mk | 22 | ||||
-rw-r--r-- | quantum/serial_link/tests/testlist.mk | 6 | ||||
-rw-r--r-- | quantum/serial_link/tests/transport_tests.cpp | 184 | ||||
-rw-r--r-- | quantum/serial_link/tests/triple_buffered_object_tests.cpp | 80 |
8 files changed, 0 insertions, 1107 deletions
diff --git a/quantum/serial_link/tests/Makefile b/quantum/serial_link/tests/Makefile deleted file mode 100644 index 11dd355b2..000000000 --- a/quantum/serial_link/tests/Makefile +++ /dev/null | |||
@@ -1,61 +0,0 @@ | |||
1 | # The MIT License (MIT) | ||
2 | # | ||
3 | # Copyright (c) 2016 Fred Sundvik | ||
4 | # | ||
5 | # Permission is hereby granted, free of charge, to any person obtaining a copy | ||
6 | # of this software and associated documentation files (the "Software"), to deal | ||
7 | # in the Software without restriction, including without limitation the rights | ||
8 | # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
9 | # copies of the Software, and to permit persons to whom the Software is | ||
10 | # furnished to do so, subject to the following conditions: | ||
11 | # | ||
12 | # The above copyright notice and this permission notice shall be included in all | ||
13 | # copies or substantial portions of the Software. | ||
14 | # | ||
15 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
16 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
17 | # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
18 | # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
19 | # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
20 | # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
21 | # SOFTWARE. | ||
22 | |||
23 | CC = gcc | ||
24 | CFLAGS = | ||
25 | INCLUDES = -I. -I../../ | ||
26 | LDFLAGS = -L$(BUILDDIR)/cgreen/build-c/src -shared | ||
27 | LDLIBS = -lcgreen | ||
28 | UNITOBJ = $(BUILDDIR)/serialtest/unitobj | ||
29 | DEPDIR = $(BUILDDIR)/serialtest/unit.d | ||
30 | UNITTESTS = $(BUILDDIR)/serialtest/unittests | ||
31 | DEPFLAGS = -MT $@ -MMD -MP -MF $(DEPDIR)/$*.Td | ||
32 | EXT = .so | ||
33 | UNAME := $(shell uname) | ||
34 | ifneq (, $(findstring MINGW, $(UNAME))) | ||
35 | EXT = .dll | ||
36 | endif | ||
37 | ifneq (, $(findstring CYGWIN, $(UNAME))) | ||
38 | EXT = .dll | ||
39 | endif | ||
40 | |||
41 | SRC = $(wildcard *.c) | ||
42 | TESTFILES = $(patsubst %.c, $(UNITTESTS)/%$(EXT), $(SRC)) | ||
43 | $(shell mkdir -p $(DEPDIR) >/dev/null) | ||
44 | |||
45 | test: $(TESTFILES) | ||
46 | @$(BUILDDIR)/cgreen/build-c/tools/cgreen-runner --color $(TESTFILES) | ||
47 | |||
48 | $(UNITTESTS)/%$(EXT): $(UNITOBJ)/%.o | ||
49 | @mkdir -p $(UNITTESTS) | ||
50 | $(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) | ||
51 | |||
52 | $(UNITOBJ)/%.o : %.c | ||
53 | $(UNITOBJ)/%.o: %.c $(DEPDIR)/%.d | ||
54 | @mkdir -p $(UNITOBJ) | ||
55 | $(CC) $(CFLAGS) $(DEPFLAGS) $(INCLUDES) -c $< -o $@ | ||
56 | @mv -f $(DEPDIR)/$*.Td $(DEPDIR)/$*.d | ||
57 | |||
58 | $(DEPDIR)/%.d: ; | ||
59 | .PRECIOUS: $(DEPDIR)/%.d | ||
60 | |||
61 | -include $(patsubst %,$(DEPDIR)/%.d,$(basename $(SRC))) | ||
diff --git a/quantum/serial_link/tests/byte_stuffer_tests.cpp b/quantum/serial_link/tests/byte_stuffer_tests.cpp deleted file mode 100644 index 9e4e1768f..000000000 --- a/quantum/serial_link/tests/byte_stuffer_tests.cpp +++ /dev/null | |||
@@ -1,450 +0,0 @@ | |||
1 | /* | ||
2 | The MIT License (MIT) | ||
3 | |||
4 | Copyright (c) 2016 Fred Sundvik | ||
5 | |||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | ||
7 | of this software and associated documentation files (the "Software"), to deal | ||
8 | in the Software without restriction, including without limitation the rights | ||
9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
10 | copies of the Software, and to permit persons to whom the Software is | ||
11 | furnished to do so, subject to the following conditions: | ||
12 | |||
13 | The above copyright notice and this permission notice shall be included in all | ||
14 | copies or substantial portions of the Software. | ||
15 | |||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
22 | SOFTWARE. | ||
23 | */ | ||
24 | |||
25 | #include "gtest/gtest.h" | ||
26 | #include "gmock/gmock.h" | ||
27 | #include <vector> | ||
28 | #include <algorithm> | ||
29 | extern "C" { | ||
30 | #include "serial_link/protocol/byte_stuffer.h" | ||
31 | #include "serial_link/protocol/frame_validator.h" | ||
32 | #include "serial_link/protocol/physical.h" | ||
33 | } | ||
34 | |||
35 | using testing::_; | ||
36 | using testing::Args; | ||
37 | using testing::ElementsAreArray; | ||
38 | |||
39 | class ByteStuffer : public ::testing::Test { | ||
40 | public: | ||
41 | ByteStuffer() { | ||
42 | Instance = this; | ||
43 | init_byte_stuffer(); | ||
44 | } | ||
45 | |||
46 | ~ByteStuffer() { Instance = nullptr; } | ||
47 | |||
48 | MOCK_METHOD3(validator_recv_frame, void(uint8_t link, uint8_t* data, uint16_t size)); | ||
49 | |||
50 | void send_data(uint8_t link, const uint8_t* data, uint16_t size) { std::copy(data, data + size, std::back_inserter(sent_data)); } | ||
51 | std::vector<uint8_t> sent_data; | ||
52 | |||
53 | static ByteStuffer* Instance; | ||
54 | }; | ||
55 | |||
56 | ByteStuffer* ByteStuffer::Instance = nullptr; | ||
57 | |||
58 | extern "C" { | ||
59 | void validator_recv_frame(uint8_t link, uint8_t* data, uint16_t size) { ByteStuffer::Instance->validator_recv_frame(link, data, size); } | ||
60 | |||
61 | void send_data(uint8_t link, const uint8_t* data, uint16_t size) { ByteStuffer::Instance->send_data(link, data, size); } | ||
62 | } | ||
63 | |||
64 | TEST_F(ByteStuffer, receives_no_frame_for_a_single_zero_byte) { | ||
65 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).Times(0); | ||
66 | byte_stuffer_recv_byte(0, 0); | ||
67 | } | ||
68 | |||
69 | TEST_F(ByteStuffer, receives_no_frame_for_a_single_FF_byte) { | ||
70 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).Times(0); | ||
71 | byte_stuffer_recv_byte(0, 0xFF); | ||
72 | } | ||
73 | |||
74 | TEST_F(ByteStuffer, receives_no_frame_for_a_single_random_byte) { | ||
75 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).Times(0); | ||
76 | byte_stuffer_recv_byte(0, 0x4A); | ||
77 | } | ||
78 | |||
79 | TEST_F(ByteStuffer, receives_no_frame_for_a_zero_length_frame) { | ||
80 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).Times(0); | ||
81 | byte_stuffer_recv_byte(0, 1); | ||
82 | byte_stuffer_recv_byte(0, 0); | ||
83 | } | ||
84 | |||
85 | TEST_F(ByteStuffer, receives_single_byte_valid_frame) { | ||
86 | uint8_t expected[] = {0x37}; | ||
87 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
88 | byte_stuffer_recv_byte(0, 2); | ||
89 | byte_stuffer_recv_byte(0, 0x37); | ||
90 | byte_stuffer_recv_byte(0, 0); | ||
91 | } | ||
92 | TEST_F(ByteStuffer, receives_three_bytes_valid_frame) { | ||
93 | uint8_t expected[] = {0x37, 0x99, 0xFF}; | ||
94 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
95 | byte_stuffer_recv_byte(0, 4); | ||
96 | byte_stuffer_recv_byte(0, 0x37); | ||
97 | byte_stuffer_recv_byte(0, 0x99); | ||
98 | byte_stuffer_recv_byte(0, 0xFF); | ||
99 | byte_stuffer_recv_byte(0, 0); | ||
100 | } | ||
101 | |||
102 | TEST_F(ByteStuffer, receives_single_zero_valid_frame) { | ||
103 | uint8_t expected[] = {0}; | ||
104 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
105 | byte_stuffer_recv_byte(0, 1); | ||
106 | byte_stuffer_recv_byte(0, 1); | ||
107 | byte_stuffer_recv_byte(0, 0); | ||
108 | } | ||
109 | |||
110 | TEST_F(ByteStuffer, receives_valid_frame_with_zeroes) { | ||
111 | uint8_t expected[] = {5, 0, 3, 0}; | ||
112 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
113 | byte_stuffer_recv_byte(0, 2); | ||
114 | byte_stuffer_recv_byte(0, 5); | ||
115 | byte_stuffer_recv_byte(0, 2); | ||
116 | byte_stuffer_recv_byte(0, 3); | ||
117 | byte_stuffer_recv_byte(0, 1); | ||
118 | byte_stuffer_recv_byte(0, 0); | ||
119 | } | ||
120 | |||
121 | TEST_F(ByteStuffer, receives_two_valid_frames) { | ||
122 | uint8_t expected1[] = {5, 0}; | ||
123 | uint8_t expected2[] = {3}; | ||
124 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected1))); | ||
125 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected2))); | ||
126 | byte_stuffer_recv_byte(1, 2); | ||
127 | byte_stuffer_recv_byte(1, 5); | ||
128 | byte_stuffer_recv_byte(1, 1); | ||
129 | byte_stuffer_recv_byte(1, 0); | ||
130 | byte_stuffer_recv_byte(1, 2); | ||
131 | byte_stuffer_recv_byte(1, 3); | ||
132 | byte_stuffer_recv_byte(1, 0); | ||
133 | } | ||
134 | |||
135 | TEST_F(ByteStuffer, receives_valid_frame_after_unexpected_zero) { | ||
136 | uint8_t expected[] = {5, 7}; | ||
137 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
138 | byte_stuffer_recv_byte(1, 3); | ||
139 | byte_stuffer_recv_byte(1, 1); | ||
140 | byte_stuffer_recv_byte(1, 0); | ||
141 | byte_stuffer_recv_byte(1, 3); | ||
142 | byte_stuffer_recv_byte(1, 5); | ||
143 | byte_stuffer_recv_byte(1, 7); | ||
144 | byte_stuffer_recv_byte(1, 0); | ||
145 | } | ||
146 | |||
147 | TEST_F(ByteStuffer, receives_valid_frame_after_unexpected_non_zero) { | ||
148 | uint8_t expected[] = {5, 7}; | ||
149 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
150 | byte_stuffer_recv_byte(0, 2); | ||
151 | byte_stuffer_recv_byte(0, 9); | ||
152 | byte_stuffer_recv_byte(0, 4); // This should have been zero | ||
153 | byte_stuffer_recv_byte(0, 0); | ||
154 | byte_stuffer_recv_byte(0, 3); | ||
155 | byte_stuffer_recv_byte(0, 5); | ||
156 | byte_stuffer_recv_byte(0, 7); | ||
157 | byte_stuffer_recv_byte(0, 0); | ||
158 | } | ||
159 | |||
160 | TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_and_then_end_of_frame) { | ||
161 | uint8_t expected[254]; | ||
162 | int i; | ||
163 | for (i = 0; i < 254; i++) { | ||
164 | expected[i] = i + 1; | ||
165 | } | ||
166 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
167 | byte_stuffer_recv_byte(0, 0xFF); | ||
168 | for (i = 0; i < 254; i++) { | ||
169 | byte_stuffer_recv_byte(0, i + 1); | ||
170 | } | ||
171 | byte_stuffer_recv_byte(0, 0); | ||
172 | } | ||
173 | |||
174 | TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_next_byte_is_non_zero) { | ||
175 | uint8_t expected[255]; | ||
176 | int i; | ||
177 | for (i = 0; i < 254; i++) { | ||
178 | expected[i] = i + 1; | ||
179 | } | ||
180 | expected[254] = 7; | ||
181 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
182 | byte_stuffer_recv_byte(0, 0xFF); | ||
183 | for (i = 0; i < 254; i++) { | ||
184 | byte_stuffer_recv_byte(0, i + 1); | ||
185 | } | ||
186 | byte_stuffer_recv_byte(0, 2); | ||
187 | byte_stuffer_recv_byte(0, 7); | ||
188 | byte_stuffer_recv_byte(0, 0); | ||
189 | } | ||
190 | |||
191 | TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_next_byte_is_zero) { | ||
192 | uint8_t expected[255]; | ||
193 | int i; | ||
194 | for (i = 0; i < 254; i++) { | ||
195 | expected[i] = i + 1; | ||
196 | } | ||
197 | expected[254] = 0; | ||
198 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
199 | byte_stuffer_recv_byte(0, 0xFF); | ||
200 | for (i = 0; i < 254; i++) { | ||
201 | byte_stuffer_recv_byte(0, i + 1); | ||
202 | } | ||
203 | byte_stuffer_recv_byte(0, 1); | ||
204 | byte_stuffer_recv_byte(0, 1); | ||
205 | byte_stuffer_recv_byte(0, 0); | ||
206 | } | ||
207 | |||
208 | TEST_F(ByteStuffer, receives_two_long_frames_and_some_more) { | ||
209 | uint8_t expected[515]; | ||
210 | int i; | ||
211 | int j; | ||
212 | for (j = 0; j < 2; j++) { | ||
213 | for (i = 0; i < 254; i++) { | ||
214 | expected[i + 254 * j] = i + 1; | ||
215 | } | ||
216 | } | ||
217 | for (i = 0; i < 7; i++) { | ||
218 | expected[254 * 2 + i] = i + 1; | ||
219 | } | ||
220 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
221 | byte_stuffer_recv_byte(0, 0xFF); | ||
222 | for (i = 0; i < 254; i++) { | ||
223 | byte_stuffer_recv_byte(0, i + 1); | ||
224 | } | ||
225 | byte_stuffer_recv_byte(0, 0xFF); | ||
226 | for (i = 0; i < 254; i++) { | ||
227 | byte_stuffer_recv_byte(0, i + 1); | ||
228 | } | ||
229 | byte_stuffer_recv_byte(0, 8); | ||
230 | byte_stuffer_recv_byte(0, 1); | ||
231 | byte_stuffer_recv_byte(0, 2); | ||
232 | byte_stuffer_recv_byte(0, 3); | ||
233 | byte_stuffer_recv_byte(0, 4); | ||
234 | byte_stuffer_recv_byte(0, 5); | ||
235 | byte_stuffer_recv_byte(0, 6); | ||
236 | byte_stuffer_recv_byte(0, 7); | ||
237 | byte_stuffer_recv_byte(0, 0); | ||
238 | } | ||
239 | |||
240 | TEST_F(ByteStuffer, receives_an_all_zeros_frame_that_is_maximum_size) { | ||
241 | uint8_t expected[MAX_FRAME_SIZE] = {}; | ||
242 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
243 | int i; | ||
244 | byte_stuffer_recv_byte(0, 1); | ||
245 | for (i = 0; i < MAX_FRAME_SIZE; i++) { | ||
246 | byte_stuffer_recv_byte(0, 1); | ||
247 | } | ||
248 | byte_stuffer_recv_byte(0, 0); | ||
249 | } | ||
250 | |||
251 | TEST_F(ByteStuffer, doesnt_recv_a_frame_thats_too_long_all_zeroes) { | ||
252 | uint8_t expected[1] = {0}; | ||
253 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).Times(0); | ||
254 | int i; | ||
255 | byte_stuffer_recv_byte(0, 1); | ||
256 | for (i = 0; i < MAX_FRAME_SIZE; i++) { | ||
257 | byte_stuffer_recv_byte(0, 1); | ||
258 | } | ||
259 | byte_stuffer_recv_byte(0, 1); | ||
260 | byte_stuffer_recv_byte(0, 0); | ||
261 | } | ||
262 | |||
263 | TEST_F(ByteStuffer, received_frame_is_aborted_when_its_too_long) { | ||
264 | uint8_t expected[1] = {1}; | ||
265 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
266 | int i; | ||
267 | byte_stuffer_recv_byte(0, 1); | ||
268 | for (i = 0; i < MAX_FRAME_SIZE; i++) { | ||
269 | byte_stuffer_recv_byte(0, 1); | ||
270 | } | ||
271 | byte_stuffer_recv_byte(0, 2); | ||
272 | byte_stuffer_recv_byte(0, 1); | ||
273 | byte_stuffer_recv_byte(0, 0); | ||
274 | } | ||
275 | |||
276 | TEST_F(ByteStuffer, does_nothing_when_sending_zero_size_frame) { | ||
277 | EXPECT_EQ(sent_data.size(), 0); | ||
278 | byte_stuffer_send_frame(0, NULL, 0); | ||
279 | } | ||
280 | |||
281 | TEST_F(ByteStuffer, send_one_byte_frame) { | ||
282 | uint8_t data[] = {5}; | ||
283 | byte_stuffer_send_frame(1, data, 1); | ||
284 | uint8_t expected[] = {2, 5, 0}; | ||
285 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
286 | } | ||
287 | |||
288 | TEST_F(ByteStuffer, sends_two_byte_frame) { | ||
289 | uint8_t data[] = {5, 0x77}; | ||
290 | byte_stuffer_send_frame(0, data, 2); | ||
291 | uint8_t expected[] = {3, 5, 0x77, 0}; | ||
292 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
293 | } | ||
294 | |||
295 | TEST_F(ByteStuffer, sends_one_byte_frame_with_zero) { | ||
296 | uint8_t data[] = {0}; | ||
297 | byte_stuffer_send_frame(0, data, 1); | ||
298 | uint8_t expected[] = {1, 1, 0}; | ||
299 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
300 | } | ||
301 | |||
302 | TEST_F(ByteStuffer, sends_two_byte_frame_starting_with_zero) { | ||
303 | uint8_t data[] = {0, 9}; | ||
304 | byte_stuffer_send_frame(1, data, 2); | ||
305 | uint8_t expected[] = {1, 2, 9, 0}; | ||
306 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
307 | } | ||
308 | |||
309 | TEST_F(ByteStuffer, sends_two_byte_frame_starting_with_non_zero) { | ||
310 | uint8_t data[] = {9, 0}; | ||
311 | byte_stuffer_send_frame(1, data, 2); | ||
312 | uint8_t expected[] = {2, 9, 1, 0}; | ||
313 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
314 | } | ||
315 | |||
316 | TEST_F(ByteStuffer, sends_three_byte_frame_zero_in_the_middle) { | ||
317 | uint8_t data[] = {9, 0, 0x68}; | ||
318 | byte_stuffer_send_frame(0, data, 3); | ||
319 | uint8_t expected[] = {2, 9, 2, 0x68, 0}; | ||
320 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
321 | } | ||
322 | |||
323 | TEST_F(ByteStuffer, sends_three_byte_frame_data_in_the_middle) { | ||
324 | uint8_t data[] = {0, 0x55, 0}; | ||
325 | byte_stuffer_send_frame(0, data, 3); | ||
326 | uint8_t expected[] = {1, 2, 0x55, 1, 0}; | ||
327 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
328 | } | ||
329 | |||
330 | TEST_F(ByteStuffer, sends_three_byte_frame_with_all_zeroes) { | ||
331 | uint8_t data[] = {0, 0, 0}; | ||
332 | byte_stuffer_send_frame(0, data, 3); | ||
333 | uint8_t expected[] = {1, 1, 1, 1, 0}; | ||
334 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
335 | } | ||
336 | |||
337 | TEST_F(ByteStuffer, sends_frame_with_254_non_zeroes) { | ||
338 | uint8_t data[254]; | ||
339 | int i; | ||
340 | for (i = 0; i < 254; i++) { | ||
341 | data[i] = i + 1; | ||
342 | } | ||
343 | byte_stuffer_send_frame(0, data, 254); | ||
344 | uint8_t expected[256]; | ||
345 | expected[0] = 0xFF; | ||
346 | for (i = 1; i < 255; i++) { | ||
347 | expected[i] = i; | ||
348 | } | ||
349 | expected[255] = 0; | ||
350 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
351 | } | ||
352 | |||
353 | TEST_F(ByteStuffer, sends_frame_with_255_non_zeroes) { | ||
354 | uint8_t data[255]; | ||
355 | int i; | ||
356 | for (i = 0; i < 255; i++) { | ||
357 | data[i] = i + 1; | ||
358 | } | ||
359 | byte_stuffer_send_frame(0, data, 255); | ||
360 | uint8_t expected[258]; | ||
361 | expected[0] = 0xFF; | ||
362 | for (i = 1; i < 255; i++) { | ||
363 | expected[i] = i; | ||
364 | } | ||
365 | expected[255] = 2; | ||
366 | expected[256] = 255; | ||
367 | expected[257] = 0; | ||
368 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
369 | } | ||
370 | |||
371 | TEST_F(ByteStuffer, sends_frame_with_254_non_zeroes_followed_by_zero) { | ||
372 | uint8_t data[255]; | ||
373 | int i; | ||
374 | for (i = 0; i < 254; i++) { | ||
375 | data[i] = i + 1; | ||
376 | } | ||
377 | data[254] = 0; | ||
378 | byte_stuffer_send_frame(0, data, 255); | ||
379 | uint8_t expected[258]; | ||
380 | expected[0] = 0xFF; | ||
381 | for (i = 1; i < 255; i++) { | ||
382 | expected[i] = i; | ||
383 | } | ||
384 | expected[255] = 1; | ||
385 | expected[256] = 1; | ||
386 | expected[257] = 0; | ||
387 | EXPECT_THAT(sent_data, ElementsAreArray(expected)); | ||
388 | } | ||
389 | |||
390 | TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_small_packet) { | ||
391 | uint8_t original_data[] = {1, 2, 3}; | ||
392 | byte_stuffer_send_frame(0, original_data, sizeof(original_data)); | ||
393 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(original_data))); | ||
394 | int i; | ||
395 | for (auto& d : sent_data) { | ||
396 | byte_stuffer_recv_byte(1, d); | ||
397 | } | ||
398 | } | ||
399 | |||
400 | TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_small_packet_with_zeros) { | ||
401 | uint8_t original_data[] = {1, 0, 3, 0, 0, 9}; | ||
402 | byte_stuffer_send_frame(1, original_data, sizeof(original_data)); | ||
403 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(original_data))); | ||
404 | int i; | ||
405 | for (auto& d : sent_data) { | ||
406 | byte_stuffer_recv_byte(1, d); | ||
407 | } | ||
408 | } | ||
409 | |||
410 | TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_254_bytes) { | ||
411 | uint8_t original_data[254]; | ||
412 | int i; | ||
413 | for (i = 0; i < 254; i++) { | ||
414 | original_data[i] = i + 1; | ||
415 | } | ||
416 | byte_stuffer_send_frame(0, original_data, sizeof(original_data)); | ||
417 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(original_data))); | ||
418 | for (auto& d : sent_data) { | ||
419 | byte_stuffer_recv_byte(1, d); | ||
420 | } | ||
421 | } | ||
422 | |||
423 | TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_256_bytes) { | ||
424 | uint8_t original_data[256]; | ||
425 | int i; | ||
426 | for (i = 0; i < 254; i++) { | ||
427 | original_data[i] = i + 1; | ||
428 | } | ||
429 | original_data[254] = 22; | ||
430 | original_data[255] = 23; | ||
431 | byte_stuffer_send_frame(0, original_data, sizeof(original_data)); | ||
432 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(original_data))); | ||
433 | for (auto& d : sent_data) { | ||
434 | byte_stuffer_recv_byte(1, d); | ||
435 | } | ||
436 | } | ||
437 | |||
438 | TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_254_bytes_and_then_zero) { | ||
439 | uint8_t original_data[255]; | ||
440 | int i; | ||
441 | for (i = 0; i < 254; i++) { | ||
442 | original_data[i] = i + 1; | ||
443 | } | ||
444 | original_data[254] = 0; | ||
445 | byte_stuffer_send_frame(0, original_data, sizeof(original_data)); | ||
446 | EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(original_data))); | ||
447 | for (auto& d : sent_data) { | ||
448 | byte_stuffer_recv_byte(1, d); | ||
449 | } | ||
450 | } | ||
diff --git a/quantum/serial_link/tests/frame_router_tests.cpp b/quantum/serial_link/tests/frame_router_tests.cpp deleted file mode 100644 index f76dfb33d..000000000 --- a/quantum/serial_link/tests/frame_router_tests.cpp +++ /dev/null | |||
@@ -1,204 +0,0 @@ | |||
1 | /* | ||
2 | The MIT License (MIT) | ||
3 | |||
4 | Copyright (c) 2016 Fred Sundvik | ||
5 | |||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | ||
7 | of this software and associated documentation files (the "Software"), to deal | ||
8 | in the Software without restriction, including without limitation the rights | ||
9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
10 | copies of the Software, and to permit persons to whom the Software is | ||
11 | furnished to do so, subject to the following conditions: | ||
12 | |||
13 | The above copyright notice and this permission notice shall be included in all | ||
14 | copies or substantial portions of the Software. | ||
15 | |||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
22 | SOFTWARE. | ||
23 | */ | ||
24 | |||
25 | #include "gtest/gtest.h" | ||
26 | #include "gmock/gmock.h" | ||
27 | #include <array> | ||
28 | extern "C" { | ||
29 | #include "serial_link/protocol/transport.h" | ||
30 | #include "serial_link/protocol/byte_stuffer.h" | ||
31 | #include "serial_link/protocol/frame_router.h" | ||
32 | } | ||
33 | |||
34 | using testing::_; | ||
35 | using testing::Args; | ||
36 | using testing::ElementsAreArray; | ||
37 | |||
38 | class FrameRouter : public testing::Test { | ||
39 | public: | ||
40 | FrameRouter() : current_router_buffer(nullptr) { | ||
41 | Instance = this; | ||
42 | init_byte_stuffer(); | ||
43 | } | ||
44 | |||
45 | ~FrameRouter() { Instance = nullptr; } | ||
46 | |||
47 | void send_data(uint8_t link, const uint8_t* data, uint16_t size) { | ||
48 | auto& buffer = current_router_buffer->send_buffers[link]; | ||
49 | std::copy(data, data + size, std::back_inserter(buffer)); | ||
50 | } | ||
51 | |||
52 | void receive_data(uint8_t link, uint8_t* data, uint16_t size) { | ||
53 | int i; | ||
54 | for (i = 0; i < size; i++) { | ||
55 | byte_stuffer_recv_byte(link, data[i]); | ||
56 | } | ||
57 | } | ||
58 | |||
59 | void activate_router(uint8_t num) { | ||
60 | current_router_buffer = router_buffers + num; | ||
61 | router_set_master(num == 0); | ||
62 | } | ||
63 | |||
64 | void simulate_transport(uint8_t from, uint8_t to) { | ||
65 | activate_router(to); | ||
66 | if (from > to) { | ||
67 | receive_data(DOWN_LINK, router_buffers[from].send_buffers[UP_LINK].data(), router_buffers[from].send_buffers[UP_LINK].size()); | ||
68 | } else if (to > from) { | ||
69 | receive_data(UP_LINK, router_buffers[from].send_buffers[DOWN_LINK].data(), router_buffers[from].send_buffers[DOWN_LINK].size()); | ||
70 | } | ||
71 | } | ||
72 | |||
73 | MOCK_METHOD3(transport_recv_frame, void(uint8_t from, uint8_t* data, uint16_t size)); | ||
74 | |||
75 | std::vector<uint8_t> received_data; | ||
76 | |||
77 | struct router_buffer { | ||
78 | std::vector<uint8_t> send_buffers[2]; | ||
79 | }; | ||
80 | |||
81 | router_buffer router_buffers[8]; | ||
82 | router_buffer* current_router_buffer; | ||
83 | |||
84 | static FrameRouter* Instance; | ||
85 | }; | ||
86 | |||
87 | FrameRouter* FrameRouter::Instance = nullptr; | ||
88 | |||
89 | typedef struct { | ||
90 | std::array<uint8_t, 4> data; | ||
91 | uint8_t extra[16]; | ||
92 | } frame_buffer_t; | ||
93 | |||
94 | extern "C" { | ||
95 | void send_data(uint8_t link, const uint8_t* data, uint16_t size) { FrameRouter::Instance->send_data(link, data, size); } | ||
96 | |||
97 | void transport_recv_frame(uint8_t from, uint8_t* data, uint16_t size) { FrameRouter::Instance->transport_recv_frame(from, data, size); } | ||
98 | } | ||
99 | |||
100 | TEST_F(FrameRouter, master_broadcast_is_received_by_everyone) { | ||
101 | frame_buffer_t data; | ||
102 | data.data = {0xAB, 0x70, 0x55, 0xBB}; | ||
103 | activate_router(0); | ||
104 | router_send_frame(0xFF, (uint8_t*)&data, 4); | ||
105 | EXPECT_GT(router_buffers[0].send_buffers[DOWN_LINK].size(), 0); | ||
106 | EXPECT_EQ(router_buffers[0].send_buffers[UP_LINK].size(), 0); | ||
107 | EXPECT_CALL(*this, transport_recv_frame(0, _, _)).With(Args<1, 2>(ElementsAreArray(data.data))); | ||
108 | simulate_transport(0, 1); | ||
109 | EXPECT_GT(router_buffers[1].send_buffers[DOWN_LINK].size(), 0); | ||
110 | EXPECT_EQ(router_buffers[1].send_buffers[UP_LINK].size(), 0); | ||
111 | |||
112 | EXPECT_CALL(*this, transport_recv_frame(0, _, _)).With(Args<1, 2>(ElementsAreArray(data.data))); | ||
113 | simulate_transport(1, 2); | ||
114 | EXPECT_GT(router_buffers[2].send_buffers[DOWN_LINK].size(), 0); | ||
115 | EXPECT_EQ(router_buffers[2].send_buffers[UP_LINK].size(), 0); | ||
116 | } | ||
117 | |||
118 | TEST_F(FrameRouter, master_send_is_received_by_targets) { | ||
119 | frame_buffer_t data; | ||
120 | data.data = {0xAB, 0x70, 0x55, 0xBB}; | ||
121 | activate_router(0); | ||
122 | router_send_frame((1 << 1) | (1 << 2), (uint8_t*)&data, 4); | ||
123 | EXPECT_GT(router_buffers[0].send_buffers[DOWN_LINK].size(), 0); | ||
124 | EXPECT_EQ(router_buffers[0].send_buffers[UP_LINK].size(), 0); | ||
125 | |||
126 | simulate_transport(0, 1); | ||
127 | EXPECT_GT(router_buffers[1].send_buffers[DOWN_LINK].size(), 0); | ||
128 | EXPECT_EQ(router_buffers[1].send_buffers[UP_LINK].size(), 0); | ||
129 | |||
130 | EXPECT_CALL(*this, transport_recv_frame(0, _, _)).With(Args<1, 2>(ElementsAreArray(data.data))); | ||
131 | simulate_transport(1, 2); | ||
132 | EXPECT_GT(router_buffers[2].send_buffers[DOWN_LINK].size(), 0); | ||
133 | EXPECT_EQ(router_buffers[2].send_buffers[UP_LINK].size(), 0); | ||
134 | |||
135 | EXPECT_CALL(*this, transport_recv_frame(0, _, _)).With(Args<1, 2>(ElementsAreArray(data.data))); | ||
136 | simulate_transport(2, 3); | ||
137 | EXPECT_GT(router_buffers[3].send_buffers[DOWN_LINK].size(), 0); | ||
138 | EXPECT_EQ(router_buffers[3].send_buffers[UP_LINK].size(), 0); | ||
139 | } | ||
140 | |||
141 | TEST_F(FrameRouter, first_link_sends_to_master) { | ||
142 | frame_buffer_t data; | ||
143 | data.data = {0xAB, 0x70, 0x55, 0xBB}; | ||
144 | activate_router(1); | ||
145 | router_send_frame(0, (uint8_t*)&data, 4); | ||
146 | EXPECT_GT(router_buffers[1].send_buffers[UP_LINK].size(), 0); | ||
147 | EXPECT_EQ(router_buffers[1].send_buffers[DOWN_LINK].size(), 0); | ||
148 | |||
149 | EXPECT_CALL(*this, transport_recv_frame(1, _, _)).With(Args<1, 2>(ElementsAreArray(data.data))); | ||
150 | simulate_transport(1, 0); | ||
151 | EXPECT_EQ(router_buffers[0].send_buffers[DOWN_LINK].size(), 0); | ||
152 | EXPECT_EQ(router_buffers[0].send_buffers[UP_LINK].size(), 0); | ||
153 | } | ||
154 | |||
155 | TEST_F(FrameRouter, second_link_sends_to_master) { | ||
156 | frame_buffer_t data; | ||
157 | data.data = {0xAB, 0x70, 0x55, 0xBB}; | ||
158 | activate_router(2); | ||
159 | router_send_frame(0, (uint8_t*)&data, 4); | ||
160 | EXPECT_GT(router_buffers[2].send_buffers[UP_LINK].size(), 0); | ||
161 | EXPECT_EQ(router_buffers[2].send_buffers[DOWN_LINK].size(), 0); | ||
162 | |||
163 | simulate_transport(2, 1); | ||
164 | EXPECT_GT(router_buffers[1].send_buffers[UP_LINK].size(), 0); | ||
165 | EXPECT_EQ(router_buffers[1].send_buffers[DOWN_LINK].size(), 0); | ||
166 | |||
167 | EXPECT_CALL(*this, transport_recv_frame(2, _, _)).With(Args<1, 2>(ElementsAreArray(data.data))); | ||
168 | simulate_transport(1, 0); | ||
169 | EXPECT_EQ(router_buffers[0].send_buffers[DOWN_LINK].size(), 0); | ||
170 | EXPECT_EQ(router_buffers[0].send_buffers[UP_LINK].size(), 0); | ||
171 | } | ||
172 | |||
173 | TEST_F(FrameRouter, master_sends_to_master_does_nothing) { | ||
174 | frame_buffer_t data; | ||
175 | data.data = {0xAB, 0x70, 0x55, 0xBB}; | ||
176 | activate_router(0); | ||
177 | router_send_frame(0, (uint8_t*)&data, 4); | ||
178 | EXPECT_EQ(router_buffers[0].send_buffers[UP_LINK].size(), 0); | ||
179 | EXPECT_EQ(router_buffers[0].send_buffers[DOWN_LINK].size(), 0); | ||
180 | } | ||
181 | |||
182 | TEST_F(FrameRouter, link_sends_to_other_link_does_nothing) { | ||
183 | frame_buffer_t data; | ||
184 | data.data = {0xAB, 0x70, 0x55, 0xBB}; | ||
185 | activate_router(1); | ||
186 | router_send_frame(2, (uint8_t*)&data, 4); | ||
187 | EXPECT_EQ(router_buffers[1].send_buffers[UP_LINK].size(), 0); | ||
188 | EXPECT_EQ(router_buffers[1].send_buffers[DOWN_LINK].size(), 0); | ||
189 | } | ||
190 | |||
191 | TEST_F(FrameRouter, master_receives_on_uplink_does_nothing) { | ||
192 | frame_buffer_t data; | ||
193 | data.data = {0xAB, 0x70, 0x55, 0xBB}; | ||
194 | activate_router(1); | ||
195 | router_send_frame(0, (uint8_t*)&data, 4); | ||
196 | EXPECT_GT(router_buffers[1].send_buffers[UP_LINK].size(), 0); | ||
197 | EXPECT_EQ(router_buffers[1].send_buffers[DOWN_LINK].size(), 0); | ||
198 | |||
199 | EXPECT_CALL(*this, transport_recv_frame(_, _, _)).Times(0); | ||
200 | activate_router(0); | ||
201 | receive_data(UP_LINK, router_buffers[1].send_buffers[UP_LINK].data(), router_buffers[1].send_buffers[UP_LINK].size()); | ||
202 | EXPECT_EQ(router_buffers[0].send_buffers[UP_LINK].size(), 0); | ||
203 | EXPECT_EQ(router_buffers[0].send_buffers[DOWN_LINK].size(), 0); | ||
204 | } | ||
diff --git a/quantum/serial_link/tests/frame_validator_tests.cpp b/quantum/serial_link/tests/frame_validator_tests.cpp deleted file mode 100644 index 43dc57b63..000000000 --- a/quantum/serial_link/tests/frame_validator_tests.cpp +++ /dev/null | |||
@@ -1,100 +0,0 @@ | |||
1 | /* | ||
2 | The MIT License (MIT) | ||
3 | |||
4 | Copyright (c) 2016 Fred Sundvik | ||
5 | |||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | ||
7 | of this software and associated documentation files (the "Software"), to deal | ||
8 | in the Software without restriction, including without limitation the rights | ||
9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
10 | copies of the Software, and to permit persons to whom the Software is | ||
11 | furnished to do so, subject to the following conditions: | ||
12 | |||
13 | The above copyright notice and this permission notice shall be included in all | ||
14 | copies or substantial portions of the Software. | ||
15 | |||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
22 | SOFTWARE. | ||
23 | */ | ||
24 | |||
25 | #include "gtest/gtest.h" | ||
26 | #include "gmock/gmock.h" | ||
27 | extern "C" { | ||
28 | #include "serial_link/protocol/frame_validator.h" | ||
29 | } | ||
30 | |||
31 | using testing::_; | ||
32 | using testing::Args; | ||
33 | using testing::ElementsAreArray; | ||
34 | |||
35 | class FrameValidator : public testing::Test { | ||
36 | public: | ||
37 | FrameValidator() { Instance = this; } | ||
38 | |||
39 | ~FrameValidator() { Instance = nullptr; } | ||
40 | |||
41 | MOCK_METHOD3(route_incoming_frame, void(uint8_t link, uint8_t* data, uint16_t size)); | ||
42 | MOCK_METHOD3(byte_stuffer_send_frame, void(uint8_t link, uint8_t* data, uint16_t size)); | ||
43 | |||
44 | static FrameValidator* Instance; | ||
45 | }; | ||
46 | |||
47 | FrameValidator* FrameValidator::Instance = nullptr; | ||
48 | |||
49 | extern "C" { | ||
50 | void route_incoming_frame(uint8_t link, uint8_t* data, uint16_t size) { FrameValidator::Instance->route_incoming_frame(link, data, size); } | ||
51 | |||
52 | void byte_stuffer_send_frame(uint8_t link, uint8_t* data, uint16_t size) { FrameValidator::Instance->byte_stuffer_send_frame(link, data, size); } | ||
53 | } | ||
54 | |||
55 | TEST_F(FrameValidator, doesnt_validate_frames_under_5_bytes) { | ||
56 | EXPECT_CALL(*this, route_incoming_frame(_, _, _)).Times(0); | ||
57 | uint8_t data[] = {1, 2}; | ||
58 | validator_recv_frame(0, 0, 1); | ||
59 | validator_recv_frame(0, data, 2); | ||
60 | validator_recv_frame(0, data, 3); | ||
61 | validator_recv_frame(0, data, 4); | ||
62 | } | ||
63 | |||
64 | TEST_F(FrameValidator, validates_one_byte_frame_with_correct_crc) { | ||
65 | uint8_t data[] = {0x44, 0x04, 0x6A, 0xB3, 0xA3}; | ||
66 | EXPECT_CALL(*this, route_incoming_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(data, 1))); | ||
67 | validator_recv_frame(0, data, 5); | ||
68 | } | ||
69 | |||
70 | TEST_F(FrameValidator, does_not_validate_one_byte_frame_with_incorrect_crc) { | ||
71 | uint8_t data[] = {0x44, 0, 0, 0, 0}; | ||
72 | EXPECT_CALL(*this, route_incoming_frame(_, _, _)).Times(0); | ||
73 | validator_recv_frame(1, data, 5); | ||
74 | } | ||
75 | |||
76 | TEST_F(FrameValidator, validates_four_byte_frame_with_correct_crc) { | ||
77 | uint8_t data[] = {0x44, 0x10, 0xFF, 0x00, 0x74, 0x4E, 0x30, 0xBA}; | ||
78 | EXPECT_CALL(*this, route_incoming_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(data, 4))); | ||
79 | validator_recv_frame(1, data, 8); | ||
80 | } | ||
81 | |||
82 | TEST_F(FrameValidator, validates_five_byte_frame_with_correct_crc) { | ||
83 | uint8_t data[] = {1, 2, 3, 4, 5, 0xF4, 0x99, 0x0B, 0x47}; | ||
84 | EXPECT_CALL(*this, route_incoming_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(data, 5))); | ||
85 | validator_recv_frame(0, data, 9); | ||
86 | } | ||
87 | |||
88 | TEST_F(FrameValidator, sends_one_byte_with_correct_crc) { | ||
89 | uint8_t original[] = {0x44, 0, 0, 0, 0}; | ||
90 | uint8_t expected[] = {0x44, 0x04, 0x6A, 0xB3, 0xA3}; | ||
91 | EXPECT_CALL(*this, byte_stuffer_send_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
92 | validator_send_frame(0, original, 1); | ||
93 | } | ||
94 | |||
95 | TEST_F(FrameValidator, sends_five_bytes_with_correct_crc) { | ||
96 | uint8_t original[] = {1, 2, 3, 4, 5, 0, 0, 0, 0}; | ||
97 | uint8_t expected[] = {1, 2, 3, 4, 5, 0xF4, 0x99, 0x0B, 0x47}; | ||
98 | EXPECT_CALL(*this, byte_stuffer_send_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected))); | ||
99 | validator_send_frame(0, original, 5); | ||
100 | } | ||
diff --git a/quantum/serial_link/tests/rules.mk b/quantum/serial_link/tests/rules.mk deleted file mode 100644 index b81515bc5..000000000 --- a/quantum/serial_link/tests/rules.mk +++ /dev/null | |||
@@ -1,22 +0,0 @@ | |||
1 | serial_link_byte_stuffer_SRC :=\ | ||
2 | $(SERIAL_PATH)/tests/byte_stuffer_tests.cpp \ | ||
3 | $(SERIAL_PATH)/protocol/byte_stuffer.c | ||
4 | |||
5 | serial_link_frame_validator_SRC := \ | ||
6 | $(SERIAL_PATH)/tests/frame_validator_tests.cpp \ | ||
7 | $(SERIAL_PATH)/protocol/frame_validator.c | ||
8 | |||
9 | serial_link_frame_router_SRC := \ | ||
10 | $(SERIAL_PATH)/tests/frame_router_tests.cpp \ | ||
11 | $(SERIAL_PATH)/protocol/byte_stuffer.c \ | ||
12 | $(SERIAL_PATH)/protocol/frame_validator.c \ | ||
13 | $(SERIAL_PATH)/protocol/frame_router.c | ||
14 | |||
15 | serial_link_triple_buffered_object_SRC := \ | ||
16 | $(SERIAL_PATH)/tests/triple_buffered_object_tests.cpp \ | ||
17 | $(SERIAL_PATH)/protocol/triple_buffered_object.c | ||
18 | |||
19 | serial_link_transport_SRC := \ | ||
20 | $(SERIAL_PATH)/tests/transport_tests.cpp \ | ||
21 | $(SERIAL_PATH)/protocol/transport.c \ | ||
22 | $(SERIAL_PATH)/protocol/triple_buffered_object.c | ||
diff --git a/quantum/serial_link/tests/testlist.mk b/quantum/serial_link/tests/testlist.mk deleted file mode 100644 index c5edaf478..000000000 --- a/quantum/serial_link/tests/testlist.mk +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | TEST_LIST +=\ | ||
2 | serial_link_byte_stuffer\ | ||
3 | serial_link_frame_validator\ | ||
4 | serial_link_frame_router\ | ||
5 | serial_link_triple_buffered_object\ | ||
6 | serial_link_transport | ||
diff --git a/quantum/serial_link/tests/transport_tests.cpp b/quantum/serial_link/tests/transport_tests.cpp deleted file mode 100644 index cfd111046..000000000 --- a/quantum/serial_link/tests/transport_tests.cpp +++ /dev/null | |||
@@ -1,184 +0,0 @@ | |||
1 | /* | ||
2 | The MIT License (MIT) | ||
3 | |||
4 | Copyright (c) 2016 Fred Sundvik | ||
5 | |||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | ||
7 | of this software and associated documentation files (the "Software"), to deal | ||
8 | in the Software without restriction, including without limitation the rights | ||
9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
10 | copies of the Software, and to permit persons to whom the Software is | ||
11 | furnished to do so, subject to the following conditions: | ||
12 | |||
13 | The above copyright notice and this permission notice shall be included in all | ||
14 | copies or substantial portions of the Software. | ||
15 | |||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
22 | SOFTWARE. | ||
23 | */ | ||
24 | |||
25 | #include "gtest/gtest.h" | ||
26 | #include "gmock/gmock.h" | ||
27 | |||
28 | using testing::_; | ||
29 | using testing::Args; | ||
30 | using testing::ElementsAreArray; | ||
31 | |||
32 | extern "C" { | ||
33 | #include "serial_link/protocol/transport.h" | ||
34 | } | ||
35 | |||
36 | struct test_object1 { | ||
37 | uint32_t test; | ||
38 | }; | ||
39 | |||
40 | struct test_object2 { | ||
41 | uint32_t test1; | ||
42 | uint32_t test2; | ||
43 | }; | ||
44 | |||
45 | MASTER_TO_ALL_SLAVES_OBJECT(master_to_slave, test_object1); | ||
46 | MASTER_TO_SINGLE_SLAVE_OBJECT(master_to_single_slave, test_object1); | ||
47 | SLAVE_TO_MASTER_OBJECT(slave_to_master, test_object1); | ||
48 | |||
49 | static remote_object_t* test_remote_objects[] = { | ||
50 | REMOTE_OBJECT(master_to_slave), | ||
51 | REMOTE_OBJECT(master_to_single_slave), | ||
52 | REMOTE_OBJECT(slave_to_master), | ||
53 | }; | ||
54 | |||
55 | class Transport : public testing::Test { | ||
56 | public: | ||
57 | Transport() { | ||
58 | Instance = this; | ||
59 | add_remote_objects(test_remote_objects, sizeof(test_remote_objects) / sizeof(remote_object_t*)); | ||
60 | } | ||
61 | |||
62 | ~Transport() { | ||
63 | Instance = nullptr; | ||
64 | reinitialize_serial_link_transport(); | ||
65 | } | ||
66 | |||
67 | MOCK_METHOD0(signal_data_written, void()); | ||
68 | MOCK_METHOD1(router_send_frame, void(uint8_t destination)); | ||
69 | |||
70 | void router_send_frame(uint8_t destination, uint8_t* data, uint16_t size) { | ||
71 | router_send_frame(destination); | ||
72 | std::copy(data, data + size, std::back_inserter(sent_data)); | ||
73 | } | ||
74 | |||
75 | static Transport* Instance; | ||
76 | |||
77 | std::vector<uint8_t> sent_data; | ||
78 | }; | ||
79 | |||
80 | Transport* Transport::Instance = nullptr; | ||
81 | |||
82 | extern "C" { | ||
83 | void signal_data_written(void) { Transport::Instance->signal_data_written(); } | ||
84 | |||
85 | void router_send_frame(uint8_t destination, uint8_t* data, uint16_t size) { Transport::Instance->router_send_frame(destination, data, size); } | ||
86 | } | ||
87 | |||
88 | TEST_F(Transport, write_to_local_signals_an_event) { | ||
89 | begin_write_master_to_slave(); | ||
90 | EXPECT_CALL(*this, signal_data_written()); | ||
91 | end_write_master_to_slave(); | ||
92 | begin_write_slave_to_master(); | ||
93 | EXPECT_CALL(*this, signal_data_written()); | ||
94 | end_write_slave_to_master(); | ||
95 | begin_write_master_to_single_slave(1); | ||
96 | EXPECT_CALL(*this, signal_data_written()); | ||
97 | end_write_master_to_single_slave(1); | ||
98 | } | ||
99 | |||
100 | TEST_F(Transport, writes_from_master_to_all_slaves) { | ||
101 | update_transport(); | ||
102 | test_object1* obj = begin_write_master_to_slave(); | ||
103 | obj->test = 5; | ||
104 | EXPECT_CALL(*this, signal_data_written()); | ||
105 | end_write_master_to_slave(); | ||
106 | EXPECT_CALL(*this, router_send_frame(0xFF)); | ||
107 | update_transport(); | ||
108 | transport_recv_frame(0, sent_data.data(), sent_data.size()); | ||
109 | test_object1* obj2 = read_master_to_slave(); | ||
110 | EXPECT_NE(obj2, nullptr); | ||
111 | EXPECT_EQ(obj2->test, 5); | ||
112 | } | ||
113 | |||
114 | TEST_F(Transport, writes_from_slave_to_master) { | ||
115 | update_transport(); | ||
116 | test_object1* obj = begin_write_slave_to_master(); | ||
117 | obj->test = 7; | ||
118 | EXPECT_CALL(*this, signal_data_written()); | ||
119 | end_write_slave_to_master(); | ||
120 | EXPECT_CALL(*this, router_send_frame(0)); | ||
121 | update_transport(); | ||
122 | transport_recv_frame(3, sent_data.data(), sent_data.size()); | ||
123 | test_object1* obj2 = read_slave_to_master(2); | ||
124 | EXPECT_EQ(read_slave_to_master(0), nullptr); | ||
125 | EXPECT_NE(obj2, nullptr); | ||
126 | EXPECT_EQ(obj2->test, 7); | ||
127 | } | ||
128 | |||
129 | TEST_F(Transport, writes_from_master_to_single_slave) { | ||
130 | update_transport(); | ||
131 | test_object1* obj = begin_write_master_to_single_slave(3); | ||
132 | obj->test = 7; | ||
133 | EXPECT_CALL(*this, signal_data_written()); | ||
134 | end_write_master_to_single_slave(3); | ||
135 | EXPECT_CALL(*this, router_send_frame(4)); | ||
136 | update_transport(); | ||
137 | transport_recv_frame(0, sent_data.data(), sent_data.size()); | ||
138 | test_object1* obj2 = read_master_to_single_slave(); | ||
139 | EXPECT_NE(obj2, nullptr); | ||
140 | EXPECT_EQ(obj2->test, 7); | ||
141 | } | ||
142 | |||
143 | TEST_F(Transport, ignores_object_with_invalid_id) { | ||
144 | update_transport(); | ||
145 | test_object1* obj = begin_write_master_to_single_slave(3); | ||
146 | obj->test = 7; | ||
147 | EXPECT_CALL(*this, signal_data_written()); | ||
148 | end_write_master_to_single_slave(3); | ||
149 | EXPECT_CALL(*this, router_send_frame(4)); | ||
150 | update_transport(); | ||
151 | sent_data[sent_data.size() - 1] = 44; | ||
152 | transport_recv_frame(0, sent_data.data(), sent_data.size()); | ||
153 | test_object1* obj2 = read_master_to_single_slave(); | ||
154 | EXPECT_EQ(obj2, nullptr); | ||
155 | } | ||
156 | |||
157 | TEST_F(Transport, ignores_object_with_size_too_small) { | ||
158 | update_transport(); | ||
159 | test_object1* obj = begin_write_master_to_slave(); | ||
160 | obj->test = 7; | ||
161 | EXPECT_CALL(*this, signal_data_written()); | ||
162 | end_write_master_to_slave(); | ||
163 | EXPECT_CALL(*this, router_send_frame(_)); | ||
164 | update_transport(); | ||
165 | sent_data[sent_data.size() - 2] = 0; | ||
166 | transport_recv_frame(0, sent_data.data(), sent_data.size() - 1); | ||
167 | test_object1* obj2 = read_master_to_slave(); | ||
168 | EXPECT_EQ(obj2, nullptr); | ||
169 | } | ||
170 | |||
171 | TEST_F(Transport, ignores_object_with_size_too_big) { | ||
172 | update_transport(); | ||
173 | test_object1* obj = begin_write_master_to_slave(); | ||
174 | obj->test = 7; | ||
175 | EXPECT_CALL(*this, signal_data_written()); | ||
176 | end_write_master_to_slave(); | ||
177 | EXPECT_CALL(*this, router_send_frame(_)); | ||
178 | update_transport(); | ||
179 | sent_data.resize(sent_data.size() + 22); | ||
180 | sent_data[sent_data.size() - 1] = 0; | ||
181 | transport_recv_frame(0, sent_data.data(), sent_data.size()); | ||
182 | test_object1* obj2 = read_master_to_slave(); | ||
183 | EXPECT_EQ(obj2, nullptr); | ||
184 | } | ||
diff --git a/quantum/serial_link/tests/triple_buffered_object_tests.cpp b/quantum/serial_link/tests/triple_buffered_object_tests.cpp deleted file mode 100644 index 8de9bfdeb..000000000 --- a/quantum/serial_link/tests/triple_buffered_object_tests.cpp +++ /dev/null | |||
@@ -1,80 +0,0 @@ | |||
1 | /* | ||
2 | The MIT License (MIT) | ||
3 | |||
4 | Copyright (c) 2016 Fred Sundvik | ||
5 | |||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | ||
7 | of this software and associated documentation files (the "Software"), to deal | ||
8 | in the Software without restriction, including without limitation the rights | ||
9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
10 | copies of the Software, and to permit persons to whom the Software is | ||
11 | furnished to do so, subject to the following conditions: | ||
12 | |||
13 | The above copyright notice and this permission notice shall be included in all | ||
14 | copies or substantial portions of the Software. | ||
15 | |||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
22 | SOFTWARE. | ||
23 | */ | ||
24 | |||
25 | #include "gtest/gtest.h" | ||
26 | extern "C" { | ||
27 | #include "serial_link/protocol/triple_buffered_object.h" | ||
28 | } | ||
29 | |||
30 | struct test_object { | ||
31 | uint8_t state; | ||
32 | uint32_t buffer[3]; | ||
33 | }; | ||
34 | |||
35 | test_object test_object; | ||
36 | |||
37 | class TripleBufferedObject : public testing::Test { | ||
38 | public: | ||
39 | TripleBufferedObject() { triple_buffer_init((triple_buffer_object_t*)&test_object); } | ||
40 | }; | ||
41 | |||
42 | TEST_F(TripleBufferedObject, writes_and_reads_object) { | ||
43 | *triple_buffer_begin_write(&test_object) = 0x3456ABCC; | ||
44 | triple_buffer_end_write(&test_object); | ||
45 | EXPECT_EQ(*triple_buffer_read(&test_object), 0x3456ABCC); | ||
46 | } | ||
47 | |||
48 | TEST_F(TripleBufferedObject, does_not_read_empty) { EXPECT_EQ(triple_buffer_read(&test_object), nullptr); } | ||
49 | |||
50 | TEST_F(TripleBufferedObject, writes_twice_and_reads_object) { | ||
51 | *triple_buffer_begin_write(&test_object) = 0x3456ABCC; | ||
52 | triple_buffer_end_write(&test_object); | ||
53 | *triple_buffer_begin_write(&test_object) = 0x44778899; | ||
54 | triple_buffer_end_write(&test_object); | ||
55 | EXPECT_EQ(*triple_buffer_read(&test_object), 0x44778899); | ||
56 | } | ||
57 | |||
58 | TEST_F(TripleBufferedObject, performs_another_write_in_the_middle_of_read) { | ||
59 | *triple_buffer_begin_write(&test_object) = 1; | ||
60 | triple_buffer_end_write(&test_object); | ||
61 | uint32_t* read = triple_buffer_read(&test_object); | ||
62 | *triple_buffer_begin_write(&test_object) = 2; | ||
63 | triple_buffer_end_write(&test_object); | ||
64 | EXPECT_EQ(*read, 1); | ||
65 | EXPECT_EQ(*triple_buffer_read(&test_object), 2); | ||
66 | EXPECT_EQ(triple_buffer_read(&test_object), nullptr); | ||
67 | } | ||
68 | |||
69 | TEST_F(TripleBufferedObject, performs_two_writes_in_the_middle_of_read) { | ||
70 | *triple_buffer_begin_write(&test_object) = 1; | ||
71 | triple_buffer_end_write(&test_object); | ||
72 | uint32_t* read = triple_buffer_read(&test_object); | ||
73 | *triple_buffer_begin_write(&test_object) = 2; | ||
74 | triple_buffer_end_write(&test_object); | ||
75 | *triple_buffer_begin_write(&test_object) = 3; | ||
76 | triple_buffer_end_write(&test_object); | ||
77 | EXPECT_EQ(*read, 1); | ||
78 | EXPECT_EQ(*triple_buffer_read(&test_object), 3); | ||
79 | EXPECT_EQ(triple_buffer_read(&test_object), nullptr); | ||
80 | } | ||