| // Copyright 2019 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 "src/lib/fidl_codec/wire_parser.h" |
| |
| #include <fuchsia/sys/cpp/fidl.h> |
| #include <lib/async-loop/cpp/loop.h> |
| #include <lib/async-loop/default.h> |
| #include <lib/fidl/cpp/test/frobinator_impl.h> |
| #include <zircon/rights.h> |
| |
| #include <iostream> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| #include <rapidjson/stringbuffer.h> |
| #include <rapidjson/writer.h> |
| #include <test/fidlcodec/examples/cpp/fidl.h> |
| |
| #include "src/lib/fidl_codec/encoder.h" |
| #include "src/lib/fidl_codec/fidl_codec_test.h" |
| #include "src/lib/fidl_codec/library_loader.h" |
| #include "src/lib/fidl_codec/library_loader_test_data.h" |
| #include "src/lib/fidl_codec/logger.h" |
| #include "src/lib/fidl_codec/message_decoder.h" |
| #include "src/lib/fidl_codec/wire_object.h" |
| |
| namespace fidl_codec { |
| |
| constexpr uint32_t kUninitialized = 0xdeadbeef; |
| constexpr float kFloatValue = 0.25; |
| constexpr double kDoubleValue = 9007199254740992.0; |
| constexpr int kUint32Precision = 8; |
| |
| const Colors FakeColors(/*new_reset=*/"#rst#", /*new_red=*/"#red#", /*new_green=*/"#gre#", |
| /*new_blue=*/"#blu#", /*new_white_on_magenta=*/"#wom#", |
| /*new_yellow_background=*/"#yeb#"); |
| |
| AsyncLoopForTest::AsyncLoopForTest() : impl_(std::make_unique<AsyncLoopForTestImpl>()) {} |
| |
| AsyncLoopForTest::~AsyncLoopForTest() = default; |
| |
| zx_status_t AsyncLoopForTest::RunUntilIdle() { return impl_->loop()->RunUntilIdle(); } |
| |
| zx_status_t AsyncLoopForTest::Run() { return impl_->loop()->Run(); } |
| |
| async_dispatcher_t* AsyncLoopForTest::dispatcher() { return impl_->loop()->dispatcher(); } |
| |
| LibraryLoader* InitLoader() { |
| LibraryReadError err; |
| auto loader = new LibraryLoader(); |
| fidl_codec_test::FidlcodecExamples examples; |
| for (const auto& element : examples.map()) { |
| loader->AddContent(element.second, &err); |
| } |
| return loader; |
| } |
| |
| LibraryLoader* GetLoader() { |
| static LibraryLoader* loader = InitLoader(); |
| return loader; |
| } |
| |
| class WireParserTest : public ::testing::Test { |
| protected: |
| void SetUp() override { |
| loader_ = GetLoader(); |
| ASSERT_NE(loader_, nullptr); |
| } |
| |
| LibraryLoader* loader() const { return loader_; } |
| |
| private: |
| LibraryLoader* loader_; |
| }; |
| |
| TEST_F(WireParserTest, ParseSingleString) { |
| fidl::IncomingMessageBuffer buffer; |
| fidl::HLCPPIncomingMessage message = buffer.CreateEmptyIncomingMessage(); |
| |
| InterceptRequest<fidl::test::frobinator::Frobinator>( |
| message, [](fidl::InterfacePtr<fidl::test::frobinator::Frobinator>& ptr) { |
| ptr->Grob("one", [](const fidl::StringPtr& /*value*/) { FAIL(); }); |
| }); |
| |
| fidl_message_header_t header = message.header(); |
| |
| const std::vector<const InterfaceMethod*>* methods = loader()->GetByOrdinal(header.ordinal); |
| ASSERT_NE(methods, nullptr); |
| ASSERT_TRUE(!methods->empty()); |
| const InterfaceMethod* method = (*methods)[0]; |
| ASSERT_NE(method, nullptr); |
| ASSERT_EQ("Grob", method->name()); |
| |
| zx_handle_disposition_t* handle_dispositions = nullptr; |
| if (message.handles().size() > 0) { |
| handle_dispositions = new zx_handle_disposition_t[message.handles().size()]; |
| for (uint32_t i = 0; i < message.handles().size(); ++i) { |
| handle_dispositions[i].operation = fidl_codec::kNoHandleDisposition; |
| handle_dispositions[i].handle = message.handles().data()[i].handle; |
| handle_dispositions[i].type = ZX_OBJ_TYPE_NONE; |
| handle_dispositions[i].rights = 0; |
| handle_dispositions[i].result = ZX_OK; |
| } |
| } |
| |
| std::unique_ptr<fidl_codec::StructValue> decoded_request; |
| std::stringstream error_stream; |
| fidl_codec::DecodeRequest(method, message.bytes().data(), message.bytes().size(), |
| handle_dispositions, message.handles().size(), &decoded_request, |
| error_stream); |
| rapidjson::Document actual; |
| if (decoded_request != nullptr) { |
| decoded_request->ExtractJson(actual.GetAllocator(), actual); |
| } |
| |
| rapidjson::Document expected; |
| expected.Parse(R"JSON({"value":"one"})JSON"); |
| ASSERT_EQ(expected, actual); |
| |
| delete[] handle_dispositions; |
| } |
| |
| // This is a general-purpose macro for calling InterceptRequest and checking its |
| // results. It can be generalized to a wide variety of types (and is, below). |
| // It checks for successful parsing, as well as failure when parsing truncated |
| // values. |
| // |_iface| is the interface method name on examples::FidlCodecTestInterface |
| // (TODO: generalize which interface to use) |
| // |_json_value| is the expected JSON representation of the message. |
| // |_pretty_print| is the expected pretty print of the message. |
| // The remaining parameters are the parameters to |_iface| to generate the |
| // message. |
| // If patched_offset is not -1, we patch the encoded buffer with patched_value. |
| // This is useful when we want to test that we can decode junk data. |
| // If num_bytes is not -1, instead of decoding the full buffer, we only decode num_bytes of buffer. |
| // This is helpful when we want to test display of incorect data. |
| #define TEST_DECODE_WIRE_BODY_COMMON(_iface, patched_offset, patched_value, _json_value, \ |
| _pretty_print, num_bytes, ...) \ |
| do { \ |
| fidl::IncomingMessageBuffer buffer; \ |
| fidl::HLCPPIncomingMessage message = buffer.CreateEmptyIncomingMessage(); \ |
| using test::fidlcodec::examples::FidlCodecTestInterface; \ |
| InterceptRequest<FidlCodecTestInterface>( \ |
| message, \ |
| [&](fidl::InterfacePtr<FidlCodecTestInterface>& ptr) { ptr->_iface(__VA_ARGS__); }); \ |
| \ |
| fidl_message_header_t header = message.header(); \ |
| \ |
| const std::vector<const InterfaceMethod*>* methods = loader()->GetByOrdinal(header.ordinal); \ |
| ASSERT_NE(methods, nullptr); \ |
| ASSERT_TRUE(!methods->empty()); \ |
| const InterfaceMethod* method = (*methods)[0]; \ |
| ASSERT_NE(method, nullptr); \ |
| ASSERT_EQ(#_iface, method->name()); \ |
| \ |
| zx_handle_disposition_t* handle_dispositions = nullptr; \ |
| if (message.handles().size() > 0) { \ |
| handle_dispositions = new zx_handle_disposition_t[message.handles().size()]; \ |
| for (uint32_t i = 0; i < message.handles().size(); ++i) { \ |
| handle_dispositions[i].operation = fidl_codec::kNoHandleDisposition; \ |
| /* Do not keep the returned value (it can be random). Instead use a well known value */ \ |
| handle_dispositions[i].handle = 0x100 + i; \ |
| handle_dispositions[i].type = ZX_OBJ_TYPE_CHANNEL; \ |
| handle_dispositions[i].rights = ZX_DEFAULT_CHANNEL_RIGHTS; \ |
| handle_dispositions[i].result = ZX_OK; \ |
| } \ |
| } \ |
| if (patched_offset != -1) { \ |
| *(reinterpret_cast<uint64_t*>(message.bytes().data() + patched_offset)) = patched_value; \ |
| } \ |
| \ |
| std::stringstream error_stream; \ |
| MessageDecoder decoder(message.bytes().data(), \ |
| (num_bytes == -1) ? message.bytes().size() : num_bytes, \ |
| handle_dispositions, message.handles().size(), error_stream); \ |
| std::unique_ptr<StructValue> object = decoder.DecodeMessage(*method->request()); \ |
| if ((num_bytes == -1) && (patched_offset == -1)) { \ |
| std::cerr << error_stream.str(); \ |
| ASSERT_FALSE(decoder.HasError()) << "Could not decode message"; \ |
| } \ |
| rapidjson::Document actual; \ |
| if (object != nullptr) { \ |
| object->ExtractJson(actual.GetAllocator(), actual); \ |
| } \ |
| rapidjson::StringBuffer actual_string; \ |
| rapidjson::Writer<rapidjson::StringBuffer> actual_w(actual_string); \ |
| actual.Accept(actual_w); \ |
| \ |
| rapidjson::Document expected; \ |
| std::string expected_source = _json_value; \ |
| expected.Parse(expected_source.c_str()); \ |
| rapidjson::StringBuffer expected_string; \ |
| rapidjson::Writer<rapidjson::StringBuffer> expected_w(expected_string); \ |
| expected.Accept(expected_w); \ |
| \ |
| ASSERT_EQ(expected, actual) << "expected = " << expected_string.GetString() << " (" \ |
| << expected_source << ")" \ |
| << " and actual = " << actual_string.GetString(); \ |
| \ |
| std::stringstream result; \ |
| if (object != nullptr) { \ |
| PrettyPrinter printer(result, FakeColors, false, "", 80, /*header_on_every_line=*/false); \ |
| object->PrettyPrint(nullptr, printer); \ |
| } \ |
| ASSERT_EQ(result.str(), _pretty_print) \ |
| << "expected = " << _pretty_print << " actual = " << result.str(); \ |
| \ |
| for (uint32_t actual = 0; actual < message.bytes().actual(); ++actual) { \ |
| std::stringstream error_stream; \ |
| MessageDecoder decoder(message.bytes().data(), actual, handle_dispositions, \ |
| message.handles().size(), error_stream); \ |
| std::unique_ptr<StructValue> object = decoder.DecodeMessage(*method->request()); \ |
| ASSERT_TRUE(decoder.HasError()) << "expect decoder error for buffer size " << actual \ |
| << " instead of " << message.bytes().actual(); \ |
| } \ |
| \ |
| for (uint32_t actual = 0; message.handles().actual() > actual; actual++) { \ |
| std::stringstream error_stream; \ |
| MessageDecoder decoder(message.bytes().data(), message.bytes().size(), handle_dispositions, \ |
| actual, error_stream); \ |
| std::unique_ptr<StructValue> object = decoder.DecodeMessage(*method->request()); \ |
| ASSERT_TRUE(decoder.HasError()) << "expect decoder error for handle size " << actual \ |
| << " instead of " << message.handles().actual(); \ |
| } \ |
| \ |
| if ((num_bytes == -1) && (patched_offset == -1)) { \ |
| auto encode_result = Encoder::EncodeMessage(header.txid, header.ordinal, header.flags, \ |
| header.magic_number, *object.get()); \ |
| ASSERT_THAT(encode_result.bytes, ::testing::ElementsAreArray(message.bytes())); \ |
| ASSERT_EQ(message.handles().size(), encode_result.handles.size()); \ |
| \ |
| for (uint32_t i = 0; i < message.handles().size(); ++i) { \ |
| EXPECT_EQ(0x100 + i, encode_result.handles[i].handle); \ |
| } \ |
| } \ |
| \ |
| delete[] handle_dispositions; \ |
| } while (0) |
| |
| #define TEST_DECODE_WIRE_BODY(_iface, _json_value, _pretty_print, ...) \ |
| TEST_DECODE_WIRE_BODY_COMMON(_iface, -1, 0, _json_value, _pretty_print, -1, __VA_ARGS__) |
| |
| #define TEST_DECODE_WIRE_BODY_BAD(_iface, _json_value, _pretty_print, num_bytes, ...) \ |
| TEST_DECODE_WIRE_BODY_COMMON(_iface, -1, 0, _json_value, _pretty_print, num_bytes, __VA_ARGS__) |
| |
| // This is a convenience wrapper for calling TEST_DECODE_WIRE_BODY that simply |
| // executes the code in a test. |
| // |_testname| is the name of the test (prepended by Parse in the output) |
| // |_iface| is the interface method name on examples::FidlCodecTestInterface |
| // (TODO: generalize which interface to use) |
| // |_json_value| is the expected JSON representation of the message. |
| // |_pretty_print| is the expected pretty print of the message. |
| // The remaining parameters are the parameters to |_iface| to generate the |
| // message. |
| #define TEST_DECODE_WIRE(_testname, _iface, _json_value, _pretty_print, ...) \ |
| TEST_F(WireParserTest, Parse##_testname) { \ |
| TEST_DECODE_WIRE_BODY(_iface, _json_value, _pretty_print, __VA_ARGS__); \ |
| } |
| |
| #define TEST_DECODE_WIRE_PATCHED(_testname, _iface, patched_offset, patched_value, _json_value, \ |
| _pretty_print, ...) \ |
| TEST_F(WireParserTest, Parse##_testname) { \ |
| TEST_DECODE_WIRE_BODY_COMMON(_iface, patched_offset, patched_value, _json_value, \ |
| _pretty_print, -1, __VA_ARGS__); \ |
| } |
| |
| // Scalar Tests |
| |
| namespace { |
| |
| template <class T> |
| std::string ValueToJson(const std::string& key, T value) { |
| return "\"" + key + "\":\"" + std::to_string(value) + "\""; |
| } |
| |
| template <> |
| std::string ValueToJson(const std::string& key, bool value) { |
| return "\"" + key + "\":\"" + (value ? "true" : "false") + "\""; |
| } |
| |
| template <> |
| std::string ValueToJson(const std::string& key, const char* value) { |
| return "\"" + key + "\":\"" + value + "\""; |
| } |
| |
| template <> |
| std::string ValueToJson(const std::string& key, std::string value) { |
| return "\"" + key + "\":\"" + value + "\""; |
| } |
| |
| template <class T> |
| std::string SingleToJson(const std::string& key, T value) { |
| return "{ " + ValueToJson(key, value) + " }"; |
| } |
| |
| template <class T> |
| std::string ValueToPretty(const std::string& key, const std::string& type, T value) { |
| return key + ": #gre#" + type + "#rst# = #blu#" + std::to_string(value) + "#rst#"; |
| } |
| |
| template <> |
| std::string ValueToPretty(const std::string& key, const std::string& type, bool value) { |
| return key + ": #gre#" + type + "#rst# = #blu#" + (value ? "true" : "false") + "#rst#"; |
| } |
| |
| template <> |
| std::string ValueToPretty(const std::string& key, const std::string& type, const char* value) { |
| return key + ": #gre#" + type + "#rst# = #red#\"" + value + "\"#rst#"; |
| } |
| |
| template <> |
| std::string ValueToPretty(const std::string& key, const std::string& type, std::string value) { |
| return key + ": #gre#" + type + "#rst# = #red#\"" + value + "\"#rst#"; |
| } |
| |
| std::string HandleToJson(const std::string& key, uint32_t value) { |
| std::stringstream ss; |
| ss << std::hex << std::setfill('0') << std::setw(kUint32Precision) << value << std::dec |
| << std::setw(0); |
| return "\"" + key + "\":\"Channel:" + ss.str() + |
| "(ZX_RIGHT_TRANSFER | ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_SIGNAL | " + |
| "ZX_RIGHT_SIGNAL_PEER | ZX_RIGHT_WAIT | ZX_RIGHT_INSPECT)\""; |
| } |
| |
| std::string HandleToPretty(const std::string& key, uint32_t value) { |
| std::stringstream ss; |
| ss << std::hex << std::setfill('0') << std::setw(kUint32Precision) << value << std::dec |
| << std::setw(0); |
| return key + ": #gre#handle#rst# = #red#Channel:" + ss.str() + "#rst#(#blu#" + |
| "ZX_RIGHT_TRANSFER | ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_SIGNAL | " + |
| "ZX_RIGHT_SIGNAL_PEER | ZX_RIGHT_WAIT | ZX_RIGHT_INSPECT" + "#rst#)"; |
| } |
| |
| template <class T> |
| std::string SingleToPretty(const std::string& key, const std::string& type, T value) { |
| return "{ " + ValueToPretty(key, type, value) + " }"; |
| } |
| |
| } // namespace |
| |
| #define TEST_SINGLE(_testname, _iface, _key, _type, _value) \ |
| TEST_DECODE_WIRE(_testname, _iface, SingleToJson(#_key, _value), \ |
| SingleToPretty(#_key, #_type, _value), _value) |
| |
| TEST_DECODE_WIRE(Empty, Empty, "{}", "{}") |
| |
| TEST_SINGLE(String, String, s, string, "Hello World!") |
| |
| TEST_DECODE_WIRE_PATCHED(StringBadSize, String, 16, 100, "{\"s\":\"(invalid)\"}", |
| "{ s: #gre#string#rst# = #red#invalid#rst# }", "Hello World!") |
| |
| TEST_DECODE_WIRE_PATCHED(StringHugeSize, String, 16, ULLONG_MAX, "{\"s\":\"(invalid)\"}", |
| "{ s: #gre#string#rst# = #red#invalid#rst# }", "Hello World!") |
| |
| TEST_SINGLE(BoolTrue, Bool, b, bool, true) |
| TEST_SINGLE(BoolFalse, Bool, b, bool, false) |
| |
| TEST_SINGLE(Int8Min, Int8, i8, int8, std::numeric_limits<int8_t>::min()) |
| TEST_SINGLE(Int16Min, Int16, i16, int16, std::numeric_limits<int16_t>::min()) |
| TEST_SINGLE(Int32Min, Int32, i32, int32, std::numeric_limits<int32_t>::min()) |
| TEST_SINGLE(Int64Min, Int64, i64, int64, std::numeric_limits<int64_t>::min()) |
| TEST_SINGLE(Int8Max, Int8, i8, int8, std::numeric_limits<int8_t>::max()) |
| TEST_SINGLE(Int16Max, Int16, i16, int16, std::numeric_limits<int16_t>::max()) |
| TEST_SINGLE(Int32Max, Int32, i32, int32, std::numeric_limits<int32_t>::max()) |
| TEST_SINGLE(Int64Max, Int64, i64, int64, std::numeric_limits<int64_t>::max()) |
| |
| TEST_SINGLE(Uint8Min, Uint8, ui8, uint8, std::numeric_limits<uint8_t>::min()) |
| TEST_SINGLE(Uint16Min, Uint16, ui16, uint16, std::numeric_limits<uint16_t>::min()) |
| TEST_SINGLE(Uint32Min, Uint32, ui32, uint32, std::numeric_limits<uint32_t>::min()) |
| TEST_SINGLE(Uint64Min, Uint64, ui64, uint64, std::numeric_limits<uint64_t>::min()) |
| TEST_SINGLE(Uint8Max, Uint8, ui8, uint8, std::numeric_limits<uint8_t>::max()) |
| TEST_SINGLE(Uint16Max, Uint16, ui16, uint16, std::numeric_limits<uint16_t>::max()) |
| TEST_SINGLE(Uint32Max, Uint32, ui32, uint32, std::numeric_limits<uint32_t>::max()) |
| TEST_SINGLE(Uint64Max, Uint64, ui64, uint64, std::numeric_limits<uint64_t>::max()) |
| |
| TEST_SINGLE(Float32, Float32, f32, float32, kFloatValue) |
| TEST_SINGLE(Float64, Float64, f64, float64, kDoubleValue) |
| |
| TEST_DECODE_WIRE(TwoTuple, Complex, R"({"real":"1", "imaginary":"2"})", |
| "{ " + ValueToPretty("real", "int32", 1) + ", " + |
| ValueToPretty("imaginary", "int32", 2) + " }", |
| 1, 2); |
| |
| TEST_DECODE_WIRE(StringInt, StringInt, R"({"s":"groucho", "i32":"4"})", |
| "{ " + ValueToPretty("s", "string", "groucho") + ", " + |
| ValueToPretty("i32", "int32", 4) + " }", |
| "groucho", 4) |
| |
| // Vector / Array Tests |
| |
| namespace { |
| std::array<int32_t, 1> one_param_array = {1}; |
| std::array<int32_t, 2> two_param_array = {1, 2}; |
| |
| std::vector<int32_t> one_param_vector = {1}; |
| std::vector<int32_t> two_param_vector = {1, 2}; |
| |
| } // namespace |
| |
| TEST_DECODE_WIRE(Array1, Array1, R"({"b_1":["1"]})", |
| "{ b_1: array<#gre#int32#rst#> = [ #blu#1#rst# ] }", one_param_array); |
| |
| TEST_DECODE_WIRE(Array2, Array2, R"({"b_2":["1", "2"]})", |
| "{ b_2: array<#gre#int32#rst#> = [ #blu#1#rst#, #blu#2#rst# ] }", two_param_array); |
| |
| TEST_DECODE_WIRE(NullVector, Vector, R"({"v_1": null})", |
| "{ v_1: vector<#gre#int32#rst#> = #red#null#rst# }", nullptr) |
| |
| TEST_DECODE_WIRE(VectorOneElt, Vector, R"({"v_1":["1"]})", |
| "{ v_1: vector<#gre#int32#rst#> = [ #blu#1#rst# ] }", one_param_vector); |
| |
| TEST_DECODE_WIRE(VectorTwoElt, Vector, R"({"v_1":["1", "2"]})", |
| "{ v_1: vector<#gre#int32#rst#> = [ #blu#1#rst#, #blu#2#rst# ] }", |
| two_param_vector); |
| |
| std::array<std::string, 2> TwoStringArrayFromVals(const std::string& v1, const std::string& v2) { |
| std::array<std::string, 2> brother_array; |
| brother_array[0] = v1; |
| brother_array[1] = v2; |
| return brother_array; |
| } |
| |
| TEST_DECODE_WIRE(TwoStringArrayInt, TwoStringArrayInt, R"({"arr":["harpo","chico"], "i32":"1"})", |
| R"({ arr: array<#gre#string#rst#> = [ #red#"harpo"#rst#, #red#"chico"#rst# ], )" + |
| ValueToPretty("i32", "int32", 1) + " }", |
| TwoStringArrayFromVals("harpo", "chico"), 1) |
| |
| namespace { |
| |
| std::vector<std::string> TwoStringVectorFromVals(const std::string& v1, const std::string& v2) { |
| return std::vector<std::string>({v1, v2}); |
| } |
| |
| std::vector<uint8_t> VectorUint8() { |
| const int kItemCount = 40; |
| std::vector<std::uint8_t> result; |
| for (int i = 0; i <= kItemCount; ++i) { |
| result.push_back(i); |
| } |
| return result; |
| } |
| |
| std::vector<uint8_t> VectorUint8(const char* text) { |
| std::vector<std::uint8_t> result; |
| while (*text != 0) { |
| result.push_back(*text++); |
| } |
| return result; |
| } |
| |
| std::vector<uint32_t> VectorUint32() { |
| const int kItemCount = 25; |
| std::vector<std::uint32_t> result; |
| for (int i = 0; i <= kItemCount; ++i) { |
| const int kShift = 16; |
| result.push_back(i + ((i & 1) << kShift)); |
| } |
| return result; |
| } |
| |
| } // namespace |
| |
| TEST_DECODE_WIRE(TwoStringVectorInt, TwoStringVectorInt, R"({"vec":["harpo", "chico"], "i32":"1"})", |
| R"({ vec: vector<#gre#string#rst#> = [ #red#"harpo"#rst#, #red#"chico"#rst# ], )" + |
| ValueToPretty("i32", "int32", 1) + " }", |
| TwoStringVectorFromVals("harpo", "chico"), 1) |
| |
| TEST_DECODE_WIRE(TwoStringVectors, TwoStringVectors, |
| R"({"v_1":["harpo","chico"],"v_2":["groucho","zeppo"]})", |
| "{\n v_1: vector<#gre#string#rst#> = " |
| R"([ #red#"harpo"#rst#, #red#"chico"#rst# ])" |
| "\n v_2: vector<#gre#string#rst#> = " |
| R"([ #red#"groucho"#rst#, #red#"zeppo"#rst# ])" |
| "\n}", |
| TwoStringVectorFromVals("harpo", "chico"), |
| TwoStringVectorFromVals("groucho", "zeppo")) |
| |
| TEST_DECODE_WIRE( |
| VectorUint8, VectorUint8, |
| R"({"v":["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29","30","31","32","33","34","35","36","37","38","39","40"]})", |
| "{\n" |
| " v: vector<#gre#uint8#rst#> = [\n" |
| " #blu#0#rst#, #blu#1#rst#, #blu#2#rst#, #blu#3#rst#, #blu#4#rst#, #blu#5#rst#, " |
| "#blu#6#rst#, #blu#7#rst#, #blu#8#rst#, #blu#9#rst#, #blu#10#rst#, #blu#11#rst#, #blu#12#rst#, " |
| "#blu#13#rst#, #blu#14#rst#, #blu#15#rst#, #blu#16#rst#, #blu#17#rst#, #blu#18#rst#, " |
| "#blu#19#rst#, #blu#20#rst#\n" |
| " #blu#21#rst#, #blu#22#rst#, #blu#23#rst#, #blu#24#rst#, #blu#25#rst#, #blu#26#rst#, " |
| "#blu#27#rst#, #blu#28#rst#, #blu#29#rst#, #blu#30#rst#, #blu#31#rst#, #blu#32#rst#, " |
| "#blu#33#rst#, #blu#34#rst#, #blu#35#rst#, #blu#36#rst#, #blu#37#rst#, #blu#38#rst#, " |
| "#blu#39#rst#\n" |
| " #blu#40#rst#\n" |
| " ]\n" |
| "}", |
| VectorUint8()) |
| |
| TEST_DECODE_WIRE( |
| VectorUint8String, VectorUint8, |
| R"({"v":["72","101","108","108","111","32","116","101","115","116","105","110","103","32","119","111","114","108","100","33"]})", |
| "{ v: vector<#gre#uint8#rst#> = #red#\"Hello testing world!\"#rst# }", |
| VectorUint8("Hello testing world!")) |
| |
| TEST_DECODE_WIRE( |
| VectorUint8MultilineString, VectorUint8, |
| R"({"v":["72","101","108","108","111","32","116","101","115","116","105","110","103","32","119","111","114","108","100","33","10","72","111","119","32","97","114","101","32","121","111","117","32","116","111","100","97","121", "63","10","73","39","109","32","116","101","115","116","105","110","103","32","102","105","100","108","95","99","111","100","101","99","46"]})", |
| "{\n" |
| " v: vector<#gre#uint8#rst#> = [\n" |
| " #red#Hello testing world!\n" |
| " How are you today?\n" |
| " I'm testing fidl_codec.#rst#\n" |
| " ]\n" |
| "}", |
| VectorUint8("Hello testing world!\nHow are you today?\nI'm testing fidl_codec.")) |
| |
| TEST_DECODE_WIRE( |
| VectorUint32, VectorUint32, |
| R"({"v":["0","65537","2","65539","4","65541","6","65543","8","65545","10","65547","12","65549","14","65551","16","65553","18","65555","20","65557","22","65559","24","65561"]})", |
| "{\n" |
| " v: vector<#gre#uint32#rst#> = [\n" |
| " #blu#0#rst#, #blu#65537#rst#, #blu#2#rst#, #blu#65539#rst#, #blu#4#rst#, #blu#65541#rst#, " |
| "#blu#6#rst#, #blu#65543#rst#, #blu#8#rst#, #blu#65545#rst#, #blu#10#rst#, #blu#65547#rst#, " |
| "#blu#12#rst#, #blu#65549#rst#, #blu#14#rst#\n" |
| " #blu#65551#rst#, #blu#16#rst#, #blu#65553#rst#, #blu#18#rst#, #blu#65555#rst#, " |
| "#blu#20#rst#, #blu#65557#rst#, #blu#22#rst#, #blu#65559#rst#, #blu#24#rst#, #blu#65561#rst#\n" |
| " ]\n" |
| "}", |
| VectorUint32()) |
| |
| TEST_DECODE_WIRE_PATCHED( |
| VectorUint32BadSize, VectorUint32, 16, 100000, |
| R"({"v":["0","65537","2","65539","4","65541","6","65543","8","65545","10","65547","12","65549","14","65551","16","65553","18","65555","20","65557","22","65559","24","65561"]})", |
| "{\n" |
| " v: vector<#gre#uint32#rst#> = [\n" |
| " #blu#0#rst#, #blu#65537#rst#, #blu#2#rst#, #blu#65539#rst#, #blu#4#rst#, #blu#65541#rst#, " |
| "#blu#6#rst#, #blu#65543#rst#, #blu#8#rst#, #blu#65545#rst#, #blu#10#rst#, #blu#65547#rst#, " |
| "#blu#12#rst#, #blu#65549#rst#, #blu#14#rst#\n" |
| " #blu#65551#rst#, #blu#16#rst#, #blu#65553#rst#, #blu#18#rst#, #blu#65555#rst#, " |
| "#blu#20#rst#, #blu#65557#rst#, #blu#22#rst#, #blu#65559#rst#, #blu#24#rst#, #blu#65561#rst#\n" |
| " ]\n" |
| "}", |
| VectorUint32()) |
| |
| // Struct Tests |
| |
| namespace { |
| |
| class StructSupport { |
| public: |
| StructSupport() { |
| pt.s = "Hello"; |
| pt.b = true; |
| pt.i8 = std::numeric_limits<int8_t>::min(); |
| pt.i16 = std::numeric_limits<int16_t>::min(); |
| pt.i32 = std::numeric_limits<int32_t>::min(); |
| pt.i64 = std::numeric_limits<int64_t>::min(); |
| pt.u8 = std::numeric_limits<uint8_t>::max(); |
| pt.u16 = std::numeric_limits<uint16_t>::max(); |
| pt.u32 = std::numeric_limits<uint32_t>::max(); |
| pt.u64 = std::numeric_limits<uint64_t>::max(); |
| pt.f32 = kFloatValue; |
| pt.f64 = kDoubleValue; |
| } |
| |
| std::string GetJson() { |
| std::ostringstream es; |
| es << R"({"p":{)" << ValueToJson("s", pt.s) << "," << ValueToJson("b", pt.b) << "," |
| << ValueToJson("i8", pt.i8) << "," << ValueToJson("i16", pt.i16) << "," |
| << ValueToJson("i32", pt.i32) << "," << ValueToJson("i64", pt.i64) << "," |
| << ValueToJson("u8", pt.u8) << "," << ValueToJson("u16", pt.u16) << "," |
| << ValueToJson("u32", pt.u32) << "," << ValueToJson("u64", pt.u64) << "," |
| << ValueToJson("f32", pt.f32) << "," << ValueToJson("f64", pt.f64) << "}}"; |
| return es.str(); |
| } |
| std::string GetPretty() { |
| std::ostringstream es; |
| es << "{\n" |
| << " p: #gre#test.fidlcodec.examples/PrimitiveTypes#rst# = {\n" |
| << " " << ValueToPretty("s", "string", pt.s) << "\n" |
| << " " << ValueToPretty("b", "bool", pt.b) << "\n" |
| << " " << ValueToPretty("i8", "int8", pt.i8) << "\n" |
| << " " << ValueToPretty("i16", "int16", pt.i16) << "\n" |
| << " " << ValueToPretty("i32", "int32", pt.i32) << "\n" |
| << " " << ValueToPretty("i64", "int64", pt.i64) << "\n" |
| << " " << ValueToPretty("u8", "uint8", pt.u8) << "\n" |
| << " " << ValueToPretty("u16", "uint16", pt.u16) << "\n" |
| << " " << ValueToPretty("u32", "uint32", pt.u32) << "\n" |
| << " " << ValueToPretty("u64", "uint64", pt.u64) << "\n" |
| << " " << ValueToPretty("f32", "float32", pt.f32) << "\n" |
| << " " << ValueToPretty("f64", "float64", pt.f64) << "\n" |
| << " }\n" |
| << "}"; |
| return es.str(); |
| } |
| |
| test::fidlcodec::examples::PrimitiveTypes pt; |
| }; |
| |
| } // namespace |
| |
| TEST_F(WireParserTest, ParseStruct) { |
| StructSupport sd; |
| TEST_DECODE_WIRE_BODY(Struct, sd.GetJson(), sd.GetPretty(), sd.pt); |
| } |
| |
| TEST_F(WireParserTest, BadBoolStruct) { |
| test::fidlcodec::examples::BoolStructType s; |
| TEST_DECODE_WIRE_BODY_BAD(BoolStruct, "{\"s\":{\"b\":\"(invalid)\"}}", |
| "{ s: #gre#test.fidlcodec.examples/BoolStructType#rst# = " |
| "{ b: #gre#bool#rst# = #red#invalid#rst# } }", |
| 16, s); |
| } |
| |
| TEST_DECODE_WIRE(NullableStruct, NullableStruct, R"({"p":null})", |
| "{ p: #gre#test.fidlcodec.examples/PrimitiveTypes#rst# = #red#null#rst# }", |
| nullptr); |
| |
| TEST_DECODE_WIRE(NullableStructAndInt, NullableStructAndInt, R"({"p":null, "i":"1"})", |
| "{ p: #gre#test.fidlcodec.examples/PrimitiveTypes#rst# = " |
| "#red#null#rst#, i: #gre#int32#rst# = #blu#1#rst# }", |
| nullptr, 1); |
| |
| namespace { |
| |
| std::array<std::unique_ptr<test::fidlcodec::examples::TwoStringStruct>, 3> GetArrayNullableStruct( |
| const std::string& v1, const std::string& v2, const std::string& v3, const std::string& v4) { |
| std::array<std::unique_ptr<test::fidlcodec::examples::TwoStringStruct>, 3> a; |
| a[0] = std::make_unique<test::fidlcodec::examples::TwoStringStruct>(); |
| a[0]->value1 = v1; |
| a[0]->value2 = v2; |
| a[1] = nullptr; |
| a[2] = std::make_unique<test::fidlcodec::examples::TwoStringStruct>(); |
| a[2]->value1 = v3; |
| a[2]->value2 = v4; |
| return a; |
| } |
| |
| } // namespace |
| |
| TEST_DECODE_WIRE( |
| ArrayNullableStruct, ArrayNullableStruct, |
| R"({"a":[{"value1":"harpo","value2":"chico"},null,{"value1":"groucho","value2":"zeppo"}]})", |
| "{\n" |
| " a: array<#gre#test.fidlcodec.examples/TwoStringStruct#rst#> = [\n" |
| " { value1: #gre#string#rst# = #red#\"harpo\"#rst#, " |
| "value2: #gre#string#rst# = #red#\"chico\"#rst# }, #red#null#rst#\n" |
| " { value1: #gre#string#rst# = #red#\"groucho\"#rst#, " |
| "value2: #gre#string#rst# = #red#\"zeppo\"#rst# }\n" |
| " ]\n" |
| "}", |
| GetArrayNullableStruct("harpo", "chico", "groucho", "zeppo")) |
| |
| namespace { |
| |
| test::fidlcodec::examples::SmallStruct SmallStructFromVals(uint8_t a, uint8_t b, uint8_t c) { |
| test::fidlcodec::examples::SmallStruct ss; |
| ss.a = a; |
| ss.b = b; |
| ss.c = c; |
| return ss; |
| } |
| |
| } // namespace |
| |
| TEST_DECODE_WIRE(SmallStruct, SmallStructAfterByte, |
| R"({"u":"1","s1":{"a":"2","b":"3","c":"4"},"s2":{"a":"5","b":"6","c":"7"}})", |
| "{\n" |
| " u: #gre#uint8#rst# = #blu#1#rst#\n" |
| " s1: #gre#test.fidlcodec.examples/SmallStruct#rst# = {\n" |
| " a: #gre#uint8#rst# = #blu#2#rst#\n" |
| " b: #gre#uint8#rst# = #blu#3#rst#\n" |
| " c: #gre#uint8#rst# = #blu#4#rst#\n" |
| " }\n" |
| " s2: #gre#test.fidlcodec.examples/SmallStruct#rst# = {\n" |
| " a: #gre#uint8#rst# = #blu#5#rst#\n" |
| " b: #gre#uint8#rst# = #blu#6#rst#\n" |
| " c: #gre#uint8#rst# = #blu#7#rst#\n" |
| " }\n" |
| "}", |
| 1, SmallStructFromVals(2, 3, 4), SmallStructFromVals(5, 6, 7)); |
| |
| namespace { |
| |
| test::fidlcodec::examples::TwoStringStruct TwoStringStructFromVals(const std::string& v1, |
| const std::string& v2) { |
| test::fidlcodec::examples::TwoStringStruct tss; |
| tss.value1 = v1; |
| tss.value2 = v2; |
| return tss; |
| } |
| |
| std::unique_ptr<test::fidlcodec::examples::TwoStringStruct> TwoStringStructFromValsPtr( |
| const std::string& v1, const std::string& v2) { |
| std::unique_ptr<test::fidlcodec::examples::TwoStringStruct> ptr( |
| new test::fidlcodec::examples::TwoStringStruct()); |
| ptr->value1 = v1; |
| ptr->value2 = v2; |
| return ptr; |
| } |
| |
| std::string TwoStringStructIntPretty(const char* s1, const char* s2, int v) { |
| std::string result = "{\n s: #gre#test.fidlcodec.examples/TwoStringStruct#rst# = {\n"; |
| result += " " + ValueToPretty("value1", "string", s1) + "\n"; |
| result += " " + ValueToPretty("value2", "string", s2) + "\n"; |
| result += " }\n"; |
| result += " " + ValueToPretty("i32", "int32", v) + "\n"; |
| result += "}"; |
| return result; |
| } |
| |
| } // namespace |
| |
| TEST_DECODE_WIRE(TwoStringStructInt, TwoStringStructInt, |
| R"({"s":{"value1":"harpo", "value2":"chico"}, "i32":"1"})", |
| TwoStringStructIntPretty("harpo", "chico", 1), |
| TwoStringStructFromVals("harpo", "chico"), 1) |
| |
| TEST_DECODE_WIRE(TwoStringNullableStructInt, TwoStringNullableStructInt, |
| R"({"s":{"value1":"harpo", "value2":"chico"}, "i32":"1"})", |
| TwoStringStructIntPretty("harpo", "chico", 1), |
| TwoStringStructFromValsPtr("harpo", "chico"), 1) |
| |
| TEST_DECODE_WIRE(VectorStruct, VectorStruct, |
| R"({"v":[{"a":"1","b":"2","c":"3"},{"a":"2","b":"4","c":"6"},)" |
| R"({"a":"3","b":"6","c":"9"}]})", |
| "{\n" |
| " v: vector<#gre#test.fidlcodec.examples/SmallStruct#rst#> = [\n" |
| " { a: #gre#uint8#rst# = #blu#1#rst#, b: #gre#uint8#rst# = #blu#2#rst#, c: " |
| "#gre#uint8#rst# = #blu#3#rst# }\n" |
| " { a: #gre#uint8#rst# = #blu#2#rst#, b: #gre#uint8#rst# = #blu#4#rst#, c: " |
| "#gre#uint8#rst# = #blu#6#rst# }\n" |
| " { a: #gre#uint8#rst# = #blu#3#rst#, b: #gre#uint8#rst# = #blu#6#rst#, c: " |
| "#gre#uint8#rst# = #blu#9#rst# }\n" |
| " ]\n" |
| "}", |
| std::vector{SmallStructFromVals(1, 2, 3), SmallStructFromVals(2, 4, 6), |
| SmallStructFromVals(3, 6, 9)}) |
| |
| TEST_DECODE_WIRE(ArrayStruct, ArrayStruct, |
| R"({"a":[{"a":"1","b":"2","c":"3"},{"a":"2","b":"4","c":"6"},)" |
| R"({"a":"3","b":"6","c":"9"}]})", |
| "{\n" |
| " a: array<#gre#test.fidlcodec.examples/SmallStruct#rst#> = [\n" |
| " { a: #gre#uint8#rst# = #blu#1#rst#, b: #gre#uint8#rst# = #blu#2#rst#, c: " |
| "#gre#uint8#rst# = #blu#3#rst# }\n" |
| " { a: #gre#uint8#rst# = #blu#2#rst#, b: #gre#uint8#rst# = #blu#4#rst#, c: " |
| "#gre#uint8#rst# = #blu#6#rst# }\n" |
| " { a: #gre#uint8#rst# = #blu#3#rst#, b: #gre#uint8#rst# = #blu#6#rst#, c: " |
| "#gre#uint8#rst# = #blu#9#rst# }\n" |
| " ]\n" |
| "}", |
| std::array{SmallStructFromVals(1, 2, 3), SmallStructFromVals(2, 4, 6), |
| SmallStructFromVals(3, 6, 9)}) |
| |
| namespace { |
| |
| test::fidlcodec::examples::SmallUnevenStruct SmallUnevenStructFromVals(uint8_t a, uint8_t b) { |
| test::fidlcodec::examples::SmallUnevenStruct ss; |
| ss.a = a; |
| ss.b = b; |
| return ss; |
| } |
| |
| } // namespace |
| |
| TEST_DECODE_WIRE(VectorStruct2, VectorStruct2, |
| R"({"v":[{"a":"1","b":"2"},{"a":"2","b":"4"},{"a":"3","b":"6"}]})", |
| "{\n" |
| " v: vector<#gre#test.fidlcodec.examples/SmallUnevenStruct#rst#> = [\n" |
| " { a: #gre#uint32#rst# = #blu#1#rst#, b: #gre#uint8#rst# = #blu#2#rst# }," |
| " { a: #gre#uint32#rst# = #blu#2#rst#, b: #gre#uint8#rst# = #blu#4#rst# }\n" |
| " { a: #gre#uint32#rst# = #blu#3#rst#, b: #gre#uint8#rst# = #blu#6#rst# }\n" |
| " ]\n" |
| "}", |
| std::vector{SmallUnevenStructFromVals(1, 2), SmallUnevenStructFromVals(2, 4), |
| SmallUnevenStructFromVals(3, 6)}) |
| |
| TEST_DECODE_WIRE(ArrayStruct2, ArrayStruct2, |
| R"({"a":[{"a":"1","b":"2"},{"a":"2","b":"4"},{"a":"3","b":"6"}]})", |
| "{\n" |
| " a: array<#gre#test.fidlcodec.examples/SmallUnevenStruct#rst#> = [\n" |
| " { a: #gre#uint32#rst# = #blu#1#rst#, b: #gre#uint8#rst# = #blu#2#rst# }," |
| " { a: #gre#uint32#rst# = #blu#2#rst#, b: #gre#uint8#rst# = #blu#4#rst# }\n" |
| " { a: #gre#uint32#rst# = #blu#3#rst#, b: #gre#uint8#rst# = #blu#6#rst# }\n" |
| " ]\n" |
| "}", |
| std::array{SmallUnevenStructFromVals(1, 2), SmallUnevenStructFromVals(2, 4), |
| SmallUnevenStructFromVals(3, 6)}) |
| |
| // Union and XUnion tests |
| |
| namespace { |
| |
| using isu = test::fidlcodec::examples::IntStructUnion; |
| using xisu = test::fidlcodec::examples::IntStructXunion; |
| using u8u16struct = test::fidlcodec::examples::U8U16UnionStructType; |
| |
| template <class T> |
| T GetIntUnion(int32_t i) { |
| T u; |
| u.set_variant_i(i); |
| return u; |
| } |
| |
| template <class T> |
| T GetStructUnion(const std::string& v1, const std::string& v2) { |
| T u; |
| test::fidlcodec::examples::TwoStringStruct tss = TwoStringStructFromVals(v1, v2); |
| u.set_variant_tss(tss); |
| return u; |
| } |
| |
| template <class T> |
| std::unique_ptr<T> GetIntUnionPtr(int32_t i) { |
| std::unique_ptr<T> ptr(new T()); |
| ptr->set_variant_i(i); |
| return ptr; |
| } |
| |
| template <class T> |
| std::unique_ptr<T> GetStructUnionPtr(const std::string& v1, const std::string& v2) { |
| std::unique_ptr<T> ptr(new T()); |
| test::fidlcodec::examples::TwoStringStruct tss = TwoStringStructFromVals(v1, v2); |
| ptr->set_variant_tss(tss); |
| return ptr; |
| } |
| |
| u8u16struct GetU8U16UnionStruct(int8_t i) { |
| u8u16struct s; |
| s.u.set_variant_u8(i); |
| return s; |
| } |
| |
| std::string IntUnionIntPretty(const std::string& name, int u, int v) { |
| std::string result = "{\n"; |
| result += " isu: #gre#test.fidlcodec.examples/" + name + "#rst# = { " + |
| ValueToPretty("variant_i", "int32", u) + " }\n"; |
| result += " " + ValueToPretty("i", "int32", v) + "\n"; |
| result += "}"; |
| return result; |
| } |
| |
| std::string StructUnionIntPretty(const std::string& name, const char* u1, const char* u2, int v) { |
| std::string result = "{\n"; |
| result += " isu: #gre#test.fidlcodec.examples/" + name + "#rst# = {\n"; |
| result += |
| " variant_tss: #gre#test.fidlcodec.examples/TwoStringStruct#rst# = " |
| "{\n"; |
| result += " " + ValueToPretty("value1", "string", u1) + "\n"; |
| result += " " + ValueToPretty("value2", "string", u2) + "\n"; |
| result += " }\n"; |
| result += " }\n"; |
| result += " " + ValueToPretty("i", "int32", v) + "\n"; |
| result += "}"; |
| return result; |
| } |
| |
| std::string IntIntUnionPretty(const std::string& name, int v, int u) { |
| std::string result = "{\n"; |
| result += " " + ValueToPretty("i", "int32", v) + "\n"; |
| result += " isu: #gre#test.fidlcodec.examples/" + name + "#rst# = { " + |
| ValueToPretty("variant_i", "int32", u) + " }\n"; |
| result += "}"; |
| return result; |
| } |
| |
| std::string IntStructUnionPretty(const std::string& name, int v, const char* u1, const char* u2) { |
| std::string result = "{\n"; |
| result += " " + ValueToPretty("i", "int32", v) + "\n"; |
| result += " isu: #gre#test.fidlcodec.examples/" + name + "#rst# = {\n"; |
| result += |
| " variant_tss: #gre#test.fidlcodec.examples/TwoStringStruct#rst# = " |
| "{\n"; |
| result += " " + ValueToPretty("value1", "string", u1) + "\n"; |
| result += " " + ValueToPretty("value2", "string", u2) + "\n"; |
| result += " }\n"; |
| result += " }\n"; |
| result += "}"; |
| return result; |
| } |
| |
| test::fidlcodec::examples::DataElement GetDataElement(int32_t i32, uint8_t u8) { |
| test::fidlcodec::examples::DataElement result; |
| std::vector<std::unique_ptr<test::fidlcodec::examples::DataElement>> alternatives; |
| auto item_1 = std::make_unique<test::fidlcodec::examples::DataElement>(); |
| item_1->set_int32(i32); |
| alternatives.emplace_back(std::move(item_1)); |
| auto item_2 = std::make_unique<test::fidlcodec::examples::DataElement>(); |
| item_2->set_uint8(u8); |
| alternatives.emplace_back(std::move(item_2)); |
| result.set_alternatives(std::move(alternatives)); |
| return result; |
| } |
| |
| } // namespace |
| |
| TEST_DECODE_WIRE(UnionInt, Union, R"({"isu":{"variant_i":"42"}, "i" : "1"})", |
| IntUnionIntPretty("IntStructUnion", 42, 1), GetIntUnion<isu>(42), 1); |
| |
| TEST_DECODE_WIRE(UnionStruct, Union, |
| R"({"isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}, "i":"1"})", |
| StructUnionIntPretty("IntStructUnion", "harpo", "chico", 1), |
| GetStructUnion<isu>("harpo", "chico"), 1); |
| |
| TEST_DECODE_WIRE(NullableUnionInt, NullableUnion, R"({"isu":{"variant_i":"42"}, "i" : "1"})", |
| IntUnionIntPretty("IntStructUnion", 42, 1), GetIntUnionPtr<isu>(42), 1); |
| |
| TEST_DECODE_WIRE(NullableUnionStruct, NullableUnion, |
| R"({"isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}, "i":"1"})", |
| StructUnionIntPretty("IntStructUnion", "harpo", "chico", 1), |
| GetStructUnionPtr<isu>("harpo", "chico"), 1); |
| |
| TEST_DECODE_WIRE(NullableUnionIntFirstInt, NullableUnionIntFirst, |
| R"({"i" : "1", "isu":{"variant_i":"42"}})", |
| IntIntUnionPretty("IntStructUnion", 1, 42), 1, GetIntUnionPtr<isu>(42)); |
| |
| TEST_DECODE_WIRE(NullableUnionIntFirstStruct, NullableUnionIntFirst, |
| R"({"i": "1", "isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}})", |
| IntStructUnionPretty("IntStructUnion", 1, "harpo", "chico"), 1, |
| GetStructUnionPtr<isu>("harpo", "chico")); |
| |
| TEST_DECODE_WIRE(XUnionInt, XUnion, R"({"isu":{"variant_i":"42"}, "i" : "1"})", |
| IntUnionIntPretty("IntStructXunion", 42, 1), GetIntUnion<xisu>(42), 1); |
| |
| TEST_DECODE_WIRE(XUnionStruct, XUnion, |
| R"({"isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}, "i":"1"})", |
| StructUnionIntPretty("IntStructXunion", "harpo", "chico", 1), |
| GetStructUnion<xisu>("harpo", "chico"), 1); |
| |
| TEST_DECODE_WIRE(NullableXUnionInt, NullableXUnion, R"({"isu":{"variant_i":"42"}, "i" : "1"})", |
| IntUnionIntPretty("IntStructXunion", 42, 1), GetIntUnionPtr<xisu>(42), 1); |
| |
| TEST_DECODE_WIRE(NullableXUnionStruct, NullableXUnion, |
| R"({"isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}, "i":"1"})", |
| StructUnionIntPretty("IntStructXunion", "harpo", "chico", 1), |
| GetStructUnionPtr<xisu>("harpo", "chico"), 1); |
| |
| TEST_DECODE_WIRE(NullableXUnionIntFirstInt, NullableXUnionIntFirst, |
| R"({"i" : "1", "isu":{"variant_i":"42"}})", |
| IntIntUnionPretty("IntStructXunion", 1, 42), 1, GetIntUnionPtr<xisu>(42)); |
| |
| TEST_DECODE_WIRE(NullableXUnionIntFirstStruct, NullableXUnionIntFirst, |
| R"({"i": "1", "isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}})", |
| IntStructUnionPretty("IntStructXunion", 1, "harpo", "chico"), 1, |
| GetStructUnionPtr<xisu>("harpo", "chico")); |
| |
| TEST_DECODE_WIRE( |
| RecursiveUnion, RecursiveUnion, R"({"e":{"alternatives":[{"int32":"-10"},{"uint8":"200"}]}})", |
| "{\n" |
| " e: #gre#test.fidlcodec.examples/DataElement#rst# = {\n" |
| " alternatives: vector<#gre#test.fidlcodec.examples/DataElement#rst#> = [\n" |
| " { int32: #gre#int32#rst# = #blu#-10#rst# }, { uint8: #gre#uint8#rst# = #blu#200#rst# }\n" |
| " ]\n" |
| " }\n" |
| "}", |
| GetDataElement(-10, 200)); |
| |
| namespace { |
| |
| std::array<std::unique_ptr<test::fidlcodec::examples::IntStructUnion>, 3> GetArrayNullableUnion( |
| int32_t i, const std::string& v1, const std::string& v2) { |
| std::array<std::unique_ptr<test::fidlcodec::examples::IntStructUnion>, 3> a; |
| a[0] = std::make_unique<test::fidlcodec::examples::IntStructUnion>(); |
| a[0]->set_variant_i(i); |
| test::fidlcodec::examples::TwoStringStruct tss = TwoStringStructFromVals(v1, v2); |
| a[2] = std::make_unique<test::fidlcodec::examples::IntStructUnion>(); |
| a[2]->set_variant_tss(tss); |
| return a; |
| } |
| |
| } // namespace |
| |
| TEST_DECODE_WIRE( |
| ArrayNullableUnion, ArrayNullableUnion, |
| R"({"a":[{"variant_i":"1234"},null,{"variant_tss":{"value1":"harpo","value2":"chico"}}]})", |
| "{\n" |
| " a: array<#gre#test.fidlcodec.examples/IntStructUnion#rst#> = [\n" |
| " { variant_i: #gre#int32#rst# = #blu#1234#rst# }, #red#null#rst#\n" |
| " {\n" |
| " variant_tss: #gre#test.fidlcodec.examples/TwoStringStruct#rst# = {\n" |
| " value1: #gre#string#rst# = #red#\"harpo\"#rst#\n" |
| " value2: #gre#string#rst# = #red#\"chico\"#rst#\n" |
| " }\n" |
| " }\n" |
| " ]\n" |
| "}", |
| GetArrayNullableUnion(1234, "harpo", "chico")) |
| |
| TEST_F(WireParserTest, BadU8U16UnionStruct) { |
| TEST_DECODE_WIRE_BODY_COMMON(U8U16UnionStruct, -1, 0, |
| "{\"s\":{\"u\":{\"variant_u8\":\"(invalid)\"}}}", |
| "{\n" |
| " s: #gre#test.fidlcodec.examples/U8U16UnionStructType#rst# = {\n" |
| " u: #gre#test.fidlcodec.examples/U8U16Union#rst# = " |
| "{ variant_u8: #gre#uint8#rst# = #red#invalid#rst# }\n" |
| " }\n" |
| "}", |
| 24, GetU8U16UnionStruct(12)); |
| } |
| |
| namespace { |
| |
| using uuu = test::fidlcodec::examples::U8U16Union; |
| using uuur = test::fidlcodec::examples::U8U16UnionReserved; |
| using uux = test::fidlcodec::examples::U8U16Xunion; |
| |
| template <class T> |
| T GetUInt8Union(uint8_t i) { |
| T u; |
| u.set_variant_u8(i); |
| return u; |
| } |
| |
| template <class T> |
| T GetUInt16Union(uint16_t i) { |
| T u; |
| u.set_variant_u16(i); |
| return u; |
| } |
| |
| std::string ShortUnionPretty(const std::string& name, const char* field, const char* type, int u, |
| int v) { |
| std::string result = "{\n"; |
| result += " u: #gre#test.fidlcodec.examples/" + name + "#rst# = { " + |
| ValueToPretty(field, type, u) + " }\n"; |
| result += " " + ValueToPretty("i", "int32", v) + "\n"; |
| result += "}"; |
| return result; |
| } |
| |
| } // namespace |
| |
| TEST_DECODE_WIRE(ShortUnion8, ShortUnion, R"({"u":{"variant_u8":"16"}, "i":"1"})", |
| ShortUnionPretty("U8U16Union", "variant_u8", "uint8", 16, 1), |
| GetUInt8Union<uuu>(16), 1); |
| |
| TEST_DECODE_WIRE(ShortUnion16, ShortUnion, R"({"u":{"variant_u16":"1024"}, "i":"1"})", |
| ShortUnionPretty("U8U16Union", "variant_u16", "uint16", 1024, 1), |
| GetUInt16Union<uuu>(1024), 1); |
| |
| TEST_DECODE_WIRE(ShortUnionReserved8, ShortUnionReserved, R"({"u":{"variant_u8":"16"}, "i":"1"})", |
| ShortUnionPretty("U8U16UnionReserved", "variant_u8", "uint8", 16, 1), |
| GetUInt8Union<uuur>(16), 1); |
| |
| TEST_DECODE_WIRE(ShortUnionReserved16, ShortUnionReserved, |
| R"({"u":{"variant_u16":"1024"}, "i":"1"})", |
| ShortUnionPretty("U8U16UnionReserved", "variant_u16", "uint16", 1024, 1), |
| GetUInt16Union<uuur>(1024), 1); |
| |
| TEST_DECODE_WIRE(ShortXUnion8, ShortXUnion, R"({"u":{"variant_u8":"16"}, "i":"1"})", |
| ShortUnionPretty("U8U16Xunion", "variant_u8", "uint8", 16, 1), |
| GetUInt8Union<uux>(16), 1); |
| |
| TEST_DECODE_WIRE(ShortXUnion16, ShortXUnion, R"({"u":{"variant_u16":"1024"}, "i":"1"})", |
| ShortUnionPretty("U8U16Xunion", "variant_u16", "uint16", 1024, 1), |
| GetUInt16Union<uux>(1024), 1); |
| |
| // Enum Tests |
| |
| TEST_DECODE_WIRE(DefaultEnum, DefaultEnumMessage, R"({"ev":"X"})", |
| "{ ev: #gre#test.fidlcodec.examples/DefaultEnum#rst# = #blu#X#rst# }", |
| test::fidlcodec::examples::DefaultEnum::X); |
| TEST_DECODE_WIRE(I8Enum, I8EnumMessage, R"({"ev":"X"})", |
| "{ ev: #gre#test.fidlcodec.examples/I8Enum#rst# = #blu#X#rst# }", |
| test::fidlcodec::examples::I8Enum::X); |
| TEST_DECODE_WIRE(I16Enum, I16EnumMessage, R"({"ev":"X"})", |
| "{ ev: #gre#test.fidlcodec.examples/I16Enum#rst# = #blu#X#rst# }", |
| test::fidlcodec::examples::I16Enum::X); |
| TEST_DECODE_WIRE(I32Enum, I32EnumMessage, R"({"ev":"X"})", |
| "{ ev: #gre#test.fidlcodec.examples/I32Enum#rst# = #blu#X#rst# }", |
| test::fidlcodec::examples::I32Enum::X); |
| TEST_DECODE_WIRE(I64Enum, I64EnumMessage, R"({"ev":"X"})", |
| "{ ev: #gre#test.fidlcodec.examples/I64Enum#rst# = #blu#X#rst# }", |
| test::fidlcodec::examples::I64Enum::X); |
| |
| // Bits Tests |
| |
| TEST_DECODE_WIRE(DefaultBits, DefaultBitsMessage, R"({"v":"A|C"})", |
| "{ v: #gre#test.fidlcodec.examples/DefaultBits#rst# = #blu#A|C#rst# }", |
| static_cast<test::fidlcodec::examples::DefaultBits>( |
| static_cast<uint8_t>(test::fidlcodec::examples::DefaultBits::A) | |
| static_cast<uint8_t>(test::fidlcodec::examples::DefaultBits::C))); |
| TEST_DECODE_WIRE(I8Bits, I8BitsMessage, R"({"v":"A|D"})", |
| "{ v: #gre#test.fidlcodec.examples/I8Bits#rst# = #blu#A|D#rst# }", |
| static_cast<test::fidlcodec::examples::I8Bits>( |
| static_cast<uint8_t>(test::fidlcodec::examples::I8Bits::A) | |
| static_cast<uint8_t>(test::fidlcodec::examples::I8Bits::D))); |
| TEST_DECODE_WIRE(I16Bits, I16BitsMessage, R"({"v":"B|C"})", |
| "{ v: #gre#test.fidlcodec.examples/I16Bits#rst# = #blu#B|C#rst# }", |
| static_cast<test::fidlcodec::examples::I16Bits>( |
| static_cast<uint16_t>(test::fidlcodec::examples::I16Bits::B) | |
| static_cast<uint16_t>(test::fidlcodec::examples::I16Bits::C))); |
| TEST_DECODE_WIRE(I32Bits, I32BitsMessage, R"({"v":"B|D"})", |
| "{ v: #gre#test.fidlcodec.examples/I32Bits#rst# = #blu#B|D#rst# }", |
| static_cast<test::fidlcodec::examples::I32Bits>( |
| static_cast<uint32_t>(test::fidlcodec::examples::I32Bits::B) | |
| static_cast<uint32_t>(test::fidlcodec::examples::I32Bits::D))); |
| TEST_DECODE_WIRE(I64Bits, I64BitsMessage, R"({"v":"C|D"})", |
| "{ v: #gre#test.fidlcodec.examples/I64Bits#rst# = #blu#C|D#rst# }", |
| static_cast<test::fidlcodec::examples::I64Bits>( |
| static_cast<uint64_t>(test::fidlcodec::examples::I64Bits::C) | |
| static_cast<uint64_t>(test::fidlcodec::examples::I64Bits::D))); |
| TEST_DECODE_WIRE(EmptyDefaultBits, DefaultBitsMessage, R"({"v":"<none>"})", |
| "{ v: #gre#test.fidlcodec.examples/DefaultBits#rst# = #blu#<none>#rst# }", |
| static_cast<test::fidlcodec::examples::DefaultBits>(0)); |
| |
| // Table Tests |
| |
| test::fidlcodec::examples::ValueTable GetTable(std::optional<int16_t> first_int16, |
| std::optional<std::string> value1, |
| std::optional<std::string> value2, |
| std::optional<int32_t> third_union_val) { |
| test::fidlcodec::examples::ValueTable table; |
| if (first_int16.has_value()) { |
| table.set_first_int16(*first_int16); |
| } |
| if (value1.has_value()) { |
| table.set_second_struct(TwoStringStructFromVals(*value1, *value2)); |
| } |
| if (third_union_val.has_value()) { |
| test::fidlcodec::examples::IntStructUnion u; |
| u.set_variant_i(*third_union_val); |
| table.set_third_union(std::move(u)); |
| } |
| return table; |
| } |
| |
| std::string TablePretty(std::optional<int16_t> first_int16, std::optional<std::string> value1, |
| std::optional<std::string> value2, std::optional<int32_t> third_union_val, |
| int i) { |
| if (!first_int16.has_value() && !value1.has_value() && !third_union_val.has_value()) { |
| std::string result = "{ table: #gre#test.fidlcodec.examples/ValueTable#rst# = {}, "; |
| result += ValueToPretty("i", "int32", i); |
| result += " }"; |
| return result; |
| } |
| std::string result = "{\n"; |
| if (!value1.has_value() && !third_union_val.has_value()) { |
| result += " table: #gre#test.fidlcodec.examples/ValueTable#rst# = { "; |
| result += ValueToPretty("first_int16", "int16", *first_int16) + " }\n"; |
| } else { |
| result += " table: #gre#test.fidlcodec.examples/ValueTable#rst# = {\n"; |
| if (first_int16.has_value()) { |
| result += " " + ValueToPretty("first_int16", "int16", *first_int16) + "\n"; |
| } |
| if (value1.has_value()) { |
| result += |
| " second_struct: " |
| "#gre#test.fidlcodec.examples/TwoStringStruct#rst# = {\n"; |
| result += " " + ValueToPretty("value1", "string", *value1) + "\n"; |
| result += " " + ValueToPretty("value2", "string", *value2) + "\n"; |
| result += " }\n"; |
| } |
| if (third_union_val.has_value()) { |
| result += " third_union: #gre#test.fidlcodec.examples/IntStructUnion#rst# = {\n"; |
| result += " " + ValueToPretty("variant_i", "int32", *third_union_val) + "\n"; |
| result += " }\n"; |
| } |
| result += " }\n"; |
| } |
| result += " " + ValueToPretty("i", "int32", i) + "\n"; |
| result += "}"; |
| return result; |
| } |
| |
| TEST_DECODE_WIRE(Table0, Table, R"({"table":{}, "i":"2"})", TablePretty({}, {}, {}, {}, 2), |
| GetTable({}, {}, {}, {}), 2) |
| |
| TEST_DECODE_WIRE(Table1, Table, |
| R"({"table":{ |
| "third_union":{"variant_i":"42"} |
| }, |
| "i":"2"})", |
| TablePretty({}, {}, {}, 42, 2), GetTable({}, {}, {}, 42), 2) |
| |
| TEST_DECODE_WIRE(Table2, Table, |
| R"({"table":{ |
| "second_struct":{"value1":"harpo", "value2":"groucho"} |
| }, |
| "i":"2"})", |
| TablePretty({}, "harpo", "groucho", {}, 2), GetTable({}, "harpo", "groucho", {}), |
| 2) |
| |
| TEST_DECODE_WIRE(Table3, Table, |
| R"({"table":{ |
| "second_struct":{ |
| "value1":"harpo", "value2":"groucho"}, |
| "third_union":{"variant_i":"42"}}, |
| "i":"2"})", |
| TablePretty({}, "harpo", "groucho", 42, 2), GetTable({}, "harpo", "groucho", 42), |
| 2) |
| |
| TEST_DECODE_WIRE(Table4, Table, R"({"table":{ |
| "first_int16":"1" |
| }, |
| "i":"2"})", |
| TablePretty(1, {}, {}, {}, 2), GetTable(1, {}, {}, {}), 2) |
| |
| TEST_DECODE_WIRE(Table5, Table, |
| R"({"table":{ |
| "first_int16":"1", |
| "third_union":{"variant_i":"42"} |
| }, |
| "i":"2"})", |
| TablePretty(1, {}, {}, 42, 2), GetTable(1, {}, {}, 42), 2) |
| |
| TEST_DECODE_WIRE(Table6, Table, |
| R"({"table":{ |
| "first_int16":"1", |
| "second_struct":{ |
| "value1":"harpo", "value2":"groucho"} |
| }, |
| "i":"2"})", |
| TablePretty(1, "harpo", "groucho", {}, 2), GetTable(1, "harpo", "groucho", {}), 2) |
| |
| TEST_DECODE_WIRE(Table7, Table, |
| R"({"table":{ |
| "first_int16":"1", |
| "second_struct":{ |
| "value1":"harpo", "value2":"groucho"}, |
| "third_union":{"variant_i":"42"} |
| }, |
| "i":"2"})", |
| TablePretty(1, "harpo", "groucho", 42, 2), GetTable(1, "harpo", "groucho", 42), 2) |
| |
| // TODO(fxbug.dev/6274): Add a test that exercises what happens when we encounter an |
| // unknown type in a table. |
| |
| // Handle Tests |
| |
| namespace { |
| |
| class HandleSupport { |
| public: |
| HandleSupport() { |
| zx::channel::create(0, &out1_, &out2_); |
| json_ = "{" + HandleToJson("ch", 0x100) + "}"; |
| pretty_ = "{ " + HandleToPretty("ch", 0x100) + " }"; |
| } |
| zx::channel handle() { return std::move(out2_); } |
| |
| template <typename Interface> |
| fidl::InterfaceHandle<Interface> interface() { |
| return fidl::InterfaceHandle<Interface>(std::move(out2_)); |
| } |
| |
| std::string GetJSON() { return json_; } |
| std::string GetPretty() { return pretty_; } |
| |
| private: |
| zx::channel out1_; |
| zx::channel out2_; |
| std::string json_; |
| std::string pretty_; |
| }; |
| |
| } // namespace |
| |
| TEST_F(WireParserTest, ParseHandle) { |
| HandleSupport support; |
| TEST_DECODE_WIRE_BODY(Handle, support.GetJSON(), support.GetPretty(), support.handle()); |
| } |
| TEST_F(WireParserTest, ParseNullableHandle) { |
| HandleSupport support; |
| TEST_DECODE_WIRE_BODY(NullableHandle, support.GetJSON(), support.GetPretty(), support.handle()); |
| } |
| TEST_F(WireParserTest, ParseProtocol) { |
| HandleSupport support; |
| TEST_DECODE_WIRE_BODY(Protocol, support.GetJSON(), support.GetPretty(), |
| support.interface<test::fidlcodec::examples::ParamProtocol>()); |
| } |
| |
| namespace { |
| |
| class HandleStructSupport { |
| public: |
| HandleStructSupport() { |
| zx::channel::create(0, &out1_, &out2_); |
| zx::channel::create(0, &out3_, &out4_); |
| json_ = "{\"hs\":{" + HandleToJson("h1", 0x100) + "," + HandleToJson("h2", 0x101) + "," + |
| HandleToJson("h3", 0x102) + "}}"; |
| pretty_ = "{\n hs: #gre#test.fidlcodec.examples/HandleStruct#rst# = {\n " + |
| HandleToPretty("h1", 0x100) + "\n " + HandleToPretty("h2", 0x101) + "\n " + |
| HandleToPretty("h3", 0x102) + "\n }\n}"; |
| } |
| test::fidlcodec::examples::HandleStruct handle_struct() { |
| test::fidlcodec::examples::HandleStruct hs; |
| hs.h1 = std::move(out1_); |
| hs.h2 = std::move(out2_); |
| hs.h3 = std::move(out3_); |
| return hs; |
| } |
| std::string GetJSON() { return json_; } |
| std::string GetPretty() { return pretty_; } |
| |
| private: |
| zx::channel out1_; |
| zx::channel out2_; |
| zx::channel out3_; |
| zx::channel out4_; |
| |
| std::string json_; |
| std::string pretty_; |
| }; |
| |
| } // namespace |
| |
| TEST_F(WireParserTest, ParseHandleStruct) { |
| HandleStructSupport support; |
| TEST_DECODE_WIRE_BODY(HandleStructMessage, support.GetJSON(), support.GetPretty(), |
| support.handle_struct()); |
| } |
| |
| namespace { |
| |
| class HandleTableSupport { |
| public: |
| HandleTableSupport() { |
| zx::channel::create(0, &out1_, &out2_); |
| json_ = "{\"t\":{" + HandleToJson("h1", 0x100) + ",\"s1\":{\"sh1\":\"00000000\"," + |
| HandleToJson("sh2", 0x101) + "}}}"; |
| pretty_ = |
| "{\n" |
| " t: #gre#test.fidlcodec.examples/HandleTable#rst# = {\n" |
| " " + |
| HandleToPretty("h1", 0x100) + |
| "\n" |
| " s1: #gre#test.fidlcodec.examples/OptHandleStruct#rst# = {\n" |
| " sh1: #gre#handle#rst# = #red#00000000#rst#\n" |
| " " + |
| HandleToPretty("sh2", 0x101) + |
| "\n" |
| " }\n" |
| " }\n" |
| "}"; |
| } |
| test::fidlcodec::examples::HandleTable handle_table() { |
| test::fidlcodec::examples::HandleTable t; |
| t.set_h1(std::move(out1_)); |
| test::fidlcodec::examples::OptHandleStruct s; |
| s.sh2 = std::move(out2_); |
| t.set_s1(std::move(s)); |
| return t; |
| } |
| std::string GetJSON() { return json_; } |
| std::string GetPretty() { return pretty_; } |
| |
| private: |
| zx::channel out1_; |
| zx::channel out2_; |
| |
| std::string json_; |
| std::string pretty_; |
| }; |
| |
| } // namespace |
| |
| TEST_F(WireParserTest, ParseHandleTable) { |
| HandleTableSupport support; |
| TEST_DECODE_WIRE_BODY(HandleTableMessage, support.GetJSON(), support.GetPretty(), |
| support.handle_table()); |
| } |
| |
| namespace { |
| |
| class TraversalOrderSupport { |
| public: |
| TraversalOrderSupport() { |
| zx::channel::create(0, &sh1_, &sh2_); |
| zx::channel::create(0, &h1_, &h2_); |
| json_ = "{\"t\":{\"s\":{" + HandleToJson("sh1", 0x100) + "," + HandleToJson("sh2", 0x101) + |
| "}," + HandleToJson("h1", 0x102) + "," + HandleToJson("h2", 0x103) + "}}"; |
| pretty_ = |
| "{\n t: #gre#test.fidlcodec.examples/TraversalOrder#rst# = {\n " |
| "s: #gre#test.fidlcodec.examples/OptHandleStruct#rst# = {\n " + |
| HandleToPretty("sh1", 0x100) + "\n " + HandleToPretty("sh2", 0x101) + "\n }\n " + |
| HandleToPretty("h1", 0x102) + "\n " + HandleToPretty("h2", 0x103) + "\n }\n}"; |
| } |
| test::fidlcodec::examples::TraversalOrder TraversalOrder() { |
| test::fidlcodec::examples::TraversalOrder t; |
| auto s = std::make_unique<test::fidlcodec::examples::OptHandleStruct>(); |
| s->sh1 = std::move(sh1_); |
| s->sh2 = std::move(sh2_); |
| t.s = std::move(s); |
| t.h1 = std::move(h1_); |
| t.h2 = std::move(h2_); |
| return t; |
| } |
| std::string GetJSON() { return json_; } |
| std::string GetPretty() { return pretty_; } |
| |
| private: |
| zx::channel sh1_; |
| zx::channel sh2_; |
| zx::channel h1_; |
| zx::channel h2_; |
| |
| std::string json_; |
| std::string pretty_; |
| }; |
| |
| } // namespace |
| |
| TEST_F(WireParserTest, ParseTraversalOrder) { |
| TraversalOrderSupport support; |
| TEST_DECODE_WIRE_BODY(TraversalOrderMessage, support.GetJSON(), support.GetPretty(), |
| support.TraversalOrder()); |
| } |
| |
| namespace { |
| |
| class TraversalMainSupport { |
| public: |
| TraversalMainSupport() { |
| zx::channel::create(0, &out1_, &out2_); |
| json_ = R"JSON({"v":[{"x":"10","y":{"a":"20",)JSON" + HandleToJson("b", 0x100) + |
| R"JSON(}},{"x":"30","y":{"a":"40",)JSON" + HandleToJson("b", 0x101) + |
| R"JSON(}}],"s":{"a":"50","b":"00000000"}})JSON"; |
| pretty_ = |
| "{\n" |
| " v: vector<#gre#test.fidlcodec.examples/TraversalMain#rst#> = [\n" |
| " {\n" |
| " x: #gre#uint32#rst# = #blu#10#rst#\n" |
| " y: #gre#test.fidlcodec.examples/TraversalStruct#rst# = {\n" |
| " a: #gre#uint32#rst# = #blu#20#rst#\n" |
| " " + |
| HandleToPretty("b", 0x100) + |
| "\n" |
| " }\n" |
| " }\n" |
| " {\n" |
| " x: #gre#uint32#rst# = #blu#30#rst#\n" |
| " y: #gre#test.fidlcodec.examples/TraversalStruct#rst# = {\n" |
| " a: #gre#uint32#rst# = #blu#40#rst#\n" |
| " " + |
| HandleToPretty("b", 0x101) + |
| "\n" |
| " }\n" |
| " }\n" |
| " ]\n" |
| " s: #gre#test.fidlcodec.examples/TraversalStruct#rst# = { " |
| "a: #gre#uint32#rst# = #blu#50#rst#, " |
| "b: #gre#handle#rst# = #red#00000000#rst# }\n" |
| "}"; |
| } |
| std::vector<std::unique_ptr<test::fidlcodec::examples::TraversalMain>> GetV() { |
| std::vector<std::unique_ptr<test::fidlcodec::examples::TraversalMain>> result; |
| auto object1 = std::make_unique<test::fidlcodec::examples::TraversalMain>(); |
| object1->x = 10; |
| auto object2 = std::make_unique<test::fidlcodec::examples::TraversalStruct>(); |
| object2->a = 20; |
| object2->b = std::move(out1_); |
| object1->y = std::move(object2); |
| result.emplace_back(std::move(object1)); |
| auto object3 = std::make_unique<test::fidlcodec::examples::TraversalMain>(); |
| object3->x = 30; |
| auto object4 = std::make_unique<test::fidlcodec::examples::TraversalStruct>(); |
| object4->a = 40; |
| object4->b = std::move(out2_); |
| object3->y = std::move(object4); |
| result.emplace_back(std::move(object3)); |
| return result; |
| } |
| |
| std::unique_ptr<test::fidlcodec::examples::TraversalStruct> GetS() { |
| auto result = std::make_unique<test::fidlcodec::examples::TraversalStruct>(); |
| result->a = 50; |
| return result; |
| } |
| |
| std::string GetJSON() { return json_; } |
| std::string GetPretty() { return pretty_; } |
| |
| private: |
| zx::channel out1_; |
| zx::channel out2_; |
| |
| std::string json_; |
| std::string pretty_; |
| }; |
| |
| } // namespace |
| |
| TEST_F(WireParserTest, ParseTraversalMain) { |
| TraversalMainSupport support_v1; |
| TEST_DECODE_WIRE_BODY(TraversalMainMessage, support_v1.GetJSON(), support_v1.GetPretty(), |
| support_v1.GetV(), support_v1.GetS()); |
| } |
| |
| // Corrupt data tests |
| |
| TEST_F(WireParserTest, BadSchemaPrintHex) { |
| std::ostringstream log_msg; |
| fidl_codec::logger::LogCapturer capturer(&log_msg); |
| // i32 in the schema is missing "subtype": "int32" |
| std::string bad_schema = R"FIDL({ |
| "version": "0.0.1", |
| "name": "fidl.examples.types", |
| "library_dependencies": [], |
| "bits_declarations": [], |
| "const_declarations": [], |
| "enum_declarations": [], |
| "interface_declarations": [ |
| { |
| "name": "test.fidlcodec.examples/FidlCodecTestInterface", |
| "location": { |
| "filename": "../../src/lib/fidl_codec/testdata/types.test.fidl", |
| "line": 11, |
| "column": 10 |
| }, |
| "methods": [ |
| { |
| "ordinal": 1593056155789170713, |
| "name": "Int32", |
| "location": { |
| "filename": "../../src/lib/fidl_codec/testdata/types.test.fidl", |
| "line": 16, |
| "column": 5 |
| }, |
| "has_request": true, |
| "maybe_request": [ |
| { |
| "type": { |
| "kind": "primitive" |
| }, |
| "name": "i32", |
| "location": { |
| "filename": "../../src/lib/fidl_codec/testdata/types.test.fidl", |
| "line": 16, |
| "column": 17 |
| }, |
| "size": 4, |
| "max_out_of_line": 0, |
| "alignment": 4, |
| "offset": 16, |
| "max_handles": 0, |
| "field_shape_old": { |
| "offset": 16, |
| "padding": 0 |
| }, |
| "field_shape_v1": { |
| "offset": 16, |
| "padding": 0 |
| } |
| } |
| ], |
| "maybe_request_size": 24, |
| "maybe_request_alignment": 8, |
| "maybe_request_type_shape_old": { |
| "inline_size": 24, |
| "alignment": 8, |
| "depth": 0, |
| "max_handles": 0, |
| "max_out_of_line": 0, |
| "has_padding": true, |
| "has_flexible_envelope": false |
| }, |
| "maybe_request_type_shape_v1": { |
| "inline_size": 24, |
| "alignment": 8, |
| "depth": 0, |
| "max_handles": 0, |
| "max_out_of_line": 0, |
| "has_padding": true, |
| "has_flexible_envelope": false |
| }, |
| "has_response": false, |
| "is_composed": false |
| } |
| ] |
| } |
| ], |
| "struct_declarations": [], |
| "table_declarations": [], |
| "union_declarations": [], |
| "xunion_declarations": [] |
| })FIDL"; |
| LibraryReadError err; |
| LibraryLoader loader; |
| loader.AddContent(bad_schema, &err); |
| ASSERT_TRUE(err.value == LibraryReadError::ErrorValue::kOk); |
| fidl::IncomingMessageBuffer buffer; |
| fidl::HLCPPIncomingMessage message = buffer.CreateEmptyIncomingMessage(); |
| |
| InterceptRequest<test::fidlcodec::examples::FidlCodecTestInterface>( |
| message, [](fidl::InterfacePtr<test::fidlcodec::examples::FidlCodecTestInterface>& ptr) { |
| ptr->Int32(kUninitialized); |
| }); |
| |
| fidl_message_header_t header = message.header(); |
| |
| zx_handle_disposition_t* handle_dispositions = nullptr; |
| if (message.handles().size() > 0) { |
| handle_dispositions = new zx_handle_disposition_t[message.handles().size()]; |
| for (uint32_t i = 0; i < message.handles().size(); ++i) { |
| handle_dispositions[i].operation = fidl_codec::kNoHandleDisposition; |
| handle_dispositions[i].handle = message.handles().data()[i].handle; |
| handle_dispositions[i].type = ZX_OBJ_TYPE_NONE; |
| handle_dispositions[i].rights = 0; |
| handle_dispositions[i].result = ZX_OK; |
| } |
| } |
| |
| const std::vector<const InterfaceMethod*>* methods = loader.GetByOrdinal(header.ordinal); |
| ASSERT_NE(methods, nullptr); |
| ASSERT_TRUE(!methods->empty()); |
| |
| const InterfaceMethod* method = (*methods)[0]; |
| // If this is null, you probably have to update the schema above. |
| ASSERT_NE(method, nullptr); |
| |
| std::unique_ptr<fidl_codec::StructValue> decoded_request; |
| std::stringstream error_stream; |
| fidl_codec::DecodeRequest(method, message.bytes().data(), message.bytes().size(), |
| handle_dispositions, message.handles().size(), &decoded_request, |
| error_stream); |
| rapidjson::Document actual; |
| if (decoded_request != nullptr) { |
| decoded_request->ExtractJson(actual.GetAllocator(), actual); |
| } |
| |
| // Checks that an invalid type generates an invalid value. |
| ASSERT_STREQ(actual["i32"].GetString(), "(invalid)"); |
| |
| delete[] handle_dispositions; |
| ASSERT_STREQ(log_msg.str().c_str(), "Invalid type"); |
| } |
| |
| // Checks that MessageDecoder::DecodeValue doesn't core dump with a null type. |
| TEST_F(WireParserTest, DecodeNullTypeValue) { |
| std::stringstream error_stream; |
| fidl_message_header_t header; |
| MessageDecoder decoder(reinterpret_cast<uint8_t*>(&header), sizeof(header), nullptr, 0, |
| error_stream); |
| decoder.DecodeValue(nullptr); |
| } |
| |
| } // namespace fidl_codec |
