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 | } | ||
