You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
346 lines
9.1 KiB
346 lines
9.1 KiB
// Copyright 2020 The Pigweed Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
// use this file except in compliance with the License. You may obtain a copy of
|
|
// the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
// License for the specific language governing permissions and limitations under
|
|
// the License.
|
|
|
|
#include "pw_protobuf/decoder.h"
|
|
|
|
#include "gtest/gtest.h"
|
|
#include "pw_preprocessor/util.h"
|
|
|
|
namespace pw::protobuf {
|
|
namespace {
|
|
|
|
class TestDecodeHandler : public DecodeHandler {
|
|
public:
|
|
Status ProcessField(CallbackDecoder& decoder,
|
|
uint32_t field_number) override {
|
|
std::string_view str;
|
|
|
|
switch (field_number) {
|
|
case 1:
|
|
decoder.ReadInt32(&test_int32);
|
|
break;
|
|
case 2:
|
|
decoder.ReadSint32(&test_sint32);
|
|
break;
|
|
case 3:
|
|
decoder.ReadBool(&test_bool);
|
|
break;
|
|
case 4:
|
|
decoder.ReadDouble(&test_double);
|
|
break;
|
|
case 5:
|
|
decoder.ReadFixed32(&test_fixed32);
|
|
break;
|
|
case 6:
|
|
decoder.ReadString(&str);
|
|
std::memcpy(test_string, str.data(), str.size());
|
|
test_string[str.size()] = '\0';
|
|
break;
|
|
}
|
|
|
|
called = true;
|
|
return OkStatus();
|
|
}
|
|
|
|
bool called = false;
|
|
int32_t test_int32 = 0;
|
|
int32_t test_sint32 = 0;
|
|
bool test_bool = true;
|
|
double test_double = 0;
|
|
uint32_t test_fixed32 = 0;
|
|
char test_string[16];
|
|
};
|
|
|
|
TEST(Decoder, Decode) {
|
|
// clang-format off
|
|
uint8_t encoded_proto[] = {
|
|
// type=int32, k=1, v=42
|
|
0x08, 0x2a,
|
|
// type=sint32, k=2, v=-13
|
|
0x10, 0x19,
|
|
// type=bool, k=3, v=false
|
|
0x18, 0x00,
|
|
// type=double, k=4, v=3.14159
|
|
0x21, 0x6e, 0x86, 0x1b, 0xf0, 0xf9, 0x21, 0x09, 0x40,
|
|
// type=fixed32, k=5, v=0xdeadbeef
|
|
0x2d, 0xef, 0xbe, 0xad, 0xde,
|
|
// type=string, k=6, v="Hello world"
|
|
0x32, 0x0b, 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd',
|
|
};
|
|
// clang-format on
|
|
|
|
Decoder decoder(std::as_bytes(std::span(encoded_proto)));
|
|
|
|
int32_t v1 = 0;
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
ASSERT_EQ(decoder.FieldNumber(), 1u);
|
|
EXPECT_EQ(decoder.ReadInt32(&v1), OkStatus());
|
|
EXPECT_EQ(v1, 42);
|
|
|
|
int32_t v2 = 0;
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
ASSERT_EQ(decoder.FieldNumber(), 2u);
|
|
EXPECT_EQ(decoder.ReadSint32(&v2), OkStatus());
|
|
EXPECT_EQ(v2, -13);
|
|
|
|
bool v3 = true;
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
ASSERT_EQ(decoder.FieldNumber(), 3u);
|
|
EXPECT_EQ(decoder.ReadBool(&v3), OkStatus());
|
|
EXPECT_FALSE(v3);
|
|
|
|
double v4 = 0;
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
ASSERT_EQ(decoder.FieldNumber(), 4u);
|
|
EXPECT_EQ(decoder.ReadDouble(&v4), OkStatus());
|
|
EXPECT_EQ(v4, 3.14159);
|
|
|
|
uint32_t v5 = 0;
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
ASSERT_EQ(decoder.FieldNumber(), 5u);
|
|
EXPECT_EQ(decoder.ReadFixed32(&v5), OkStatus());
|
|
EXPECT_EQ(v5, 0xdeadbeef);
|
|
|
|
std::string_view v6;
|
|
char buffer[16];
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
ASSERT_EQ(decoder.FieldNumber(), 6u);
|
|
EXPECT_EQ(decoder.ReadString(&v6), OkStatus());
|
|
std::memcpy(buffer, v6.data(), v6.size());
|
|
buffer[v6.size()] = '\0';
|
|
EXPECT_STREQ(buffer, "Hello world");
|
|
|
|
EXPECT_EQ(decoder.Next(), Status::OutOfRange());
|
|
}
|
|
|
|
TEST(Decoder, Decode_SkipsUnusedFields) {
|
|
// clang-format off
|
|
uint8_t encoded_proto[] = {
|
|
// type=int32, k=1, v=42
|
|
0x08, 0x2a,
|
|
// type=sint32, k=2, v=-13
|
|
0x10, 0x19,
|
|
// type=bool, k=3, v=false
|
|
0x18, 0x00,
|
|
// type=double, k=4, v=3.14159
|
|
0x21, 0x6e, 0x86, 0x1b, 0xf0, 0xf9, 0x21, 0x09, 0x40,
|
|
// type=fixed32, k=5, v=0xdeadbeef
|
|
0x2d, 0xef, 0xbe, 0xad, 0xde,
|
|
// type=string, k=6, v="Hello world"
|
|
0x32, 0x0b, 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd',
|
|
};
|
|
// clang-format on
|
|
|
|
Decoder decoder(std::as_bytes(std::span(encoded_proto)));
|
|
|
|
// Don't process any fields except for the fourth. Next should still iterate
|
|
// correctly despite field values not being consumed.
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
ASSERT_EQ(decoder.FieldNumber(), 4u);
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
EXPECT_EQ(decoder.Next(), OkStatus());
|
|
EXPECT_EQ(decoder.Next(), Status::OutOfRange());
|
|
}
|
|
|
|
TEST(CallbackDecoder, Decode) {
|
|
CallbackDecoder decoder;
|
|
TestDecodeHandler handler;
|
|
|
|
// clang-format off
|
|
uint8_t encoded_proto[] = {
|
|
// type=int32, k=1, v=42
|
|
0x08, 0x2a,
|
|
// type=sint32, k=2, v=-13
|
|
0x10, 0x19,
|
|
// type=bool, k=3, v=false
|
|
0x18, 0x00,
|
|
// type=double, k=4, v=3.14159
|
|
0x21, 0x6e, 0x86, 0x1b, 0xf0, 0xf9, 0x21, 0x09, 0x40,
|
|
// type=fixed32, k=5, v=0xdeadbeef
|
|
0x2d, 0xef, 0xbe, 0xad, 0xde,
|
|
// type=string, k=6, v="Hello world"
|
|
0x32, 0x0b, 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd',
|
|
};
|
|
// clang-format on
|
|
|
|
decoder.set_handler(&handler);
|
|
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
|
|
OkStatus());
|
|
EXPECT_TRUE(handler.called);
|
|
EXPECT_EQ(handler.test_int32, 42);
|
|
EXPECT_EQ(handler.test_sint32, -13);
|
|
EXPECT_FALSE(handler.test_bool);
|
|
EXPECT_EQ(handler.test_double, 3.14159);
|
|
EXPECT_EQ(handler.test_fixed32, 0xdeadbeef);
|
|
EXPECT_STREQ(handler.test_string, "Hello world");
|
|
}
|
|
|
|
TEST(CallbackDecoder, Decode_OverridesDuplicateFields) {
|
|
CallbackDecoder decoder;
|
|
TestDecodeHandler handler;
|
|
|
|
// clang-format off
|
|
uint8_t encoded_proto[] = {
|
|
// type=int32, k=1, v=42
|
|
0x08, 0x2a,
|
|
// type=int32, k=1, v=43
|
|
0x08, 0x2b,
|
|
// type=int32, k=1, v=44
|
|
0x08, 0x2c,
|
|
};
|
|
// clang-format on
|
|
|
|
decoder.set_handler(&handler);
|
|
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
|
|
OkStatus());
|
|
EXPECT_TRUE(handler.called);
|
|
EXPECT_EQ(handler.test_int32, 44);
|
|
}
|
|
|
|
TEST(CallbackDecoder, Decode_Empty) {
|
|
CallbackDecoder decoder;
|
|
TestDecodeHandler handler;
|
|
|
|
decoder.set_handler(&handler);
|
|
EXPECT_EQ(decoder.Decode(std::span<std::byte>()), OkStatus());
|
|
EXPECT_FALSE(handler.called);
|
|
EXPECT_EQ(handler.test_int32, 0);
|
|
EXPECT_EQ(handler.test_sint32, 0);
|
|
}
|
|
|
|
TEST(CallbackDecoder, Decode_BadData) {
|
|
CallbackDecoder decoder;
|
|
TestDecodeHandler handler;
|
|
|
|
// Field key without a value.
|
|
uint8_t encoded_proto[] = {0x08};
|
|
|
|
decoder.set_handler(&handler);
|
|
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
|
|
Status::DataLoss());
|
|
}
|
|
|
|
// Only processes fields numbered 1 or 3.
|
|
class OneThreeDecodeHandler : public DecodeHandler {
|
|
public:
|
|
Status ProcessField(CallbackDecoder& decoder,
|
|
uint32_t field_number) override {
|
|
switch (field_number) {
|
|
case 1:
|
|
EXPECT_EQ(decoder.ReadInt32(&field_one), OkStatus());
|
|
break;
|
|
case 3:
|
|
EXPECT_EQ(decoder.ReadInt32(&field_three), OkStatus());
|
|
break;
|
|
default:
|
|
// Do nothing.
|
|
break;
|
|
}
|
|
|
|
called = true;
|
|
return OkStatus();
|
|
}
|
|
|
|
bool called = false;
|
|
int32_t field_one = 0;
|
|
int32_t field_three = 0;
|
|
};
|
|
|
|
TEST(CallbackDecoder, Decode_SkipsUnprocessedFields) {
|
|
CallbackDecoder decoder;
|
|
OneThreeDecodeHandler handler;
|
|
|
|
// clang-format off
|
|
uint8_t encoded_proto[] = {
|
|
// type=int32, k=1, v=42
|
|
// Should be read.
|
|
0x08, 0x2a,
|
|
// type=sint32, k=2, v=-13
|
|
// Should be ignored.
|
|
0x10, 0x19,
|
|
// type=int32, k=2, v=3
|
|
// Should be ignored.
|
|
0x10, 0x03,
|
|
// type=int32, k=3, v=99
|
|
// Should be read.
|
|
0x18, 0x63,
|
|
// type=int32, k=4, v=16
|
|
// Should be ignored.
|
|
0x20, 0x10,
|
|
};
|
|
// clang-format on
|
|
|
|
decoder.set_handler(&handler);
|
|
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
|
|
OkStatus());
|
|
EXPECT_TRUE(handler.called);
|
|
EXPECT_EQ(handler.field_one, 42);
|
|
EXPECT_EQ(handler.field_three, 99);
|
|
}
|
|
|
|
// Only processes fields numbered 1 or 3, and stops the decode after hitting 1.
|
|
class ExitOnOneDecoder : public DecodeHandler {
|
|
public:
|
|
Status ProcessField(CallbackDecoder& decoder,
|
|
uint32_t field_number) override {
|
|
switch (field_number) {
|
|
case 1:
|
|
EXPECT_EQ(decoder.ReadInt32(&field_one), OkStatus());
|
|
return Status::Cancelled();
|
|
case 3:
|
|
EXPECT_EQ(decoder.ReadInt32(&field_three), OkStatus());
|
|
break;
|
|
default:
|
|
// Do nothing.
|
|
break;
|
|
}
|
|
|
|
return OkStatus();
|
|
}
|
|
|
|
int32_t field_one = 0;
|
|
int32_t field_three = 1111;
|
|
};
|
|
|
|
TEST(CallbackDecoder, Decode_StopsOnNonOkStatus) {
|
|
CallbackDecoder decoder;
|
|
ExitOnOneDecoder handler;
|
|
|
|
// clang-format off
|
|
uint8_t encoded_proto[] = {
|
|
// type=int32, k=1, v=42
|
|
// Should be read.
|
|
0x08, 0x2a,
|
|
// type=int32, k=3, v=99
|
|
// Should be skipped.
|
|
0x18, 0x63,
|
|
// type=int32, k=2, v=16
|
|
// Should be skipped.
|
|
0x08, 0x10,
|
|
};
|
|
// clang-format on
|
|
|
|
decoder.set_handler(&handler);
|
|
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
|
|
Status::Cancelled());
|
|
EXPECT_EQ(handler.field_one, 42);
|
|
EXPECT_EQ(handler.field_three, 1111);
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace pw::protobuf
|