| // Copyright 2020 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <lib/async-loop/cpp/loop.h> |
| #include <lib/async-loop/default.h> |
| |
| #include <memory> |
| #include <sstream> |
| |
| #include <gtest/gtest.h> |
| #include <test/fidlcodec/examples/cpp/fidl.h> |
| |
| #include "src/lib/fidl_codec/fidl_codec_test.h" |
| #include "src/lib/fidl_codec/library_loader.h" |
| #include "src/lib/fidl_codec/printer.h" |
| #include "src/lib/fidl_codec/proto_value.h" |
| #include "src/lib/fidl_codec/wire_object.h" |
| #include "src/lib/fidl_codec/wire_types.h" |
| |
| namespace fidl_codec { |
| |
| class ProtoValueTest : public ::testing::Test { |
| protected: |
| void SetUp() override { |
| loader_ = GetLoader(); |
| ASSERT_NE(loader_, nullptr); |
| library_ = loader()->GetLibraryFromName("test.fidlcodec.examples"); |
| ASSERT_NE(library_, nullptr); |
| library_->DecodeAll(); |
| } |
| |
| LibraryLoader* loader() const { return loader_; } |
| Library* library() const { return library_; } |
| |
| std::unique_ptr<FidlMessageValue> CreateFidlMessage(const fidl::HLCPPIncomingMessage& message) { |
| DisplayOptions display_options; |
| MessageDecoderDispatcher decoder(loader(), display_options); |
| |
| constexpr uint64_t kProcessKoid = 0x1234; |
| |
| DecodedMessage decoded_message; |
| std::stringstream error_stream; |
| decoded_message.DecodeMessage(&decoder, kProcessKoid, ZX_HANDLE_INVALID, message.bytes().data(), |
| message.bytes().size(), nullptr, 0, |
| SyscallFidlType::kOutputMessage, error_stream); |
| return std::make_unique<fidl_codec::FidlMessageValue>(&decoded_message, error_stream.str(), |
| message.bytes().data(), |
| message.bytes().size(), nullptr, 0); |
| } |
| |
| private: |
| LibraryLoader* loader_ = nullptr; |
| Library* library_ = nullptr; |
| }; |
| |
| class ProtoPrinter : public PrettyPrinter { |
| public: |
| ProtoPrinter(std::ostream& os, bool dump_messages) |
| : PrettyPrinter(os, WithoutColors, true, "", 100, false), dump_messages_(dump_messages) {} |
| |
| bool DumpMessages() const override { return dump_messages_; } |
| |
| private: |
| const bool dump_messages_; |
| }; |
| |
| #define PROTO_TEST(value, type, dump_messages, expected) \ |
| { \ |
| proto::Value proto_value; \ |
| ProtoVisitor visitor(&proto_value); \ |
| value->Visit(&visitor, nullptr); \ |
| auto new_value = DecodeValue(loader(), proto_value, type); \ |
| std::stringstream ss; \ |
| ProtoPrinter printer(ss, dump_messages); \ |
| new_value->PrettyPrint(type, printer); \ |
| EXPECT_EQ(ss.str(), expected); \ |
| } |
| |
| TEST_F(ProtoValueTest, NullValue) { |
| PROTO_TEST(std::make_unique<NullValue>(), nullptr, false, "null"); |
| } |
| |
| TEST_F(ProtoValueTest, RawValue) { |
| std::array<uint8_t, 10> data = {0, 1, 3, 5, 7, 11, 13, 17, 19, 23}; |
| PROTO_TEST(std::make_unique<RawValue>(data.data(), data.size()), nullptr, false, |
| "00 01 03 05 07 0b 0d 11 13 17"); |
| } |
| |
| TEST_F(ProtoValueTest, BoolValue) { |
| PROTO_TEST(std::make_unique<BoolValue>(false), nullptr, false, "false"); |
| PROTO_TEST(std::make_unique<BoolValue>(true), nullptr, false, "true"); |
| } |
| |
| TEST_F(ProtoValueTest, IntegerValue) { |
| Int8Type type_int8; |
| PROTO_TEST(std::make_unique<IntegerValue>(10, true), &type_int8, false, "-10"); |
| |
| Int8Type type_uint32; |
| PROTO_TEST(std::make_unique<IntegerValue>(123456, false), &type_uint32, false, "123456"); |
| |
| std::unique_ptr<Type> enum_type = |
| library()->TypeFromIdentifier(/*is_nullable=*/false, "test.fidlcodec.examples/DefaultEnum"); |
| ASSERT_NE(enum_type, nullptr); |
| PROTO_TEST(std::make_unique<IntegerValue>( |
| static_cast<uint64_t>(test::fidlcodec::examples::DefaultEnum::X)), |
| enum_type.get(), false, "X"); |
| |
| std::unique_ptr<Type> bits_type = |
| library()->TypeFromIdentifier(/*is_nullable=*/false, "test.fidlcodec.examples/DefaultBits"); |
| ASSERT_NE(bits_type, nullptr); |
| PROTO_TEST(std::make_unique<IntegerValue>(5, false), bits_type.get(), false, "A|C"); |
| } |
| |
| TEST_F(ProtoValueTest, DoubleValue) { |
| Float32Type type_float32; |
| PROTO_TEST(std::make_unique<DoubleValue>(3.141593), &type_float32, false, "3.141593"); |
| Float64Type type_float64; |
| PROTO_TEST(std::make_unique<DoubleValue>(3.141593), &type_float64, false, "3.141593"); |
| } |
| |
| TEST_F(ProtoValueTest, StringValue) { |
| PROTO_TEST(std::make_unique<StringValue>("Hello world!"), nullptr, false, "\"Hello world!\""); |
| } |
| |
| TEST_F(ProtoValueTest, HandleValue) { |
| PROTO_TEST(std::make_unique<HandleValue>( |
| zx_handle_disposition_t{.operation = fidl_codec::kNoHandleDisposition, |
| .handle = 0x1234, |
| .type = ZX_OBJ_TYPE_CHANNEL, |
| .rights = ZX_RIGHT_DUPLICATE, |
| .result = ZX_OK}), |
| nullptr, false, "Channel:00001234(ZX_RIGHT_DUPLICATE)"); |
| } |
| |
| TEST_F(ProtoValueTest, UnionValue) { |
| std::unique_ptr<Type> type = library()->TypeFromIdentifier( |
| /*is_nullable=*/false, "test.fidlcodec.examples/U8U16UnionReserved"); |
| const UnionType* union_type = type->AsUnionType(); |
| ASSERT_NE(union_type, nullptr); |
| UnionMember* variant_u8 = union_type->union_definition().SearchMember("variant_u8"); |
| ASSERT_NE(variant_u8, nullptr); |
| PROTO_TEST(std::make_unique<UnionValue>(*variant_u8, std::make_unique<IntegerValue>(250, false)), |
| union_type, false, "{ variant_u8: uint8 = 250 }"); |
| UnionMember* variant_u16 = union_type->union_definition().SearchMember("variant_u16"); |
| ASSERT_NE(variant_u16, nullptr); |
| PROTO_TEST( |
| std::make_unique<UnionValue>(*variant_u16, std::make_unique<IntegerValue>(65000, false)), |
| union_type, false, "{ variant_u16: uint16 = 65000 }"); |
| } |
| |
| TEST_F(ProtoValueTest, StructValue) { |
| std::unique_ptr<Type> type = library()->TypeFromIdentifier( |
| /*is_nullable=*/false, "test.fidlcodec.examples/PrimitiveTypes"); |
| const StructType* struct_type = type->AsStructType(); |
| ASSERT_NE(struct_type, nullptr); |
| auto value = std::make_unique<StructValue>(struct_type->struct_definition()); |
| value->AddField("s", std::make_unique<StringValue>("The string field")); |
| value->AddField("b", std::make_unique<BoolValue>(true)); |
| value->AddField("i8", std::make_unique<IntegerValue>(5, false)); |
| value->AddField("i16", std::make_unique<IntegerValue>(5, true)); |
| value->AddField("i32", std::make_unique<IntegerValue>(100000, true)); |
| value->AddField("i64", std::make_unique<IntegerValue>(100000, false)); |
| value->AddField("u8", std::make_unique<IntegerValue>(250, false)); |
| value->AddField("u16", std::make_unique<IntegerValue>(65000, false)); |
| value->AddField("u32", std::make_unique<IntegerValue>(100000, false)); |
| value->AddField("u64", std::make_unique<IntegerValue>(100000, false)); |
| value->AddField("f32", std::make_unique<DoubleValue>(3.141593)); |
| value->AddField("f64", std::make_unique<DoubleValue>(3.141593)); |
| PROTO_TEST(std::move(value), struct_type, false, |
| "{\n" |
| " s: string = \"The string field\"\n" |
| " b: bool = true\n" |
| " i8: int8 = 5\n" |
| " i16: int16 = -5\n" |
| " i32: int32 = -100000\n" |
| " i64: int64 = 100000\n" |
| " u8: uint8 = 250\n" |
| " u16: uint16 = 65000\n" |
| " u32: uint32 = 100000\n" |
| " u64: uint64 = 100000\n" |
| " f32: float32 = 3.141593\n" |
| " f64: float64 = 3.141593\n" |
| "}"); |
| } |
| |
| TEST_F(ProtoValueTest, VectorValue) { |
| std::unique_ptr<Type> type = library()->TypeFromIdentifier( |
| /*is_nullable=*/false, "test.fidlcodec.examples/DataElement"); |
| const UnionType* union_type = type->AsUnionType(); |
| ASSERT_NE(union_type, nullptr); |
| UnionMember* uint8 = union_type->union_definition().SearchMember("uint8"); |
| ASSERT_NE(uint8, nullptr); |
| UnionMember* uint16 = union_type->union_definition().SearchMember("uint16"); |
| ASSERT_NE(uint16, nullptr); |
| UnionMember* sequence = union_type->union_definition().SearchMember("sequence"); |
| ASSERT_NE(sequence, nullptr); |
| auto vector_value = std::make_unique<VectorValue>(); |
| vector_value->AddValue( |
| std::make_unique<UnionValue>(*uint8, std::make_unique<IntegerValue>(250, false))); |
| vector_value->AddValue(std::make_unique<NullValue>()); |
| vector_value->AddValue( |
| std::make_unique<UnionValue>(*uint16, std::make_unique<IntegerValue>(65000, false))); |
| vector_value->AddValue( |
| std::make_unique<UnionValue>(*uint8, std::make_unique<IntegerValue>(50, false))); |
| PROTO_TEST(std::make_unique<UnionValue>(*sequence, std::move(vector_value)), union_type, false, |
| "{\n" |
| " sequence: vector<test.fidlcodec.examples/DataElement> = [\n" |
| " { uint8: uint8 = 250 }, null, { uint16: uint16 = 65000 }, { uint8: uint8 = 50 }\n" |
| " ]\n" |
| "}"); |
| } |
| |
| TEST_F(ProtoValueTest, TableValue) { |
| std::unique_ptr<Type> type_t = library()->TypeFromIdentifier( |
| /*is_nullable=*/false, "test.fidlcodec.examples/ValueTable"); |
| const TableType* table_type = type_t->AsTableType(); |
| ASSERT_NE(table_type, nullptr); |
| |
| std::unique_ptr<Type> type_u = library()->TypeFromIdentifier( |
| /*is_nullable=*/false, "test.fidlcodec.examples/IntStructUnion"); |
| const UnionType* union_type = type_u->AsUnionType(); |
| ASSERT_NE(union_type, nullptr); |
| UnionMember* variant_i = union_type->union_definition().SearchMember("variant_i"); |
| ASSERT_NE(variant_i, nullptr); |
| |
| std::unique_ptr<Type> type_s = library()->TypeFromIdentifier( |
| /*is_nullable=*/false, "test.fidlcodec.examples/TwoStringStruct"); |
| const StructType* struct_type = type_s->AsStructType(); |
| ASSERT_NE(struct_type, nullptr); |
| auto struct_value = std::make_unique<StructValue>(struct_type->struct_definition()); |
| struct_value->AddField("value1", std::make_unique<StringValue>("The value one field")); |
| struct_value->AddField("value2", std::make_unique<StringValue>("The value two field")); |
| |
| auto value = std::make_unique<TableValue>(table_type->table_definition()); |
| value->AddMember("first_int16", std::make_unique<IntegerValue>(500, true)); |
| value->AddMember("second_struct", std::move(struct_value)); |
| value->AddMember("third_union", std::make_unique<UnionValue>( |
| *variant_i, std::make_unique<IntegerValue>(100000, true))); |
| |
| PROTO_TEST( |
| std::move(value), table_type, false, |
| "{\n" |
| " first_int16: int16 = -500\n" |
| " second_struct: test.fidlcodec.examples/TwoStringStruct = {\n" |
| " value1: string = \"The value one field\"\n" |
| " value2: string = \"The value two field\"\n" |
| " }\n" |
| " third_union: test.fidlcodec.examples/IntStructUnion = { variant_i: int32 = -100000 }\n" |
| "}"); |
| } |
| |
| TEST_F(ProtoValueTest, FidlMessageValueStruct) { |
| fidl::IncomingMessageBuffer buffer_; |
| fidl::HLCPPIncomingMessage message = buffer_.CreateEmptyIncomingMessage(); |
| InterceptRequest<test::fidlcodec::examples::FidlCodecTestProtocol>( |
| message, [&](fidl::InterfacePtr<test::fidlcodec::examples::FidlCodecTestProtocol>& ptr) { |
| ptr->StringInt("Hello FIDL", 100); |
| }); |
| std::unique_ptr<FidlMessageValue> fidl_message = CreateFidlMessage(message); |
| PROTO_TEST(fidl_message, nullptr, false, |
| "sent request test.fidlcodec.examples/FidlCodecTestProtocol.StringInt = {\n" |
| " s: string = \"Hello FIDL\"\n" |
| " i32: int32 = 100\n" |
| "}\n"); |
| PROTO_TEST(fidl_message, nullptr, true, |
| "sent request test.fidlcodec.examples/FidlCodecTestProtocol.StringInt = {\n" |
| " s: string = \"Hello FIDL\"\n" |
| " i32: int32 = 100\n" |
| "}\n" |
| "Message: num_bytes=56 num_handles=0 " |
| "ordinal=6ef319bc9c063524(test.fidlcodec.examples/FidlCodecTestProtocol.StringInt)\n" |
| " data=\n" |
| " 0000: 00, 00, 00, 00, 02, 00, 00, 01, 24, 35, 06, 9c, bc, 19, f3, 6e, \n" |
| " 0010: 0a, 00, 00, 00, 00, 00, 00, 00, ff, ff, ff, ff, ff, ff, ff, ff, \n" |
| " 0020: 64, 00, 00, 00, 00, 00, 00, 00, 48, 65, 6c, 6c, 6f, 20, 46, 49, \n" |
| " 0030: 44, 4c, 00, 00, 00, 00, 00, 00\n"); |
| } |
| |
| TEST_F(ProtoValueTest, FidlMessageValueTable) { |
| fidl::IncomingMessageBuffer buffer_; |
| fidl::HLCPPIncomingMessage message = buffer_.CreateEmptyIncomingMessage(); |
| test::fidlcodec::examples::FidlCodecTestProtocolStringIntTableRequest payload; |
| payload.set_s("Hello FIDL"); |
| payload.set_i32(200); |
| InterceptRequest<test::fidlcodec::examples::FidlCodecTestProtocol>( |
| message, [&](fidl::InterfacePtr<test::fidlcodec::examples::FidlCodecTestProtocol>& ptr) { |
| ptr->StringIntTable(std::move(payload)); |
| }); |
| std::unique_ptr<FidlMessageValue> fidl_message = CreateFidlMessage(message); |
| PROTO_TEST(fidl_message, nullptr, false, |
| "sent request test.fidlcodec.examples/FidlCodecTestProtocol.StringIntTable = {\n" |
| " s: string = \"Hello FIDL\"\n" |
| " i32: int32 = 200\n" |
| "}\n"); |
| PROTO_TEST(fidl_message, nullptr, true, |
| "sent request test.fidlcodec.examples/FidlCodecTestProtocol.StringIntTable = {\n" |
| " s: string = \"Hello FIDL\"\n" |
| " i32: int32 = 200\n" |
| "}\n" |
| "Message: num_bytes=80 num_handles=0 ordinal=" |
| "5f61e4e5cb978883(test.fidlcodec.examples/FidlCodecTestProtocol.StringIntTable)\n" |
| " data=\n" |
| " 0000: 00, 00, 00, 00, 02, 00, 00, 01, 83, 88, 97, cb, e5, e4, 61, 5f, \n" |
| " 0010: 02, 00, 00, 00, 00, 00, 00, 00, ff, ff, ff, ff, ff, ff, ff, ff, \n" |
| " 0020: 20, 00, 00, 00, 00, 00, 00, 00, c8, 00, 00, 00, 00, 00, 01, 00, \n" |
| " 0030: 0a, 00, 00, 00, 00, 00, 00, 00, ff, ff, ff, ff, ff, ff, ff, ff, \n" |
| " 0040: 48, 65, 6c, 6c, 6f, 20, 46, 49, 44, 4c, 00, 00, 00, 00, 00, 00\n"); |
| } |
| |
| TEST_F(ProtoValueTest, FidlMessageValueUnion) { |
| fidl::IncomingMessageBuffer buffer_; |
| fidl::HLCPPIncomingMessage message = buffer_.CreateEmptyIncomingMessage(); |
| InterceptRequest<test::fidlcodec::examples::FidlCodecTestProtocol>( |
| message, [&](fidl::InterfacePtr<test::fidlcodec::examples::FidlCodecTestProtocol>& ptr) { |
| ptr->StringIntUnion( |
| test::fidlcodec::examples::FidlCodecTestProtocolStringIntUnionRequest::WithS( |
| "Hello FIDL")); |
| }); |
| std::unique_ptr<FidlMessageValue> fidl_message = CreateFidlMessage(message); |
| PROTO_TEST(fidl_message, nullptr, false, |
| "sent request test.fidlcodec.examples/FidlCodecTestProtocol.StringIntUnion = {\n" |
| " s: string = \"Hello FIDL\"\n" |
| "}\n"); |
| PROTO_TEST(fidl_message, nullptr, true, |
| "sent request test.fidlcodec.examples/FidlCodecTestProtocol.StringIntUnion = {\n" |
| " s: string = \"Hello FIDL\"\n" |
| "}\n" |
| "Message: num_bytes=64 num_handles=0 ordinal=" |
| "1eabd1794ab9fd9d(test.fidlcodec.examples/FidlCodecTestProtocol.StringIntUnion)\n" |
| " data=\n" |
| " 0000: 00, 00, 00, 00, 02, 00, 00, 01, 9d, fd, b9, 4a, 79, d1, ab, 1e, \n" |
| " 0010: 01, 00, 00, 00, 00, 00, 00, 00, 20, 00, 00, 00, 00, 00, 00, 00, \n" |
| " 0020: 0a, 00, 00, 00, 00, 00, 00, 00, ff, ff, ff, ff, ff, ff, ff, ff, \n" |
| " 0030: 48, 65, 6c, 6c, 6f, 20, 46, 49, 44, 4c, 00, 00, 00, 00, 00, 00\n"); |
| } |
| |
| TEST_F(ProtoValueTest, ActualAndRequestedValue) { |
| ActualAndRequestedType type; |
| auto value = std::make_unique<ActualAndRequestedValue>(10, 20); |
| PROTO_TEST(std::move(value), &type, false, "10/20"); |
| } |
| |
| } // namespace fidl_codec |
