Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 1 | // Copyright 2020 The Pigweed Authors |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| 4 | // use this file except in compliance with the License. You may obtain a copy of |
| 5 | // the License at |
| 6 | // |
| 7 | // https://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 11 | // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 12 | // License for the specific language governing permissions and limitations under |
| 13 | // the License. |
| 14 | |
| 15 | #include "pw_protobuf/decoder.h" |
| 16 | |
| 17 | #include "gtest/gtest.h" |
| 18 | #include "pw_preprocessor/util.h" |
| 19 | |
| 20 | namespace pw::protobuf { |
| 21 | namespace { |
| 22 | |
| 23 | class TestDecodeHandler : public DecodeHandler { |
| 24 | public: |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 25 | Status ProcessField(CallbackDecoder& decoder, |
| 26 | uint32_t field_number) override { |
Alexei Frolov | 6d9b9b4 | 2020-01-14 12:57:33 -0800 | [diff] [blame] | 27 | std::string_view str; |
| 28 | |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 29 | switch (field_number) { |
| 30 | case 1: |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 31 | decoder.ReadInt32(&test_int32); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 32 | break; |
| 33 | case 2: |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 34 | decoder.ReadSint32(&test_sint32); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 35 | break; |
Alexei Frolov | 6d9b9b4 | 2020-01-14 12:57:33 -0800 | [diff] [blame] | 36 | case 3: |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 37 | decoder.ReadBool(&test_bool); |
Alexei Frolov | 6d9b9b4 | 2020-01-14 12:57:33 -0800 | [diff] [blame] | 38 | break; |
| 39 | case 4: |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 40 | decoder.ReadDouble(&test_double); |
Alexei Frolov | 6d9b9b4 | 2020-01-14 12:57:33 -0800 | [diff] [blame] | 41 | break; |
| 42 | case 5: |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 43 | decoder.ReadFixed32(&test_fixed32); |
Alexei Frolov | 6d9b9b4 | 2020-01-14 12:57:33 -0800 | [diff] [blame] | 44 | break; |
| 45 | case 6: |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 46 | decoder.ReadString(&str); |
Alexei Frolov | 6d9b9b4 | 2020-01-14 12:57:33 -0800 | [diff] [blame] | 47 | std::memcpy(test_string, str.data(), str.size()); |
| 48 | test_string[str.size()] = '\0'; |
| 49 | break; |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 50 | } |
| 51 | |
| 52 | called = true; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 53 | return OkStatus(); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 54 | } |
| 55 | |
| 56 | bool called = false; |
| 57 | int32_t test_int32 = 0; |
| 58 | int32_t test_sint32 = 0; |
Alexei Frolov | 6d9b9b4 | 2020-01-14 12:57:33 -0800 | [diff] [blame] | 59 | bool test_bool = true; |
| 60 | double test_double = 0; |
| 61 | uint32_t test_fixed32 = 0; |
| 62 | char test_string[16]; |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 63 | }; |
| 64 | |
| 65 | TEST(Decoder, Decode) { |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 66 | // clang-format off |
| 67 | uint8_t encoded_proto[] = { |
| 68 | // type=int32, k=1, v=42 |
| 69 | 0x08, 0x2a, |
| 70 | // type=sint32, k=2, v=-13 |
| 71 | 0x10, 0x19, |
| 72 | // type=bool, k=3, v=false |
| 73 | 0x18, 0x00, |
| 74 | // type=double, k=4, v=3.14159 |
| 75 | 0x21, 0x6e, 0x86, 0x1b, 0xf0, 0xf9, 0x21, 0x09, 0x40, |
| 76 | // type=fixed32, k=5, v=0xdeadbeef |
| 77 | 0x2d, 0xef, 0xbe, 0xad, 0xde, |
| 78 | // type=string, k=6, v="Hello world" |
| 79 | 0x32, 0x0b, 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', |
| 80 | }; |
| 81 | // clang-format on |
| 82 | |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 83 | Decoder decoder(std::as_bytes(std::span(encoded_proto))); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 84 | |
| 85 | int32_t v1 = 0; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 86 | EXPECT_EQ(decoder.Next(), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 87 | ASSERT_EQ(decoder.FieldNumber(), 1u); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 88 | EXPECT_EQ(decoder.ReadInt32(&v1), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 89 | EXPECT_EQ(v1, 42); |
| 90 | |
| 91 | int32_t v2 = 0; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 92 | EXPECT_EQ(decoder.Next(), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 93 | ASSERT_EQ(decoder.FieldNumber(), 2u); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 94 | EXPECT_EQ(decoder.ReadSint32(&v2), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 95 | EXPECT_EQ(v2, -13); |
| 96 | |
| 97 | bool v3 = true; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 98 | EXPECT_EQ(decoder.Next(), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 99 | ASSERT_EQ(decoder.FieldNumber(), 3u); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 100 | EXPECT_EQ(decoder.ReadBool(&v3), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 101 | EXPECT_FALSE(v3); |
| 102 | |
| 103 | double v4 = 0; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 104 | EXPECT_EQ(decoder.Next(), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 105 | ASSERT_EQ(decoder.FieldNumber(), 4u); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 106 | EXPECT_EQ(decoder.ReadDouble(&v4), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 107 | EXPECT_EQ(v4, 3.14159); |
| 108 | |
| 109 | uint32_t v5 = 0; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 110 | EXPECT_EQ(decoder.Next(), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 111 | ASSERT_EQ(decoder.FieldNumber(), 5u); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 112 | EXPECT_EQ(decoder.ReadFixed32(&v5), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 113 | EXPECT_EQ(v5, 0xdeadbeef); |
| 114 | |
| 115 | std::string_view v6; |
| 116 | char buffer[16]; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 117 | EXPECT_EQ(decoder.Next(), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 118 | ASSERT_EQ(decoder.FieldNumber(), 6u); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 119 | EXPECT_EQ(decoder.ReadString(&v6), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 120 | std::memcpy(buffer, v6.data(), v6.size()); |
| 121 | buffer[v6.size()] = '\0'; |
| 122 | EXPECT_STREQ(buffer, "Hello world"); |
| 123 | |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 124 | EXPECT_EQ(decoder.Next(), Status::OutOfRange()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 125 | } |
| 126 | |
| 127 | TEST(Decoder, Decode_SkipsUnusedFields) { |
| 128 | // clang-format off |
| 129 | uint8_t encoded_proto[] = { |
| 130 | // type=int32, k=1, v=42 |
| 131 | 0x08, 0x2a, |
| 132 | // type=sint32, k=2, v=-13 |
| 133 | 0x10, 0x19, |
| 134 | // type=bool, k=3, v=false |
| 135 | 0x18, 0x00, |
| 136 | // type=double, k=4, v=3.14159 |
| 137 | 0x21, 0x6e, 0x86, 0x1b, 0xf0, 0xf9, 0x21, 0x09, 0x40, |
| 138 | // type=fixed32, k=5, v=0xdeadbeef |
| 139 | 0x2d, 0xef, 0xbe, 0xad, 0xde, |
| 140 | // type=string, k=6, v="Hello world" |
| 141 | 0x32, 0x0b, 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', |
| 142 | }; |
| 143 | // clang-format on |
| 144 | |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 145 | Decoder decoder(std::as_bytes(std::span(encoded_proto))); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 146 | |
| 147 | // Don't process any fields except for the fourth. Next should still iterate |
| 148 | // correctly despite field values not being consumed. |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 149 | EXPECT_EQ(decoder.Next(), OkStatus()); |
| 150 | EXPECT_EQ(decoder.Next(), OkStatus()); |
| 151 | EXPECT_EQ(decoder.Next(), OkStatus()); |
| 152 | EXPECT_EQ(decoder.Next(), OkStatus()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 153 | ASSERT_EQ(decoder.FieldNumber(), 4u); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 154 | EXPECT_EQ(decoder.Next(), OkStatus()); |
| 155 | EXPECT_EQ(decoder.Next(), OkStatus()); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 156 | EXPECT_EQ(decoder.Next(), Status::OutOfRange()); |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 157 | } |
| 158 | |
| 159 | TEST(CallbackDecoder, Decode) { |
| 160 | CallbackDecoder decoder; |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 161 | TestDecodeHandler handler; |
| 162 | |
| 163 | // clang-format off |
| 164 | uint8_t encoded_proto[] = { |
| 165 | // type=int32, k=1, v=42 |
| 166 | 0x08, 0x2a, |
| 167 | // type=sint32, k=2, v=-13 |
| 168 | 0x10, 0x19, |
| 169 | // type=bool, k=3, v=false |
| 170 | 0x18, 0x00, |
| 171 | // type=double, k=4, v=3.14159 |
| 172 | 0x21, 0x6e, 0x86, 0x1b, 0xf0, 0xf9, 0x21, 0x09, 0x40, |
| 173 | // type=fixed32, k=5, v=0xdeadbeef |
| 174 | 0x2d, 0xef, 0xbe, 0xad, 0xde, |
Alexei Frolov | 6d9b9b4 | 2020-01-14 12:57:33 -0800 | [diff] [blame] | 175 | // type=string, k=6, v="Hello world" |
| 176 | 0x32, 0x0b, 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 177 | }; |
| 178 | // clang-format on |
| 179 | |
| 180 | decoder.set_handler(&handler); |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 181 | EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))), |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 182 | OkStatus()); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 183 | EXPECT_TRUE(handler.called); |
| 184 | EXPECT_EQ(handler.test_int32, 42); |
| 185 | EXPECT_EQ(handler.test_sint32, -13); |
Alexei Frolov | 6d9b9b4 | 2020-01-14 12:57:33 -0800 | [diff] [blame] | 186 | EXPECT_FALSE(handler.test_bool); |
| 187 | EXPECT_EQ(handler.test_double, 3.14159); |
| 188 | EXPECT_EQ(handler.test_fixed32, 0xdeadbeef); |
| 189 | EXPECT_STREQ(handler.test_string, "Hello world"); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 190 | } |
| 191 | |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 192 | TEST(CallbackDecoder, Decode_OverridesDuplicateFields) { |
| 193 | CallbackDecoder decoder; |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 194 | TestDecodeHandler handler; |
| 195 | |
| 196 | // clang-format off |
| 197 | uint8_t encoded_proto[] = { |
| 198 | // type=int32, k=1, v=42 |
| 199 | 0x08, 0x2a, |
| 200 | // type=int32, k=1, v=43 |
| 201 | 0x08, 0x2b, |
| 202 | // type=int32, k=1, v=44 |
| 203 | 0x08, 0x2c, |
| 204 | }; |
| 205 | // clang-format on |
| 206 | |
| 207 | decoder.set_handler(&handler); |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 208 | EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))), |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 209 | OkStatus()); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 210 | EXPECT_TRUE(handler.called); |
| 211 | EXPECT_EQ(handler.test_int32, 44); |
| 212 | } |
| 213 | |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 214 | TEST(CallbackDecoder, Decode_Empty) { |
| 215 | CallbackDecoder decoder; |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 216 | TestDecodeHandler handler; |
| 217 | |
| 218 | decoder.set_handler(&handler); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 219 | EXPECT_EQ(decoder.Decode(std::span<std::byte>()), OkStatus()); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 220 | EXPECT_FALSE(handler.called); |
| 221 | EXPECT_EQ(handler.test_int32, 0); |
| 222 | EXPECT_EQ(handler.test_sint32, 0); |
| 223 | } |
| 224 | |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 225 | TEST(CallbackDecoder, Decode_BadData) { |
| 226 | CallbackDecoder decoder; |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 227 | TestDecodeHandler handler; |
| 228 | |
| 229 | // Field key without a value. |
| 230 | uint8_t encoded_proto[] = {0x08}; |
| 231 | |
| 232 | decoder.set_handler(&handler); |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 233 | EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))), |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 234 | Status::DataLoss()); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 235 | } |
| 236 | |
| 237 | // Only processes fields numbered 1 or 3. |
| 238 | class OneThreeDecodeHandler : public DecodeHandler { |
| 239 | public: |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 240 | Status ProcessField(CallbackDecoder& decoder, |
| 241 | uint32_t field_number) override { |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 242 | switch (field_number) { |
| 243 | case 1: |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 244 | EXPECT_EQ(decoder.ReadInt32(&field_one), OkStatus()); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 245 | break; |
| 246 | case 3: |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 247 | EXPECT_EQ(decoder.ReadInt32(&field_three), OkStatus()); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 248 | break; |
| 249 | default: |
| 250 | // Do nothing. |
| 251 | break; |
| 252 | } |
| 253 | |
| 254 | called = true; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 255 | return OkStatus(); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 256 | } |
| 257 | |
| 258 | bool called = false; |
| 259 | int32_t field_one = 0; |
| 260 | int32_t field_three = 0; |
| 261 | }; |
| 262 | |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 263 | TEST(CallbackDecoder, Decode_SkipsUnprocessedFields) { |
| 264 | CallbackDecoder decoder; |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 265 | OneThreeDecodeHandler handler; |
| 266 | |
| 267 | // clang-format off |
| 268 | uint8_t encoded_proto[] = { |
| 269 | // type=int32, k=1, v=42 |
| 270 | // Should be read. |
| 271 | 0x08, 0x2a, |
| 272 | // type=sint32, k=2, v=-13 |
| 273 | // Should be ignored. |
| 274 | 0x10, 0x19, |
| 275 | // type=int32, k=2, v=3 |
| 276 | // Should be ignored. |
| 277 | 0x10, 0x03, |
| 278 | // type=int32, k=3, v=99 |
| 279 | // Should be read. |
| 280 | 0x18, 0x63, |
| 281 | // type=int32, k=4, v=16 |
| 282 | // Should be ignored. |
| 283 | 0x20, 0x10, |
| 284 | }; |
| 285 | // clang-format on |
| 286 | |
| 287 | decoder.set_handler(&handler); |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 288 | EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))), |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 289 | OkStatus()); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 290 | EXPECT_TRUE(handler.called); |
| 291 | EXPECT_EQ(handler.field_one, 42); |
| 292 | EXPECT_EQ(handler.field_three, 99); |
| 293 | } |
| 294 | |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 295 | // Only processes fields numbered 1 or 3, and stops the decode after hitting 1. |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 296 | class ExitOnOneDecoder : public DecodeHandler { |
| 297 | public: |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 298 | Status ProcessField(CallbackDecoder& decoder, |
| 299 | uint32_t field_number) override { |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 300 | switch (field_number) { |
| 301 | case 1: |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 302 | EXPECT_EQ(decoder.ReadInt32(&field_one), OkStatus()); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 303 | return Status::Cancelled(); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 304 | case 3: |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 305 | EXPECT_EQ(decoder.ReadInt32(&field_three), OkStatus()); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 306 | break; |
| 307 | default: |
| 308 | // Do nothing. |
| 309 | break; |
| 310 | } |
| 311 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 312 | return OkStatus(); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 313 | } |
| 314 | |
| 315 | int32_t field_one = 0; |
| 316 | int32_t field_three = 1111; |
| 317 | }; |
| 318 | |
Alexei Frolov | fe9723c | 2020-05-11 13:20:47 -0700 | [diff] [blame] | 319 | TEST(CallbackDecoder, Decode_StopsOnNonOkStatus) { |
| 320 | CallbackDecoder decoder; |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 321 | ExitOnOneDecoder handler; |
| 322 | |
| 323 | // clang-format off |
| 324 | uint8_t encoded_proto[] = { |
| 325 | // type=int32, k=1, v=42 |
| 326 | // Should be read. |
| 327 | 0x08, 0x2a, |
| 328 | // type=int32, k=3, v=99 |
| 329 | // Should be skipped. |
| 330 | 0x18, 0x63, |
| 331 | // type=int32, k=2, v=16 |
| 332 | // Should be skipped. |
| 333 | 0x08, 0x10, |
| 334 | }; |
| 335 | // clang-format on |
| 336 | |
| 337 | decoder.set_handler(&handler); |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 338 | EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))), |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 339 | Status::Cancelled()); |
Alexei Frolov | dea46f7 | 2020-01-07 13:28:24 -0800 | [diff] [blame] | 340 | EXPECT_EQ(handler.field_one, 42); |
| 341 | EXPECT_EQ(handler.field_three, 1111); |
| 342 | } |
| 343 | |
| 344 | } // namespace |
| 345 | } // namespace pw::protobuf |