| /* |
| * Copyright (C) 2019 The Android Open Source Project |
| * |
| * 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 |
| * |
| * http://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 "src/trace_processor/util/protozero_to_text.h" |
| |
| #include "perfetto/ext/base/string_utils.h" |
| #include "perfetto/protozero/scattered_heap_buffer.h" |
| #include "src/protozero/test/example_proto/test_messages.pbzero.h" |
| #include "src/trace_processor/importers/proto/track_event.descriptor.h" |
| #include "src/trace_processor/test_messages.descriptor.h" |
| #include "src/trace_processor/util/descriptors.h" |
| #include "test/gtest_and_gmock.h" |
| |
| #include "protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.pbzero.h" |
| #include "protos/perfetto/trace/track_event/track_event.pbzero.h" |
| |
| namespace perfetto { |
| namespace trace_processor { |
| namespace protozero_to_text { |
| |
| namespace { |
| |
| constexpr size_t kChunkSize = 42; |
| |
| using ::protozero::test::protos::pbzero::EveryField; |
| using ::protozero::test::protos::pbzero::PackedRepeatedFields; |
| using ::testing::_; |
| using ::testing::ElementsAre; |
| using ::testing::Eq; |
| using ::testing::StartsWith; |
| |
| TEST(ProtozeroToTextTest, TrackEventBasic) { |
| using perfetto::protos::pbzero::TrackEvent; |
| protozero::HeapBuffered<TrackEvent> msg{kChunkSize, kChunkSize}; |
| msg->set_track_uuid(4); |
| msg->set_timestamp_delta_us(3); |
| auto binary_proto = msg.SerializeAsArray(); |
| EXPECT_EQ( |
| "track_uuid: 4\ntimestamp_delta_us: 3", |
| DebugTrackEventProtozeroToText( |
| ".perfetto.protos.TrackEvent", |
| protozero::ConstBytes{binary_proto.data(), binary_proto.size()})); |
| EXPECT_EQ( |
| "track_uuid: 4 timestamp_delta_us: 3", |
| ShortDebugTrackEventProtozeroToText( |
| ".perfetto.protos.TrackEvent", |
| protozero::ConstBytes{binary_proto.data(), binary_proto.size()})); |
| } |
| |
| TEST(ProtozeroToTextTest, TrackEventNestedMsg) { |
| using perfetto::protos::pbzero::TrackEvent; |
| protozero::HeapBuffered<TrackEvent> msg{kChunkSize, kChunkSize}; |
| msg->set_track_uuid(4); |
| auto* state = msg->set_cc_scheduler_state(); |
| state->set_deadline_us(7); |
| auto* machine = state->set_state_machine(); |
| auto* minor_state = machine->set_minor_state(); |
| minor_state->set_commit_count(8); |
| state->set_observing_begin_frame_source(true); |
| msg->set_timestamp_delta_us(3); |
| auto binary_proto = msg.SerializeAsArray(); |
| |
| EXPECT_EQ( |
| R"(track_uuid: 4 |
| cc_scheduler_state { |
| deadline_us: 7 |
| state_machine { |
| minor_state { |
| commit_count: 8 |
| } |
| } |
| observing_begin_frame_source: true |
| } |
| timestamp_delta_us: 3)", |
| DebugTrackEventProtozeroToText( |
| ".perfetto.protos.TrackEvent", |
| protozero::ConstBytes{binary_proto.data(), binary_proto.size()})); |
| |
| EXPECT_EQ( |
| "track_uuid: 4 cc_scheduler_state { deadline_us: 7 state_machine { " |
| "minor_state { commit_count: 8 } } observing_begin_frame_source: true } " |
| "timestamp_delta_us: 3", |
| ShortDebugTrackEventProtozeroToText( |
| ".perfetto.protos.TrackEvent", |
| protozero::ConstBytes{binary_proto.data(), binary_proto.size()})); |
| } |
| |
| TEST(ProtozeroToTextTest, TrackEventEnumNames) { |
| using perfetto::protos::pbzero::TrackEvent; |
| protozero::HeapBuffered<TrackEvent> msg{kChunkSize, kChunkSize}; |
| msg->set_type(TrackEvent::TYPE_SLICE_BEGIN); |
| auto binary_proto = msg.SerializeAsArray(); |
| EXPECT_EQ( |
| "type: TYPE_SLICE_BEGIN", |
| DebugTrackEventProtozeroToText( |
| ".perfetto.protos.TrackEvent", |
| protozero::ConstBytes{binary_proto.data(), binary_proto.size()})); |
| EXPECT_EQ( |
| "type: TYPE_SLICE_BEGIN", |
| DebugTrackEventProtozeroToText( |
| ".perfetto.protos.TrackEvent", |
| protozero::ConstBytes{binary_proto.data(), binary_proto.size()})); |
| } |
| |
| TEST(ProtozeroToTextTest, CustomDescriptorPoolBasic) { |
| using perfetto::protos::pbzero::TrackEvent; |
| protozero::HeapBuffered<TrackEvent> msg{kChunkSize, kChunkSize}; |
| msg->set_track_uuid(4); |
| msg->set_timestamp_delta_us(3); |
| auto binary_proto = msg.SerializeAsArray(); |
| DescriptorPool pool; |
| auto status = pool.AddFromFileDescriptorSet(kTrackEventDescriptor.data(), |
| kTrackEventDescriptor.size()); |
| ASSERT_TRUE(status.ok()); |
| EXPECT_EQ("track_uuid: 4\ntimestamp_delta_us: 3", |
| ProtozeroToText(pool, ".perfetto.protos.TrackEvent", binary_proto, |
| kIncludeNewLines)); |
| EXPECT_EQ("track_uuid: 4 timestamp_delta_us: 3", |
| ProtozeroToText(pool, ".perfetto.protos.TrackEvent", binary_proto, |
| kSkipNewLines)); |
| } |
| |
| TEST(ProtozeroToTextTest, CustomDescriptorPoolNestedMsg) { |
| using perfetto::protos::pbzero::TrackEvent; |
| protozero::HeapBuffered<TrackEvent> msg{kChunkSize, kChunkSize}; |
| msg->set_track_uuid(4); |
| auto* state = msg->set_cc_scheduler_state(); |
| state->set_deadline_us(7); |
| auto* machine = state->set_state_machine(); |
| auto* minor_state = machine->set_minor_state(); |
| minor_state->set_commit_count(8); |
| state->set_observing_begin_frame_source(true); |
| msg->set_timestamp_delta_us(3); |
| auto binary_proto = msg.SerializeAsArray(); |
| |
| DescriptorPool pool; |
| auto status = pool.AddFromFileDescriptorSet(kTrackEventDescriptor.data(), |
| kTrackEventDescriptor.size()); |
| ASSERT_TRUE(status.ok()); |
| |
| EXPECT_EQ( |
| R"(track_uuid: 4 |
| cc_scheduler_state { |
| deadline_us: 7 |
| state_machine { |
| minor_state { |
| commit_count: 8 |
| } |
| } |
| observing_begin_frame_source: true |
| } |
| timestamp_delta_us: 3)", |
| ProtozeroToText(pool, ".perfetto.protos.TrackEvent", binary_proto, |
| kIncludeNewLines)); |
| |
| EXPECT_EQ( |
| "track_uuid: 4 cc_scheduler_state { deadline_us: 7 state_machine { " |
| "minor_state { commit_count: 8 } } observing_begin_frame_source: true } " |
| "timestamp_delta_us: 3", |
| ProtozeroToText(pool, ".perfetto.protos.TrackEvent", binary_proto, |
| kSkipNewLines)); |
| } |
| |
| TEST(ProtozeroToTextTest, ProtozeroEnumToText) { |
| using perfetto::protos::pbzero::TrackEvent; |
| EXPECT_EQ("TYPE_SLICE_END", |
| ProtozeroEnumToText(".perfetto.protos.TrackEvent.Type", |
| TrackEvent::TYPE_SLICE_END)); |
| } |
| |
| // Sets up a descriptor pool with all the messages from |
| // "src/protozero/test/example_proto/test_messages.proto" |
| class ProtozeroToTextTestMessageTest : public testing::Test { |
| protected: |
| void SetUp() override { |
| auto status = pool_.AddFromFileDescriptorSet( |
| kTestMessagesDescriptor.data(), kTestMessagesDescriptor.size()); |
| ASSERT_TRUE(status.ok()); |
| } |
| |
| DescriptorPool pool_; |
| }; |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntInt32) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_int32(42); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_int32: 42"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntSint32) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_sint32(-42); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_sint32: -42"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntUint32) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_uint32(3000000000); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_uint32: 3000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntInt64) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_int64(3000000000); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_int64: 3000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntSint64) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_sint64(-3000000000); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_sint64: -3000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntBool) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_bool(true); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_bool: true"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntSmallEnum) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_small_enum(protozero::test::protos::pbzero::TO_BE); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "small_enum: TO_BE"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntSignedEnum) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_signed_enum(protozero::test::protos::pbzero::NEGATIVE); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "signed_enum: NEGATIVE"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntBigEnum) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_big_enum(protozero::test::protos::pbzero::END); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "big_enum: END"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntEnumUnknown) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->AppendVarInt(EveryField::kSmallEnumFieldNumber, 42); |
| ASSERT_EQ(EveryField::kSmallEnumFieldNumber, 51); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "51: 42"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntUnknown) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->AppendVarInt(/*field_id=*/9999, /*value=*/42); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "9999: 42"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntMismatch) { |
| protozero::HeapBuffered<EveryField> msg; |
| ASSERT_EQ(EveryField::kFieldStringFieldNumber, 500); |
| msg->AppendVarInt(EveryField::kFieldStringFieldNumber, 42); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "500: 42"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntForPacked) { |
| // Even though field_int32 has [packed = true], it still accepts a non-packed |
| // representation. |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| msg->AppendVarInt(PackedRepeatedFields::kFieldInt32FieldNumber, 42); |
| |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_int32: 42"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldFixed32Signed) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_sfixed32(-42); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_sfixed32: -42"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldFixed32Unsigned) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_fixed32(3000000000); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_fixed32: 3000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldFixed32Float) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_float(24.125); |
| |
| EXPECT_THAT(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| StartsWith("field_float: 24.125")); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldFixed32Unknown) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->AppendFixed<uint32_t>(/*field_id=*/9999, /*value=*/0x1); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "9999: 0x00000001"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldFixed32Mismatch) { |
| protozero::HeapBuffered<EveryField> msg; |
| ASSERT_EQ(EveryField::kFieldStringFieldNumber, 500); |
| msg->AppendFixed<uint32_t>(EveryField::kFieldStringFieldNumber, 0x1); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "500: 0x00000001"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldFixed64Signed) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_sfixed64(-42); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_sfixed64: -42"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldFixed64Unsigned) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_fixed64(3000000000); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_fixed64: 3000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldFixed64Double) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_double(24.125); |
| |
| EXPECT_THAT(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| StartsWith("field_double: 24.125")); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldFixed64Unknown) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->AppendFixed<uint64_t>(/*field_id=*/9999, /*value=*/0x1); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "9999: 0x0000000000000001"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldFixed64Mismatch) { |
| protozero::HeapBuffered<EveryField> msg; |
| ASSERT_EQ(EveryField::kFieldStringFieldNumber, 500); |
| msg->AppendFixed<uint64_t>(EveryField::kFieldStringFieldNumber, 0x1); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "500: 0x0000000000000001"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedString) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_string("Hello"); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| R"(field_string: "Hello")"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedBytes) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_bytes("Hello"); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| R"(field_bytes: "Hello")"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedUnknown) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->AppendString(9999, "Hello"); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| R"(9999: "Hello")"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedMismatch) { |
| protozero::HeapBuffered<EveryField> msg; |
| ASSERT_EQ(EveryField::kFieldBoolFieldNumber, 13); |
| msg->AppendString(EveryField::kFieldBoolFieldNumber, "Hello"); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "# Packed type 8 not supported. Printing raw string.\n" |
| R"(13: "Hello")"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedForNonPacked) { |
| // Even though repeated_int32 doesn't have [packed = true], it still accepts a |
| // packed representation. |
| protozero::HeapBuffered<EveryField> msg; |
| protozero::PackedVarInt buf; |
| buf.Append<int32_t>(-42); |
| buf.Append<int32_t>(2147483647); |
| msg->AppendBytes(EveryField::kRepeatedInt32FieldNumber, buf.data(), |
| buf.size()); |
| |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "repeated_int32: -42\nrepeated_int32: 2147483647"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntInt32) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedVarInt buf; |
| buf.Append<int32_t>(-42); |
| buf.Append<int32_t>(2147483647); |
| msg->set_field_int32(buf); |
| |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_int32: -42\nfield_int32: 2147483647"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntInt64) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedVarInt buf; |
| buf.Append<int64_t>(-42); |
| buf.Append<int64_t>(3000000000); |
| msg->set_field_int64(buf); |
| |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_int64: -42\nfield_int64: 3000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntUint32) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedVarInt buf; |
| buf.Append<uint32_t>(42); |
| buf.Append<uint32_t>(3000000000); |
| msg->set_field_uint32(buf); |
| |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_uint32: 42\nfield_uint32: 3000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntUint64) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedVarInt buf; |
| buf.Append<uint64_t>(42); |
| buf.Append<uint64_t>(3000000000000); |
| msg->set_field_uint64(buf); |
| |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_uint64: 42\nfield_uint64: 3000000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed32Uint32) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedFixedSizeInt<uint32_t> buf; |
| buf.Append(42); |
| buf.Append(3000000000); |
| msg->set_field_fixed32(buf); |
| |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_fixed32: 42\nfield_fixed32: 3000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed32Int32) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedFixedSizeInt<int32_t> buf; |
| buf.Append(-42); |
| buf.Append(42); |
| msg->set_field_sfixed32(buf); |
| |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_sfixed32: -42\nfield_sfixed32: 42"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed32Float) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedFixedSizeInt<float> buf; |
| buf.Append(-42); |
| buf.Append(42.125); |
| msg->set_field_float(buf); |
| |
| std::string output = |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines); |
| |
| EXPECT_THAT(base::SplitString(output, "\n"), |
| ElementsAre(StartsWith("field_float: -42"), |
| StartsWith("field_float: 42.125"))); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed64Uint64) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedFixedSizeInt<uint64_t> buf; |
| buf.Append(42); |
| buf.Append(3000000000000); |
| msg->set_field_fixed64(buf); |
| |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_fixed64: 42\nfield_fixed64: 3000000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed64Int64) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedFixedSizeInt<int64_t> buf; |
| buf.Append(-42); |
| buf.Append(3000000000000); |
| msg->set_field_sfixed64(buf); |
| |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_sfixed64: -42\nfield_sfixed64: 3000000000000"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed64Double) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedFixedSizeInt<double> buf; |
| buf.Append(-42); |
| buf.Append(42.125); |
| msg->set_field_double(buf); |
| |
| EXPECT_THAT( |
| base::SplitString( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "\n"), |
| ElementsAre(StartsWith("field_double: -42"), |
| StartsWith("field_double: 42.125"))); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedSmallEnum) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedVarInt buf; |
| buf.Append(1); |
| buf.Append(0); |
| buf.Append(-1); |
| msg->set_small_enum(buf); |
| |
| EXPECT_THAT( |
| base::SplitString( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "\n"), |
| ElementsAre(Eq("small_enum: TO_BE"), Eq("small_enum: NOT_TO_BE"), |
| Eq("51: -1"))); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedSignedEnum) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedVarInt buf; |
| buf.Append(1); |
| buf.Append(0); |
| buf.Append(-1); |
| buf.Append(-100); |
| msg->set_signed_enum(buf); |
| |
| EXPECT_THAT( |
| base::SplitString( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "\n"), |
| ElementsAre(Eq("signed_enum: POSITIVE"), Eq("signed_enum: NEUTRAL"), |
| Eq("signed_enum: NEGATIVE"), Eq("52: -100"))); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedBigEnum) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedVarInt buf; |
| buf.Append(10); |
| buf.Append(100500); |
| buf.Append(-1); |
| msg->set_big_enum(buf); |
| |
| EXPECT_THAT( |
| base::SplitString( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "\n"), |
| ElementsAre(Eq("big_enum: BEGIN"), Eq("big_enum: END"), Eq("53: -1"))); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixedErrShort) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| std::string buf; |
| buf = "\x01"; |
| // buf does not contain enough data for a fixed 64 |
| msg->AppendBytes(PackedRepeatedFields::kFieldFixed64FieldNumber, buf.data(), |
| buf.size()); |
| |
| // "protoc --decode", instead, returns an error on stderr and doesn't output |
| // anything at all. |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "# Packed decoding failure for field field_fixed64\n"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixedGarbage) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedFixedSizeInt<uint64_t> buf; |
| buf.Append(42); |
| buf.Append(3000000000000); |
| std::string buf_and_garbage(reinterpret_cast<const char*>(buf.data()), |
| buf.size()); |
| buf_and_garbage += "\x01"; |
| // buf contains extra garbage |
| msg->AppendBytes(PackedRepeatedFields::kFieldFixed64FieldNumber, |
| buf_and_garbage.data(), buf_and_garbage.size()); |
| |
| // "protoc --decode", instead, returns an error on stderr and doesn't output |
| // anything at all. |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "# Packed decoding failure for field field_fixed64\n"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntShort) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| std::string buf; |
| buf = "\xFF"; |
| // for the varint to be valid, buf should contain another byte. |
| msg->AppendBytes(PackedRepeatedFields::kFieldInt32FieldNumber, buf.data(), |
| buf.size()); |
| |
| // "protoc --decode", instead, returns an error on stderr and doesn't output |
| // anything at all. |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "# Packed decoding failure for field field_int32\n"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntGarbage) { |
| protozero::HeapBuffered<PackedRepeatedFields> msg; |
| protozero::PackedVarInt buf; |
| buf.Append(42); |
| buf.Append(105); |
| std::string buf_and_garbage(reinterpret_cast<const char*>(buf.data()), |
| buf.size()); |
| buf_and_garbage += "\xFF"; |
| // buf contains extra garbage |
| msg->AppendBytes(PackedRepeatedFields::kFieldInt32FieldNumber, |
| buf_and_garbage.data(), buf_and_garbage.size()); |
| |
| // "protoc --decode", instead: |
| // * doesn't output anything. |
| // * returns an error on stderr. |
| EXPECT_EQ( |
| ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| "field_int32: 42\n" |
| "field_int32: 105\n" |
| "# Packed decoding failure for field field_int32\n"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, ExtraBytes) { |
| protozero::HeapBuffered<EveryField> msg; |
| EveryField* nested = msg->add_field_nested(); |
| nested->set_field_string("hello"); |
| std::string garbage("\377\377"); |
| nested->AppendRawProtoBytes(garbage.data(), garbage.size()); |
| |
| // "protoc --decode", instead: |
| // * doesn't output anything. |
| // * returns an error on stderr. |
| EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField", |
| msg.SerializeAsArray(), kIncludeNewLines), |
| R"(field_nested { |
| field_string: "hello" |
| # Extra bytes: "\377\377" |
| |
| })"); |
| } |
| |
| TEST_F(ProtozeroToTextTestMessageTest, NonExistingType) { |
| protozero::HeapBuffered<EveryField> msg; |
| msg->set_field_string("hello"); |
| ASSERT_EQ(EveryField::kFieldStringFieldNumber, 500); |
| |
| // "protoc --decode", instead: |
| // * doesn't output anything. |
| // * returns an error on stderr. |
| EXPECT_EQ(ProtozeroToText(pool_, ".non.existing.type", msg.SerializeAsArray(), |
| kIncludeNewLines), |
| R"(500: "hello")"); |
| } |
| |
| } // namespace |
| } // namespace protozero_to_text |
| } // namespace trace_processor |
| } // namespace perfetto |
