Primiano Tucci | 97440f4 | 2017-10-24 13:27:18 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2017 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "protozero/proto_utils.h" |
| 18 | |
| 19 | #include <limits> |
| 20 | |
Primiano Tucci | d7d1be0 | 2017-10-30 17:41:34 +0000 | [diff] [blame] | 21 | #include "base/logging.h" |
| 22 | #include "base/utils.h" |
Primiano Tucci | 97440f4 | 2017-10-24 13:27:18 +0100 | [diff] [blame] | 23 | #include "gtest/gtest.h" |
| 24 | |
| 25 | namespace protozero { |
| 26 | namespace proto_utils { |
| 27 | namespace { |
| 28 | |
Primiano Tucci | d7d1be0 | 2017-10-30 17:41:34 +0000 | [diff] [blame] | 29 | using ::perfetto::base::ArraySize; |
| 30 | |
Primiano Tucci | 97440f4 | 2017-10-24 13:27:18 +0100 | [diff] [blame] | 31 | struct VarIntExpectation { |
| 32 | const char* encoded; |
| 33 | size_t encoded_size; |
| 34 | uint64_t int_value; |
| 35 | }; |
| 36 | |
| 37 | const VarIntExpectation kVarIntExpectations[] = { |
| 38 | {"\x00", 1, 0}, |
| 39 | {"\x01", 1, 0x1}, |
| 40 | {"\x7f", 1, 0x7F}, |
| 41 | {"\xFF\x01", 2, 0xFF}, |
| 42 | {"\xFF\x7F", 2, 0x3FFF}, |
| 43 | {"\x80\x80\x01", 3, 0x4000}, |
| 44 | {"\xFF\xFF\x7F", 3, 0x1FFFFF}, |
| 45 | {"\x80\x80\x80\x01", 4, 0x200000}, |
| 46 | {"\xFF\xFF\xFF\x7F", 4, 0xFFFFFFF}, |
| 47 | {"\x80\x80\x80\x80\x01", 5, 0x10000000}, |
| 48 | {"\xFF\xFF\xFF\xFF\x0F", 5, 0xFFFFFFFF}, |
| 49 | {"\x80\x80\x80\x80\x10", 5, 0x100000000}, |
| 50 | {"\xFF\xFF\xFF\xFF\x7F", 5, 0x7FFFFFFFF}, |
| 51 | {"\x80\x80\x80\x80\x80\x01", 6, 0x800000000}, |
| 52 | {"\xFF\xFF\xFF\xFF\xFF\x7F", 6, 0x3FFFFFFFFFF}, |
| 53 | {"\x80\x80\x80\x80\x80\x80\x01", 7, 0x40000000000}, |
| 54 | {"\xFF\xFF\xFF\xFF\xFF\xFF\x7F", 7, 0x1FFFFFFFFFFFF}, |
| 55 | {"\x80\x80\x80\x80\x80\x80\x80\x01", 8, 0x2000000000000}, |
| 56 | {"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F", 8, 0xFFFFFFFFFFFFFF}, |
| 57 | {"\x80\x80\x80\x80\x80\x80\x80\x80\x01", 9, 0x100000000000000}, |
| 58 | {"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F", 9, 0x7FFFFFFFFFFFFFFF}, |
| 59 | {"\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01", 10, 0x8000000000000000}, |
| 60 | {"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01", 10, 0xFFFFFFFFFFFFFFFF}, |
| 61 | }; |
| 62 | |
| 63 | TEST(ProtoUtilsTest, FieldPreambleEncoding) { |
| 64 | // According to C++ standard, right shift of negative value has |
| 65 | // implementation-defined resulting value. |
| 66 | if ((static_cast<int32_t>(0x80000000u) >> 31) != -1) |
| 67 | FAIL() << "Platform has unsupported negative number format or arithmetic"; |
| 68 | |
| 69 | EXPECT_EQ(0x08u, MakeTagVarInt(1)); |
| 70 | EXPECT_EQ(0x09u, MakeTagFixed<uint64_t>(1)); |
| 71 | EXPECT_EQ(0x0Au, MakeTagLengthDelimited(1)); |
| 72 | EXPECT_EQ(0x0Du, MakeTagFixed<uint32_t>(1)); |
| 73 | |
| 74 | EXPECT_EQ(0x03F8u, MakeTagVarInt(0x7F)); |
| 75 | EXPECT_EQ(0x03F9u, MakeTagFixed<int64_t>(0x7F)); |
| 76 | EXPECT_EQ(0x03FAu, MakeTagLengthDelimited(0x7F)); |
| 77 | EXPECT_EQ(0x03FDu, MakeTagFixed<int32_t>(0x7F)); |
| 78 | |
| 79 | EXPECT_EQ(0x0400u, MakeTagVarInt(0x80)); |
| 80 | EXPECT_EQ(0x0401u, MakeTagFixed<double>(0x80)); |
| 81 | EXPECT_EQ(0x0402u, MakeTagLengthDelimited(0x80)); |
| 82 | EXPECT_EQ(0x0405u, MakeTagFixed<float>(0x80)); |
| 83 | |
| 84 | EXPECT_EQ(0x01FFF8u, MakeTagVarInt(0x3fff)); |
| 85 | EXPECT_EQ(0x01FFF9u, MakeTagFixed<int64_t>(0x3fff)); |
| 86 | EXPECT_EQ(0x01FFFAu, MakeTagLengthDelimited(0x3fff)); |
| 87 | EXPECT_EQ(0x01FFFDu, MakeTagFixed<int32_t>(0x3fff)); |
| 88 | |
| 89 | EXPECT_EQ(0x020000u, MakeTagVarInt(0x4000)); |
| 90 | EXPECT_EQ(0x020001u, MakeTagFixed<int64_t>(0x4000)); |
| 91 | EXPECT_EQ(0x020002u, MakeTagLengthDelimited(0x4000)); |
| 92 | EXPECT_EQ(0x020005u, MakeTagFixed<int32_t>(0x4000)); |
| 93 | } |
| 94 | |
| 95 | TEST(ProtoUtilsTest, ZigZagEncoding) { |
| 96 | EXPECT_EQ(0u, ZigZagEncode(0)); |
| 97 | EXPECT_EQ(1u, ZigZagEncode(-1)); |
| 98 | EXPECT_EQ(2u, ZigZagEncode(1)); |
| 99 | EXPECT_EQ(3u, ZigZagEncode(-2)); |
| 100 | EXPECT_EQ(4294967293u, ZigZagEncode(-2147483647)); |
| 101 | EXPECT_EQ(4294967294u, ZigZagEncode(2147483647)); |
| 102 | EXPECT_EQ(std::numeric_limits<uint32_t>::max(), |
| 103 | ZigZagEncode(std::numeric_limits<int32_t>::min())); |
| 104 | EXPECT_EQ(std::numeric_limits<uint64_t>::max(), |
| 105 | ZigZagEncode(std::numeric_limits<int64_t>::min())); |
| 106 | } |
| 107 | |
| 108 | TEST(ProtoUtilsTest, VarIntEncoding) { |
Primiano Tucci | d7d1be0 | 2017-10-30 17:41:34 +0000 | [diff] [blame] | 109 | for (size_t i = 0; i < ArraySize(kVarIntExpectations); ++i) { |
Primiano Tucci | 97440f4 | 2017-10-24 13:27:18 +0100 | [diff] [blame] | 110 | const VarIntExpectation& exp = kVarIntExpectations[i]; |
| 111 | uint8_t buf[32]; |
| 112 | uint8_t* res = WriteVarInt<uint64_t>(exp.int_value, buf); |
| 113 | ASSERT_EQ(exp.encoded_size, static_cast<size_t>(res - buf)); |
| 114 | ASSERT_EQ(0, memcmp(buf, exp.encoded, exp.encoded_size)); |
| 115 | |
| 116 | if (exp.int_value <= std::numeric_limits<uint32_t>::max()) { |
| 117 | uint8_t* res_32 = |
| 118 | WriteVarInt<uint32_t>(static_cast<uint32_t>(exp.int_value), buf); |
| 119 | ASSERT_EQ(exp.encoded_size, static_cast<size_t>(res_32 - buf)); |
| 120 | ASSERT_EQ(0, memcmp(buf, exp.encoded, exp.encoded_size)); |
| 121 | } |
| 122 | } |
| 123 | } |
| 124 | |
| 125 | TEST(ProtoUtilsTest, RedundantVarIntEncoding) { |
| 126 | uint8_t buf[kMessageLengthFieldSize]; |
| 127 | |
| 128 | WriteRedundantVarInt(0, buf); |
| 129 | EXPECT_EQ(0, memcmp("\x80\x80\x80\x00", buf, sizeof(buf))); |
| 130 | |
| 131 | WriteRedundantVarInt(1, buf); |
| 132 | EXPECT_EQ(0, memcmp("\x81\x80\x80\x00", buf, sizeof(buf))); |
| 133 | |
| 134 | WriteRedundantVarInt(0x80, buf); |
| 135 | EXPECT_EQ(0, memcmp("\x80\x81\x80\x00", buf, sizeof(buf))); |
| 136 | |
| 137 | WriteRedundantVarInt(0x332211, buf); |
| 138 | EXPECT_EQ(0, memcmp("\x91\xC4\xCC\x01", buf, sizeof(buf))); |
| 139 | |
| 140 | // Largest allowed length. |
| 141 | WriteRedundantVarInt(0x0FFFFFFF, buf); |
| 142 | EXPECT_EQ(0, memcmp("\xFF\xFF\xFF\x7F", buf, sizeof(buf))); |
| 143 | } |
| 144 | |
| 145 | TEST(ProtoUtilsTest, VarIntDecoding) { |
Primiano Tucci | d7d1be0 | 2017-10-30 17:41:34 +0000 | [diff] [blame] | 146 | for (size_t i = 0; i < ArraySize(kVarIntExpectations); ++i) { |
Primiano Tucci | 97440f4 | 2017-10-24 13:27:18 +0100 | [diff] [blame] | 147 | const VarIntExpectation& exp = kVarIntExpectations[i]; |
| 148 | uint64_t value = std::numeric_limits<uint64_t>::max(); |
| 149 | const uint8_t* res = ParseVarInt( |
| 150 | reinterpret_cast<const uint8_t*>(exp.encoded), |
| 151 | reinterpret_cast<const uint8_t*>(exp.encoded + exp.encoded_size), |
| 152 | &value); |
| 153 | ASSERT_EQ(reinterpret_cast<const void*>(exp.encoded + exp.encoded_size), |
| 154 | reinterpret_cast<const void*>(res)); |
| 155 | ASSERT_EQ(exp.int_value, value); |
| 156 | } |
| 157 | } |
| 158 | |
| 159 | TEST(ProtoUtilsTest, FieldDecoding) { |
| 160 | struct FieldExpectation { |
| 161 | const char* encoded; |
| 162 | size_t encoded_size; |
| 163 | uint32_t id; |
| 164 | FieldType type; |
| 165 | uint64_t int_value; |
| 166 | }; |
| 167 | |
| 168 | const FieldExpectation kFieldExpectations[] = { |
| 169 | {"\x08\x00", 2, 1, kFieldTypeVarInt, 0}, |
| 170 | {"\x08\x42", 2, 1, kFieldTypeVarInt, 0x42}, |
| 171 | {"\xF8\x07\x42", 3, 127, kFieldTypeVarInt, 0x42}, |
| 172 | {"\x90\x4D\xFF\xFF\xFF\xFF\x0F", 7, 1234, kFieldTypeVarInt, 0xFFFFFFFF}, |
| 173 | {"\x7D\x42\x00\x00\x00", 5, 15, kFieldTypeFixed32, 0x42}, |
| 174 | {"\x95\x4D\x78\x56\x34\x12", 6, 1234, kFieldTypeFixed32, 0x12345678}, |
| 175 | {"\x79\x42\x00\x00\x00\x00\x00\x00\x00", 9, 15, kFieldTypeFixed64, 0x42}, |
| 176 | {"\x91\x4D\x08\x07\x06\x05\x04\x03\x02\x01", 10, 1234, kFieldTypeFixed64, |
| 177 | 0x0102030405060708}, |
| 178 | {"\x0A\x00", 2, 1, kFieldTypeLengthDelimited, 0}, |
| 179 | {"\x0A\x04|abc", 6, 1, kFieldTypeLengthDelimited, 4}, |
| 180 | {"\x92\x4D\x04|abc", 7, 1234, kFieldTypeLengthDelimited, 4}, |
| 181 | {"\x92\x4D\x83\x01|abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzab" |
| 182 | "cdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstu" |
| 183 | "vwx", |
| 184 | 135, 1234, kFieldTypeLengthDelimited, 131}, |
| 185 | }; |
| 186 | |
Primiano Tucci | d7d1be0 | 2017-10-30 17:41:34 +0000 | [diff] [blame] | 187 | for (size_t i = 0; i < ArraySize(kFieldExpectations); ++i) { |
Primiano Tucci | 97440f4 | 2017-10-24 13:27:18 +0100 | [diff] [blame] | 188 | const FieldExpectation& exp = kFieldExpectations[i]; |
| 189 | FieldType field_type = kFieldTypeVarInt; |
| 190 | uint32_t field_id = std::numeric_limits<uint32_t>::max(); |
| 191 | uint64_t field_intvalue = std::numeric_limits<uint64_t>::max(); |
| 192 | const uint8_t* res = ParseField( |
| 193 | reinterpret_cast<const uint8_t*>(exp.encoded), |
| 194 | reinterpret_cast<const uint8_t*>(exp.encoded + exp.encoded_size), |
| 195 | &field_id, &field_type, &field_intvalue); |
| 196 | ASSERT_EQ(reinterpret_cast<const void*>(exp.encoded + exp.encoded_size), |
| 197 | reinterpret_cast<const void*>(res)); |
| 198 | ASSERT_EQ(exp.id, field_id); |
| 199 | ASSERT_EQ(exp.type, field_type); |
| 200 | ASSERT_EQ(exp.int_value, field_intvalue); |
| 201 | } |
| 202 | } |
| 203 | |
| 204 | } // namespace |
| 205 | } // namespace proto_utils |
| 206 | } // namespace protozero |