| // Copyright 2018 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 <limits.h> |
| #include <memory> |
| #include <stddef.h> |
| |
| #include <lib/fidl/coding.h> |
| #include <lib/fidl/cpp/string_view.h> |
| #include <lib/fidl/cpp/vector_view.h> |
| #include <unittest/unittest.h> |
| #include <zircon/syscalls.h> |
| |
| #include "fidl_coded_types.h" |
| #include "fidl_structs.h" |
| #include "fidl/extra_messages.h" |
| |
| namespace fidl { |
| namespace { |
| |
| bool linearize_present_nonnullable_string() { |
| BEGIN_TEST; |
| |
| unbounded_nonnullable_string_inline_data message = {}; |
| constexpr const char* kStr = "hello!"; |
| constexpr size_t kLength = 6; |
| |
| char some_other_string[kLength] = {0}; |
| message.string = fidl_string_t{kLength, some_other_string}; |
| memcpy(some_other_string, kStr, kLength); |
| |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| |
| // Manually compute linearized size |
| constexpr uint32_t buf_size = 32u + FIDL_ALIGN(kLength); |
| // Allocate a buffer of the specified size |
| std::unique_ptr<uint8_t[]> buf(new uint8_t[buf_size]); |
| status = fidl_linearize(&unbounded_nonnullable_string_message_type, |
| &message, buf.get(), buf_size, &actual_num_bytes, &error); |
| EXPECT_EQ(status, ZX_OK); |
| EXPECT_NULL(error, error); |
| EXPECT_EQ(actual_num_bytes, buf_size); |
| // Verify pointers and object packing |
| auto inline_data = reinterpret_cast<unbounded_nonnullable_string_inline_data*>(buf.get()); |
| EXPECT_EQ(static_cast<void*>(inline_data->string.data), |
| static_cast<void*>(&buf[FIDL_ALIGN(sizeof(message))])); |
| EXPECT_BYTES_EQ(reinterpret_cast<const uint8_t*>("hello!"), |
| reinterpret_cast<const uint8_t*>(inline_data->string.data), |
| kLength, |
| "Secondary object string must be hello!"); |
| |
| END_TEST; |
| } |
| |
| bool linearize_present_nonnullable_string_unaligned_error() { |
| BEGIN_TEST; |
| |
| unbounded_nonnullable_string_inline_data message = {}; |
| constexpr const char* kStr = "hello!"; |
| constexpr size_t kLength = 6; |
| |
| char some_other_string[kLength] = {0}; |
| message.string = fidl_string_t{kLength, some_other_string}; |
| memcpy(some_other_string, kStr, kLength); |
| |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| |
| // Pass in an unaligned storage |
| constexpr uint32_t buf_size = 32u + FIDL_ALIGN(kLength); |
| std::unique_ptr<uint8_t[]> buf(new uint8_t[buf_size * 2]); |
| uint8_t* unaligned_ptr = buf.get() + 1; |
| status = fidl_linearize(&unbounded_nonnullable_string_message_type, |
| &message, unaligned_ptr, buf_size, &actual_num_bytes, &error); |
| EXPECT_EQ(status, ZX_ERR_INVALID_ARGS); |
| EXPECT_NONNULL(error); |
| ASSERT_STR_STR(error, "must be aligned to FIDL_ALIGNMENT"); |
| |
| END_TEST; |
| } |
| |
| bool linearize_present_nonnullable_longer_string() { |
| BEGIN_TEST; |
| |
| unbounded_nonnullable_string_inline_data message = {}; |
| constexpr const char* kStr = "hello world!"; |
| constexpr size_t kLength = 12; |
| |
| char some_other_string[kLength] = {0}; |
| message.string = fidl_string_t{kLength, some_other_string}; |
| memcpy(some_other_string, kStr, kLength); |
| |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| |
| // Manually compute linearized size |
| constexpr uint32_t buf_size = 32u + FIDL_ALIGN(kLength); |
| |
| // For non-handle-containing structures, linearizing should not change anything |
| const unbounded_nonnullable_string_inline_data message_shallow_copy = message; |
| |
| // Allocate a buffer of the specified size |
| std::unique_ptr<uint8_t[]> buf(new uint8_t[buf_size]); |
| status = fidl_linearize(&unbounded_nonnullable_string_message_type, |
| &message, buf.get(), buf_size, &actual_num_bytes, &error); |
| EXPECT_EQ(status, ZX_OK); |
| EXPECT_NULL(error, error); |
| EXPECT_EQ(actual_num_bytes, buf_size); |
| // Verify pointers and object packing |
| auto inline_data = reinterpret_cast<unbounded_nonnullable_string_inline_data*>(buf.get()); |
| EXPECT_EQ(static_cast<void*>(inline_data->string.data), |
| static_cast<void*>(&buf[FIDL_ALIGN(sizeof(message))])); |
| EXPECT_BYTES_EQ(reinterpret_cast<const uint8_t*>("hello world!"), |
| reinterpret_cast<const uint8_t*>(inline_data->string.data), |
| kLength, |
| "Secondary object string must be hello world!"); |
| // Verify that message is not destroyed |
| EXPECT_BYTES_EQ(reinterpret_cast<const uint8_t*>(&message_shallow_copy), |
| reinterpret_cast<uint8_t*>(&message), |
| sizeof(message), |
| "Input object should not change"); |
| |
| // Linearizing with a buffer size smaller than allowed should error out |
| status = fidl_linearize(&unbounded_nonnullable_string_message_type, |
| &message, buf.get(), buf_size - 1, nullptr, &error); |
| EXPECT_EQ(status, ZX_ERR_BUFFER_TOO_SMALL); |
| EXPECT_NONNULL(error, "Should report error when buffer too small"); |
| |
| END_TEST; |
| } |
| |
| bool linearize_vector_of_uint32() { |
| BEGIN_TEST; |
| |
| // Linearizing this array... |
| constexpr uint32_t array_len = 40; |
| std::unique_ptr<uint32_t[]> numbers(new uint32_t[array_len]); |
| for (uint32_t i = 0; i < array_len; i++) { |
| numbers[i] = i; |
| } |
| // into this buffer, which is big enough for the entire message |
| constexpr uint32_t buf_size = 512; |
| std::unique_ptr<uint8_t[]> buffer(new uint8_t[buf_size]); |
| |
| unbounded_nonnullable_vector_of_uint32_inline_data message = {}; |
| message.header.flags = 123; |
| message.header.ordinal = 456; |
| message.header.txid = 789; |
| message.vector = (fidl_vector_t) { |
| .count = array_len, |
| .data = numbers.get(), |
| }; |
| |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(&unbounded_nonnullable_vector_of_uint32_message_type, |
| &message, |
| buffer.get(), |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| ASSERT_EQ(status, ZX_OK); |
| ASSERT_NULL(error, error); |
| ASSERT_GT(actual_num_bytes, sizeof(message)); |
| |
| // Verify that vector contents have been copied copied correctly |
| auto linearized_message = |
| reinterpret_cast<unbounded_nonnullable_vector_of_uint32_inline_data*>(buffer.get()); |
| EXPECT_NONNULL(linearized_message->vector.data); |
| EXPECT_NE(linearized_message->vector.data, message.vector.data); |
| auto copied_numbers = reinterpret_cast<uint32_t*>(linearized_message->vector.data); |
| for (uint32_t i = 0; i < array_len; i++) { |
| EXPECT_EQ(copied_numbers[i], i); |
| } |
| EXPECT_EQ(memcmp(&message.header, |
| &linearized_message->header, |
| sizeof(message.header)), 0); |
| |
| // Verify that linearizing with less number of bytes does fail |
| status = fidl_linearize(&unbounded_nonnullable_vector_of_uint32_message_type, |
| &message, |
| buffer.get(), |
| actual_num_bytes - 1, |
| nullptr, |
| &error); |
| EXPECT_EQ(status, ZX_ERR_BUFFER_TOO_SMALL); |
| EXPECT_NONNULL(error); |
| |
| END_TEST; |
| } |
| |
| bool linearize_vector_of_string() { |
| BEGIN_TEST; |
| |
| // Define the memory-layout of the inline object |
| struct VectorOfStringRequest { |
| alignas(FIDL_ALIGNMENT) |
| fidl_message_header_t header; |
| fidl::VectorView<fidl::StringView> vector; |
| }; |
| |
| // Serialize these strings... |
| const char str1[] = "Open connection,"; |
| const char str2[] = "Send the wrong FIDL message,"; |
| const char str3[] = "Get an epitaph."; |
| // into this buffer, which is big enough for the entire message |
| constexpr uint32_t buf_size = 512; |
| std::unique_ptr<uint8_t[]> buffer(new uint8_t[buf_size]); |
| |
| fidl::StringView strings[3] = {}; |
| strings[0].set_data(const_cast<char*>(str1)); |
| strings[0].set_size(sizeof(str1)); |
| strings[1].set_data(const_cast<char*>(str2)); |
| strings[1].set_size(sizeof(str2)); |
| strings[2].set_data(const_cast<char*>(str3)); |
| strings[2].set_size(sizeof(str3)); |
| |
| VectorOfStringRequest message; |
| message.vector.set_data(strings); |
| message.vector.set_count(3); |
| |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(&fidl_test_coding_LinearizerTestVectorOfStringRequestTable, |
| &message, |
| buffer.get(), |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| ASSERT_EQ(status, ZX_OK); |
| ASSERT_NULL(error, error); |
| ASSERT_GT(actual_num_bytes, sizeof(message)); |
| |
| // Verify that vector contents have been copied copied correctly |
| auto linearized_message = |
| reinterpret_cast<VectorOfStringRequest*>(buffer.get()); |
| EXPECT_NONNULL(linearized_message->vector.data()); |
| EXPECT_EQ(linearized_message->vector.count(), 3); |
| |
| EXPECT_NE(linearized_message->vector[0].data(), str1); |
| EXPECT_BYTES_EQ( |
| reinterpret_cast<const uint8_t*>(linearized_message->vector[0].data()), |
| reinterpret_cast<const uint8_t*>(str1), |
| sizeof(str1), |
| str1); |
| EXPECT_NE(linearized_message->vector[1].data(), str2); |
| EXPECT_BYTES_EQ( |
| reinterpret_cast<const uint8_t*>(linearized_message->vector[1].data()), |
| reinterpret_cast<const uint8_t*>(str2), |
| sizeof(str2), |
| str2); |
| EXPECT_NE(linearized_message->vector[2].data(), str3); |
| EXPECT_BYTES_EQ( |
| reinterpret_cast<const uint8_t*>(linearized_message->vector[2].data()), |
| reinterpret_cast<const uint8_t*>(str3), |
| sizeof(str3), |
| str3); |
| |
| END_TEST; |
| } |
| |
| bool linearize_struct_with_handle() { |
| BEGIN_TEST; |
| |
| constexpr zx_handle_t dummy_handle = static_cast<zx_handle_t>(42); |
| |
| // Define the memory-layout of the inline object |
| struct StructWithHandle { |
| alignas(FIDL_ALIGNMENT) |
| zx_handle_t h; |
| int32_t foo; |
| }; |
| |
| // Since there are no out-of-line objects, the size is known |
| constexpr uint32_t buf_size = sizeof(StructWithHandle); |
| StructWithHandle message = { |
| .h = dummy_handle, |
| .foo = 0, |
| }; |
| uint8_t buffer[buf_size]; |
| |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(&fidl_test_coding_StructWithHandleTable, |
| &message, |
| buffer, |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| ASSERT_EQ(status, ZX_OK); |
| ASSERT_EQ(actual_num_bytes, sizeof(StructWithHandle)); |
| ASSERT_NULL(error, error); |
| |
| // Handles in the original object are moved |
| auto linearized_message = reinterpret_cast<StructWithHandle*>(buffer); |
| EXPECT_EQ(message.h, ZX_HANDLE_INVALID); |
| EXPECT_EQ(linearized_message->h, dummy_handle); |
| |
| END_TEST; |
| } |
| |
| bool linearize_struct_with_many_handles() { |
| BEGIN_TEST; |
| |
| zx_handle_t dummy_handles[4] = {}; |
| auto handle_value_at = [] (int i) ->zx_handle_t { return static_cast<zx_handle_t>(100 + i); }; |
| for (int i = 0; i < 4; i++) { |
| dummy_handles[i] = handle_value_at(i); |
| } |
| |
| // Define the memory-layout of the inline object |
| struct StructWithManyHandles { |
| alignas(FIDL_ALIGNMENT) |
| zx_handle_t h1; |
| zx_handle_t h2; |
| fidl::VectorView<zx_handle_t> hs; |
| }; |
| |
| fidl::VectorView<zx_handle_t> hs; |
| hs.set_count(2); |
| hs.set_data(&dummy_handles[2]); |
| |
| constexpr uint32_t buf_size = 512; |
| StructWithManyHandles message = { |
| .h1 = dummy_handles[0], |
| .h2 = dummy_handles[1], |
| .hs = hs, |
| }; |
| uint8_t buffer[buf_size]; |
| |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(&fidl_test_coding_StructWithManyHandlesTable, |
| &message, |
| buffer, |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| ASSERT_EQ(status, ZX_OK); |
| ASSERT_GT(actual_num_bytes, sizeof(StructWithManyHandles)); |
| ASSERT_NULL(error, error); |
| |
| // Handles in the original object are moved |
| auto linearized_message = reinterpret_cast<StructWithManyHandles*>(buffer); |
| EXPECT_EQ(message.h1, ZX_HANDLE_INVALID); |
| EXPECT_EQ(message.h2, ZX_HANDLE_INVALID); |
| EXPECT_EQ(message.hs[0], ZX_HANDLE_INVALID); |
| EXPECT_EQ(message.hs[1], ZX_HANDLE_INVALID); |
| EXPECT_EQ(linearized_message->h1, handle_value_at(0)); |
| EXPECT_EQ(linearized_message->h2, handle_value_at(1)); |
| EXPECT_EQ(linearized_message->hs[0], handle_value_at(2)); |
| EXPECT_EQ(linearized_message->hs[1], handle_value_at(3)); |
| |
| END_TEST; |
| } |
| |
| bool linearize_simple_table() { |
| BEGIN_TEST; |
| |
| SimpleTableEnvelopes envelopes = {}; |
| SimpleTable simple_table; |
| simple_table.set_count(5); |
| simple_table.set_data(&envelopes.x); |
| |
| IntStruct x = {10}; |
| IntStruct y = {20}; |
| envelopes.x.data = &x; |
| envelopes.y.data = &y; |
| |
| // Attempt to linearize with different table schemas to verify evolution-compatibility |
| for (auto coding_table : { |
| &fidl_test_coding_SimpleTableTable, |
| &fidl_test_coding_NewerSimpleTableTable |
| }) { |
| constexpr uint32_t buf_size = 512; |
| uint8_t buffer[buf_size]; |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(coding_table, |
| &simple_table, |
| buffer, |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| EXPECT_EQ(status, ZX_OK); |
| EXPECT_GT(actual_num_bytes, sizeof(SimpleTable)); |
| EXPECT_NULL(error, error); |
| |
| // Verify object placement |
| const auto& linearized = *reinterpret_cast<SimpleTable*>(buffer); |
| EXPECT_EQ(reinterpret_cast<IntStruct*>(linearized[0].data)->v, 10); |
| EXPECT_EQ(reinterpret_cast<IntStruct*>(linearized[4].data)->v, 20); |
| |
| // Verify auto-filling envelope header |
| for (int i = 0; i < 5; i++) { |
| if (i == 0 || i == 4) { |
| EXPECT_EQ(linearized[i].num_bytes, 8); |
| EXPECT_EQ(linearized[i].num_handles, 0); |
| } else { |
| EXPECT_EQ(linearized[i].num_bytes, 0); |
| EXPECT_EQ(linearized[i].num_handles, 0); |
| } |
| } |
| } |
| |
| // Alternative version with only x set, such that we can use OlderSimpleTable |
| envelopes.y.data = nullptr; |
| // Attempt to linearize with different table schemas to verify evolution-compatibility |
| for (auto coding_table : { |
| &fidl_test_coding_OlderSimpleTableTable, |
| &fidl_test_coding_SimpleTableTable, |
| &fidl_test_coding_NewerSimpleTableTable |
| }) { |
| constexpr uint32_t buf_size = 512; |
| uint8_t buffer[buf_size]; |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(coding_table, |
| &simple_table, |
| buffer, |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| EXPECT_EQ(status, ZX_OK); |
| EXPECT_GT(actual_num_bytes, sizeof(SimpleTable)); |
| EXPECT_NULL(error, error); |
| |
| // Verify object placement |
| const auto& linearized = *reinterpret_cast<SimpleTable*>(buffer); |
| EXPECT_EQ(reinterpret_cast<IntStruct*>(linearized[0].data)->v, 10); |
| |
| // Verify auto-filling envelope header |
| EXPECT_EQ(linearized[0].num_bytes, 8); |
| EXPECT_EQ(linearized[0].num_handles, 0); |
| for (int i = 1; i < 5; i++) { |
| EXPECT_EQ(linearized[i].num_bytes, 0); |
| EXPECT_EQ(linearized[i].num_handles, 0); |
| } |
| } |
| |
| // If y is set, |
| envelopes.y.data = &y; |
| // but OlderSimpleTable is used, it should error as the walker does not know how to process y. |
| { |
| constexpr uint32_t buf_size = 512; |
| uint8_t buffer[buf_size]; |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(&fidl_test_coding_OlderSimpleTableTable, |
| &simple_table, |
| buffer, |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| EXPECT_EQ(status, ZX_ERR_INVALID_ARGS); |
| EXPECT_EQ(actual_num_bytes, 0); |
| EXPECT_NONNULL(error); |
| } |
| |
| END_TEST; |
| } |
| |
| namespace { |
| |
| // Define the memory-layout of the inline object, for the group of tests below |
| using TableOfStruct = fidl::VectorView<fidl_envelope_t>; |
| struct TableOfStructEnvelopes { |
| alignas(FIDL_ALIGNMENT) |
| fidl_envelope_t a; |
| fidl_envelope_t b; |
| }; |
| struct OrdinalOneStructWithHandle { |
| alignas(FIDL_ALIGNMENT) |
| zx_handle_t h; |
| int32_t foo; |
| }; |
| struct OrdinalTwoStructWithManyHandles { |
| alignas(FIDL_ALIGNMENT) |
| zx_handle_t h1; |
| zx_handle_t h2; |
| fidl::VectorView<zx_handle_t> hs; |
| }; |
| |
| bool linearize_table_field_1() { |
| BEGIN_TEST; |
| |
| TableOfStructEnvelopes envelopes = {}; |
| TableOfStruct table; |
| table.set_count(1); |
| table.set_data(&envelopes.a); |
| |
| constexpr zx_handle_t dummy_handle = static_cast<zx_handle_t>(42); |
| OrdinalOneStructWithHandle ordinal1 = { |
| .h = dummy_handle, |
| .foo = 0 |
| }; |
| envelopes.a.data = &ordinal1; |
| |
| constexpr uint32_t buf_size = 512; |
| uint8_t buffer[buf_size]; |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(&fidl_test_coding_TableOfStructWithHandleTable, |
| &table, |
| buffer, |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| EXPECT_EQ(status, ZX_OK); |
| EXPECT_GT(actual_num_bytes, sizeof(TableOfStruct)); |
| EXPECT_NULL(error, error); |
| |
| // Verify that handles have been moved |
| const auto& linearized = *reinterpret_cast<TableOfStruct*>(buffer); |
| EXPECT_EQ(reinterpret_cast<OrdinalOneStructWithHandle*>(linearized[0].data)->h, dummy_handle); |
| EXPECT_EQ(ordinal1.h, ZX_HANDLE_INVALID); |
| |
| // Verify auto-filling envelope header |
| EXPECT_EQ(linearized[0].num_bytes, sizeof(ordinal1)); |
| EXPECT_EQ(linearized[0].num_handles, 1); |
| |
| END_TEST; |
| } |
| |
| bool linearize_table_field_2() { |
| BEGIN_TEST; |
| |
| TableOfStructEnvelopes envelopes = {}; |
| TableOfStruct table; |
| table.set_count(2); |
| table.set_data(&envelopes.a); |
| |
| zx_handle_t dummy_handles[4] = {}; |
| auto handle_value_at = [] (int i) ->zx_handle_t { return static_cast<zx_handle_t>(100 + i); }; |
| for (int i = 0; i < 4; i++) { |
| dummy_handles[i] = handle_value_at(i); |
| } |
| fidl::VectorView<zx_handle_t> hs; |
| hs.set_count(2); |
| hs.set_data(&dummy_handles[2]); |
| |
| OrdinalTwoStructWithManyHandles ordinal2 = { |
| .h1 = dummy_handles[0], |
| .h2 = dummy_handles[1], |
| .hs = hs, |
| }; |
| envelopes.b.data = &ordinal2; |
| |
| constexpr uint32_t buf_size = 512; |
| uint8_t buffer[buf_size]; |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(&fidl_test_coding_TableOfStructWithHandleTable, |
| &table, |
| buffer, |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| EXPECT_EQ(status, ZX_OK); |
| EXPECT_GT(actual_num_bytes, sizeof(TableOfStruct)); |
| EXPECT_NULL(error, error); |
| |
| // Verify that handles have been moved |
| const auto& linearized = *reinterpret_cast<TableOfStruct*>(buffer); |
| auto linearized_field = reinterpret_cast<OrdinalTwoStructWithManyHandles*>(linearized[1].data); |
| ASSERT_NONNULL(linearized_field); |
| EXPECT_EQ(linearized_field->h1, handle_value_at(0)); |
| EXPECT_EQ(ordinal2.h1, ZX_HANDLE_INVALID); |
| EXPECT_EQ(linearized_field->h2, handle_value_at(1)); |
| EXPECT_EQ(ordinal2.h2, ZX_HANDLE_INVALID); |
| EXPECT_EQ(linearized_field->hs[0], handle_value_at(2)); |
| EXPECT_EQ(ordinal2.hs[0], ZX_HANDLE_INVALID); |
| EXPECT_EQ(linearized_field->hs[1], handle_value_at(3)); |
| EXPECT_EQ(ordinal2.hs[1], ZX_HANDLE_INVALID); |
| |
| |
| // Verify auto-filling envelope header |
| EXPECT_EQ(linearized[0].num_bytes, 0); |
| EXPECT_EQ(linearized[0].num_handles, 0); |
| EXPECT_EQ(linearized[1].num_bytes, |
| FIDL_ALIGN(sizeof(ordinal2)) + sizeof(zx_handle_t) * hs.count()); |
| EXPECT_EQ(linearized[1].num_handles, 4); |
| |
| END_TEST; |
| } |
| |
| } // namespace |
| |
| bool linearize_xunion_empty_invariant_empty() { |
| BEGIN_TEST; |
| |
| // Non-zero ordinal with empty envelope is an error |
| SampleXUnionStruct xunion = {}; |
| xunion.xu.header = (fidl_xunion_t) { |
| .tag = kSampleXUnionIntStructOrdinal, |
| .padding = 0, |
| .envelope = {} |
| }; |
| constexpr uint32_t buf_size = 512; |
| uint8_t buffer[buf_size]; |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(&fidl_test_coding_SampleXUnionStructTable, |
| &xunion, |
| buffer, |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| EXPECT_EQ(status, ZX_ERR_INVALID_ARGS); |
| EXPECT_NONNULL(error); |
| EXPECT_STR_EQ(error, "empty xunion must have zero as ordinal"); |
| |
| END_TEST; |
| } |
| |
| bool linearize_xunion_empty_invariant_zero_ordinal() { |
| BEGIN_TEST; |
| |
| // Zero ordinal with non-empty envelope is an error |
| IntStruct int_struct = { |
| .v = 100 |
| }; |
| SampleXUnionStruct xunion = {}; |
| xunion.xu.header = (fidl_xunion_t) { |
| .tag = 0, |
| .padding = 0, |
| .envelope = (fidl_envelope_t) { |
| .num_bytes = 8, |
| .num_handles = 0, |
| .data = &int_struct |
| } |
| }; |
| constexpr uint32_t buf_size = 512; |
| uint8_t buffer[buf_size]; |
| const char* error = nullptr; |
| zx_status_t status; |
| uint32_t actual_num_bytes = 0; |
| status = fidl_linearize(&fidl_test_coding_SampleXUnionStructTable, |
| &xunion, |
| buffer, |
| buf_size, |
| &actual_num_bytes, |
| &error); |
| EXPECT_EQ(status, ZX_ERR_INVALID_ARGS); |
| EXPECT_NONNULL(error); |
| EXPECT_STR_EQ(error, "xunion with zero as ordinal must be empty"); |
| |
| END_TEST; |
| } |
| |
| BEGIN_TEST_CASE(strings) |
| RUN_TEST(linearize_present_nonnullable_string) |
| RUN_TEST(linearize_present_nonnullable_longer_string) |
| END_TEST_CASE(strings) |
| |
| BEGIN_TEST_CASE(unaligned) |
| RUN_TEST(linearize_present_nonnullable_string_unaligned_error) |
| END_TEST_CASE(unaligned) |
| |
| BEGIN_TEST_CASE(vectors) |
| RUN_TEST(linearize_vector_of_uint32) |
| RUN_TEST(linearize_vector_of_string) |
| END_TEST_CASE(vectors) |
| |
| BEGIN_TEST_CASE(handles) |
| RUN_TEST(linearize_struct_with_handle) |
| RUN_TEST(linearize_struct_with_many_handles) |
| END_TEST_CASE(handles) |
| |
| BEGIN_TEST_CASE(tables) |
| RUN_TEST(linearize_simple_table) |
| RUN_TEST(linearize_table_field_1) |
| RUN_TEST(linearize_table_field_2) |
| END_TEST_CASE(tables) |
| |
| BEGIN_TEST_CASE(xunions) |
| RUN_TEST(linearize_xunion_empty_invariant_empty) |
| RUN_TEST(linearize_xunion_empty_invariant_zero_ordinal) |
| END_TEST_CASE(xunions) |
| |
| |
| } // namespace |
| } // namespace fidl |
