| // 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 <fidl/test/compatibility/cpp/fidl.h> |
| #include <lib/async-loop/cpp/loop.h> |
| #include <lib/async/default.h> |
| #include <stdio.h> |
| #include <zircon/assert.h> |
| #include <zircon/errors.h> |
| #include <zircon/processargs.h> |
| |
| #include <algorithm> |
| #include <cstdlib> |
| #include <random> |
| #include <vector> |
| |
| #include "garnet/public/lib/fidl/compatibility_test/echo_client_app.h" |
| #include "gtest/gtest.h" |
| #include "lib/fidl/cpp/binding_set.h" |
| #include "src/lib/files/path.h" |
| #include "src/lib/fxl/strings/split_string.h" |
| #include "src/lib/fxl/strings/utf_codecs.h" |
| |
| using fidl::VectorPtr; |
| using fidl::test::compatibility::Struct; |
| using std::string; |
| |
| namespace { |
| // Want a size small enough that it doesn't get too big to transmit but |
| // large enough to exercise interesting code paths. |
| constexpr uint8_t kArbitraryVectorSize = 3; |
| // This is used as a literal constant in compatibility_test_service.fidl. |
| constexpr uint8_t kArbitraryConstant = 2; |
| |
| constexpr char kUsage[] = |
| ("Usage:\n fidl_compatibility_test foo_server bar_server\n"); |
| |
| zx::handle Handle() { |
| zx_handle_t raw_event; |
| const zx_status_t status = zx_event_create(0u, &raw_event); |
| // Can't use gtest ASSERT_EQ because we're in a non-void function. |
| ZX_ASSERT_MSG(status == ZX_OK, "status = %d", status); |
| return zx::handle(raw_event); |
| } |
| |
| ::testing::AssertionResult HandlesEq(const zx::object_base& a, |
| const zx::object_base& b) { |
| if (a.is_valid() != b.is_valid()) { |
| return ::testing::AssertionFailure() |
| << "Handles are not equally valid :" << a.is_valid() << " vs " |
| << b.is_valid(); |
| } |
| if (!a.is_valid()) { |
| return ::testing::AssertionSuccess() << "Both handles invalid"; |
| } |
| zx_info_handle_basic_t a_info, b_info; |
| zx_status_t status = zx_object_get_info( |
| a.get(), ZX_INFO_HANDLE_BASIC, &a_info, sizeof(a_info), nullptr, nullptr); |
| if (ZX_OK != status) { |
| return ::testing::AssertionFailure() |
| << "zx_object_get_info(a) returned " << status; |
| } |
| status = zx_object_get_info(b.get(), ZX_INFO_HANDLE_BASIC, &b_info, |
| sizeof(b_info), nullptr, nullptr); |
| if (ZX_OK != status) { |
| return ::testing::AssertionFailure() |
| << "zx_object_get_info(b) returned " << status; |
| } |
| if (a_info.koid != b_info.koid) { |
| return ::testing::AssertionFailure() |
| << std::endl |
| << "a_info.koid is: " << a_info.koid << std::endl |
| << "b_info.koid is: " << b_info.koid; |
| } |
| return ::testing::AssertionSuccess(); |
| } |
| |
| void ExpectEq(const Struct& a, const Struct& b) { |
| // primitive types |
| EXPECT_EQ(a.primitive_types.b, b.primitive_types.b); |
| EXPECT_EQ(a.primitive_types.i8, b.primitive_types.i8); |
| EXPECT_EQ(a.primitive_types.i16, b.primitive_types.i16); |
| EXPECT_EQ(a.primitive_types.i32, b.primitive_types.i32); |
| EXPECT_EQ(a.primitive_types.i64, b.primitive_types.i64); |
| EXPECT_EQ(a.primitive_types.u8, b.primitive_types.u8); |
| EXPECT_EQ(a.primitive_types.u16, b.primitive_types.u16); |
| EXPECT_EQ(a.primitive_types.u32, b.primitive_types.u32); |
| EXPECT_EQ(a.primitive_types.u64, b.primitive_types.u64); |
| EXPECT_EQ(a.primitive_types.f32, b.primitive_types.f32); |
| EXPECT_EQ(a.primitive_types.f64, b.primitive_types.f64); |
| |
| // arrays |
| EXPECT_EQ(a.arrays.b_0[0], b.arrays.b_0[0]); |
| EXPECT_EQ(a.arrays.i8_0[0], b.arrays.i8_0[0]); |
| EXPECT_EQ(a.arrays.i16_0[0], b.arrays.i16_0[0]); |
| EXPECT_EQ(a.arrays.i32_0[0], b.arrays.i32_0[0]); |
| EXPECT_EQ(a.arrays.i64_0[0], b.arrays.i64_0[0]); |
| EXPECT_EQ(a.arrays.u8_0[0], b.arrays.u8_0[0]); |
| EXPECT_EQ(a.arrays.u16_0[0], b.arrays.u16_0[0]); |
| EXPECT_EQ(a.arrays.u32_0[0], b.arrays.u32_0[0]); |
| EXPECT_EQ(a.arrays.u64_0[0], b.arrays.u64_0[0]); |
| EXPECT_EQ(a.arrays.f32_0[0], b.arrays.f32_0[0]); |
| EXPECT_EQ(a.arrays.f64_0[0], b.arrays.f64_0[0]); |
| EXPECT_TRUE(HandlesEq(a.arrays.handle_0[0], b.arrays.handle_0[0])); |
| for (uint32_t i = 0; i < fidl::test::compatibility::arrays_size; ++i) { |
| EXPECT_EQ(a.arrays.b_1[i], b.arrays.b_1[i]); |
| EXPECT_EQ(a.arrays.i8_1[i], b.arrays.i8_1[i]); |
| EXPECT_EQ(a.arrays.i16_1[i], b.arrays.i16_1[i]); |
| EXPECT_EQ(a.arrays.i32_1[i], b.arrays.i32_1[i]); |
| EXPECT_EQ(a.arrays.i64_1[i], b.arrays.i64_1[i]); |
| EXPECT_EQ(a.arrays.u8_1[i], b.arrays.u8_1[i]); |
| EXPECT_EQ(a.arrays.u16_1[i], b.arrays.u16_1[i]); |
| EXPECT_EQ(a.arrays.u32_1[i], b.arrays.u32_1[i]); |
| EXPECT_EQ(a.arrays.u64_1[i], b.arrays.u64_1[i]); |
| EXPECT_EQ(a.arrays.f32_1[i], b.arrays.f32_1[i]); |
| EXPECT_EQ(a.arrays.f64_1[i], b.arrays.f64_1[i]); |
| EXPECT_TRUE(HandlesEq(a.arrays.handle_1[i], b.arrays.handle_1[i])); |
| } |
| // arrays_2d |
| for (uint32_t i = 0; i < fidl::test::compatibility::arrays_size; ++i) { |
| for (uint32_t j = 0; j < kArbitraryConstant; ++j) { |
| EXPECT_EQ(a.arrays_2d.b[i][j], b.arrays_2d.b[i][j]); |
| EXPECT_EQ(a.arrays_2d.i8[i][j], b.arrays_2d.i8[i][j]); |
| EXPECT_EQ(a.arrays_2d.i16[i][j], b.arrays_2d.i16[i][j]); |
| EXPECT_EQ(a.arrays_2d.i32[i][j], b.arrays_2d.i32[i][j]); |
| EXPECT_EQ(a.arrays_2d.i64[i][j], b.arrays_2d.i64[i][j]); |
| EXPECT_EQ(a.arrays_2d.u8[i][j], b.arrays_2d.u8[i][j]); |
| EXPECT_EQ(a.arrays_2d.u16[i][j], b.arrays_2d.u16[i][j]); |
| EXPECT_EQ(a.arrays_2d.u32[i][j], b.arrays_2d.u32[i][j]); |
| EXPECT_EQ(a.arrays_2d.u64[i][j], b.arrays_2d.u64[i][j]); |
| EXPECT_EQ(a.arrays_2d.f32[i][j], b.arrays_2d.f32[i][j]); |
| EXPECT_EQ(a.arrays_2d.f64[i][j], b.arrays_2d.f64[i][j]); |
| EXPECT_TRUE(HandlesEq(a.arrays_2d.handle_handle[i][j], |
| b.arrays_2d.handle_handle[i][j])); |
| } |
| } |
| // vectors |
| EXPECT_EQ(a.vectors.b_0, b.vectors.b_0); |
| EXPECT_EQ(a.vectors.i8_0, b.vectors.i8_0); |
| EXPECT_EQ(a.vectors.i16_0, b.vectors.i16_0); |
| EXPECT_EQ(a.vectors.i32_0, b.vectors.i32_0); |
| EXPECT_EQ(a.vectors.i64_0, b.vectors.i64_0); |
| EXPECT_EQ(a.vectors.u8_0, b.vectors.u8_0); |
| EXPECT_EQ(a.vectors.u16_0, b.vectors.u16_0); |
| EXPECT_EQ(a.vectors.u32_0, b.vectors.u32_0); |
| EXPECT_EQ(a.vectors.u64_0, b.vectors.u64_0); |
| EXPECT_EQ(a.vectors.f32_0, b.vectors.f32_0); |
| EXPECT_EQ(a.vectors.f64_0, b.vectors.f64_0); |
| for (uint8_t i = 0; i < kArbitraryVectorSize; ++i) { |
| EXPECT_TRUE(HandlesEq(a.vectors.handle_0[i], b.vectors.handle_0[i])); |
| } |
| |
| for (uint8_t i = 0; i < kArbitraryVectorSize; ++i) { |
| EXPECT_EQ(a.vectors.b_1[i], b.vectors.b_1[i]); |
| EXPECT_EQ(a.vectors.i8_1[i], b.vectors.i8_1[i]); |
| EXPECT_EQ(a.vectors.i16_1[i], b.vectors.i16_1[i]); |
| EXPECT_EQ(a.vectors.i32_1[i], b.vectors.i32_1[i]); |
| EXPECT_EQ(a.vectors.i64_1[i], b.vectors.i64_1[i]); |
| EXPECT_EQ(a.vectors.u8_1[i], b.vectors.u8_1[i]); |
| EXPECT_EQ(a.vectors.u16_1[i], b.vectors.u16_1[i]); |
| EXPECT_EQ(a.vectors.u32_1[i], b.vectors.u32_1[i]); |
| EXPECT_EQ(a.vectors.u64_1[i], b.vectors.u64_1[i]); |
| EXPECT_EQ(a.vectors.f32_1[i], b.vectors.f32_1[i]); |
| EXPECT_EQ(a.vectors.f64_1[i], b.vectors.f64_1[i]); |
| for (uint8_t j = 0; j < kArbitraryConstant; ++j) { |
| EXPECT_TRUE( |
| HandlesEq(a.vectors.handle_1[i][j], b.vectors.handle_1[i][j])); |
| } |
| } |
| |
| EXPECT_EQ(a.vectors.b_sized_0, b.vectors.b_sized_0); |
| EXPECT_EQ(a.vectors.i8_sized_0, b.vectors.i8_sized_0); |
| EXPECT_EQ(a.vectors.i16_sized_0, b.vectors.i16_sized_0); |
| EXPECT_EQ(a.vectors.i32_sized_0, b.vectors.i32_sized_0); |
| EXPECT_EQ(a.vectors.i64_sized_0, b.vectors.i64_sized_0); |
| EXPECT_EQ(a.vectors.u8_sized_0, b.vectors.u8_sized_0); |
| EXPECT_EQ(a.vectors.u16_sized_0, b.vectors.u16_sized_0); |
| EXPECT_EQ(a.vectors.u32_sized_0, b.vectors.u32_sized_0); |
| EXPECT_EQ(a.vectors.u64_sized_0, b.vectors.u64_sized_0); |
| EXPECT_EQ(a.vectors.f32_sized_0, b.vectors.f32_sized_0); |
| EXPECT_EQ(a.vectors.f64_sized_0, b.vectors.f64_sized_0); |
| EXPECT_TRUE( |
| HandlesEq(a.vectors.handle_sized_0[0], b.vectors.handle_sized_0[0])); |
| |
| EXPECT_EQ(a.vectors.b_sized_1, b.vectors.b_sized_1); |
| EXPECT_EQ(a.vectors.i8_sized_1, b.vectors.i8_sized_1); |
| EXPECT_EQ(a.vectors.i16_sized_1, b.vectors.i16_sized_1); |
| EXPECT_EQ(a.vectors.i32_sized_1, b.vectors.i32_sized_1); |
| EXPECT_EQ(a.vectors.i64_sized_1, b.vectors.i64_sized_1); |
| EXPECT_EQ(a.vectors.u8_sized_1, b.vectors.u8_sized_1); |
| EXPECT_EQ(a.vectors.u16_sized_1, b.vectors.u16_sized_1); |
| EXPECT_EQ(a.vectors.u32_sized_1, b.vectors.u32_sized_1); |
| EXPECT_EQ(a.vectors.u64_sized_1, b.vectors.u64_sized_1); |
| EXPECT_EQ(a.vectors.f32_sized_1, b.vectors.f32_sized_1); |
| EXPECT_EQ(a.vectors.f64_sized_1, b.vectors.f64_sized_1); |
| for (uint32_t i = 0; i < fidl::test::compatibility::vectors_size; ++i) { |
| EXPECT_TRUE( |
| HandlesEq(a.vectors.handle_sized_1[i], b.vectors.handle_sized_1[i])); |
| } |
| |
| for (uint32_t i = 0; i < fidl::test::compatibility::vectors_size; ++i) { |
| EXPECT_EQ(a.vectors.b_sized_2[i], b.vectors.b_sized_2[i]); |
| EXPECT_EQ(a.vectors.i8_sized_2[i], b.vectors.i8_sized_2[i]); |
| EXPECT_EQ(a.vectors.i16_sized_2[i], b.vectors.i16_sized_2[i]); |
| EXPECT_EQ(a.vectors.i32_sized_2[i], b.vectors.i32_sized_2[i]); |
| EXPECT_EQ(a.vectors.i64_sized_2[i], b.vectors.i64_sized_2[i]); |
| EXPECT_EQ(a.vectors.u8_sized_2[i], b.vectors.u8_sized_2[i]); |
| EXPECT_EQ(a.vectors.u16_sized_2[i], b.vectors.u16_sized_2[i]); |
| EXPECT_EQ(a.vectors.u32_sized_2[i], b.vectors.u32_sized_2[i]); |
| EXPECT_EQ(a.vectors.u64_sized_2[i], b.vectors.u64_sized_2[i]); |
| EXPECT_EQ(a.vectors.f32_sized_2[i], b.vectors.f32_sized_2[i]); |
| EXPECT_EQ(a.vectors.f64_sized_2[i], b.vectors.f64_sized_2[i]); |
| for (uint8_t j = 0; j < kArbitraryConstant; ++j) { |
| EXPECT_TRUE(HandlesEq(a.vectors.handle_sized_2[i][j], |
| b.vectors.handle_sized_2[i][j])); |
| } |
| } |
| |
| EXPECT_EQ(a.vectors.b_nullable_0.is_null(), b.vectors.b_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.i8_nullable_0.is_null(), |
| b.vectors.i8_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.i16_nullable_0.is_null(), |
| b.vectors.i16_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.i32_nullable_0.is_null(), |
| b.vectors.i32_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.i64_nullable_0.is_null(), |
| b.vectors.i64_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.u8_nullable_0.is_null(), |
| b.vectors.u8_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.u16_nullable_0.is_null(), |
| b.vectors.u16_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.u32_nullable_0.is_null(), |
| b.vectors.u32_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.u64_nullable_0.is_null(), |
| b.vectors.u64_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.f32_nullable_0.is_null(), |
| b.vectors.f32_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.f64_nullable_0.is_null(), |
| b.vectors.f64_nullable_0.is_null()); |
| EXPECT_EQ(a.vectors.handle_nullable_0.is_null(), |
| b.vectors.handle_nullable_0.is_null()); |
| |
| EXPECT_EQ(a.vectors.b_nullable_1.is_null(), b.vectors.b_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.i8_nullable_1.is_null(), |
| b.vectors.i8_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.i16_nullable_1.is_null(), |
| b.vectors.i16_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.i32_nullable_1.is_null(), |
| b.vectors.i32_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.i64_nullable_1.is_null(), |
| b.vectors.i64_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.u8_nullable_1.is_null(), |
| b.vectors.u8_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.u16_nullable_1.is_null(), |
| b.vectors.u16_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.u32_nullable_1.is_null(), |
| b.vectors.u32_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.u64_nullable_1.is_null(), |
| b.vectors.u64_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.f32_nullable_1.is_null(), |
| b.vectors.f32_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.f64_nullable_1.is_null(), |
| b.vectors.f64_nullable_1.is_null()); |
| EXPECT_EQ(a.vectors.handle_nullable_1.is_null(), |
| b.vectors.handle_nullable_1.is_null()); |
| |
| for (uint8_t i = 0; i < kArbitraryVectorSize; ++i) { |
| EXPECT_EQ(a.vectors.i8_nullable_1.get()[i], |
| b.vectors.i8_nullable_1.get()[i]); |
| } |
| |
| EXPECT_EQ(a.vectors.b_nullable_sized_0.is_null(), |
| b.vectors.b_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.i8_nullable_sized_0.is_null(), |
| b.vectors.i8_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.i16_nullable_sized_0.is_null(), |
| b.vectors.i16_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.i32_nullable_sized_0.is_null(), |
| b.vectors.i32_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.i64_nullable_sized_0.is_null(), |
| b.vectors.i64_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.u8_nullable_sized_0.is_null(), |
| b.vectors.u8_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.u16_nullable_sized_0.is_null(), |
| b.vectors.u16_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.u32_nullable_sized_0.is_null(), |
| b.vectors.u32_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.u64_nullable_sized_0.is_null(), |
| b.vectors.u64_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.f32_nullable_sized_0.is_null(), |
| b.vectors.f32_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.f64_nullable_sized_0.is_null(), |
| b.vectors.f64_nullable_sized_0.is_null()); |
| EXPECT_EQ(a.vectors.handle_nullable_sized_0.is_null(), |
| b.vectors.handle_nullable_sized_0.is_null()); |
| |
| EXPECT_EQ(a.vectors.i16_nullable_sized_0.get(), |
| b.vectors.i16_nullable_sized_0.get()); |
| |
| EXPECT_EQ(a.vectors.b_nullable_sized_1.is_null(), |
| b.vectors.b_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.i8_nullable_sized_1.is_null(), |
| b.vectors.i8_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.i16_nullable_sized_1.is_null(), |
| b.vectors.i16_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.i32_nullable_sized_1.is_null(), |
| b.vectors.i32_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.i64_nullable_sized_1.is_null(), |
| b.vectors.i64_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.u8_nullable_sized_1.is_null(), |
| b.vectors.u8_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.u16_nullable_sized_1.is_null(), |
| b.vectors.u16_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.u32_nullable_sized_1.is_null(), |
| b.vectors.u32_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.u64_nullable_sized_1.is_null(), |
| b.vectors.u64_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.f32_nullable_sized_1.is_null(), |
| b.vectors.f32_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.f64_nullable_sized_1.is_null(), |
| b.vectors.f64_nullable_sized_1.is_null()); |
| EXPECT_EQ(a.vectors.handle_nullable_sized_1.is_null(), |
| b.vectors.handle_nullable_sized_1.is_null()); |
| |
| EXPECT_EQ(a.vectors.f64_nullable_sized_1.get(), |
| b.vectors.f64_nullable_sized_1.get()); |
| |
| EXPECT_EQ(a.vectors.b_nullable_sized_2.is_null(), |
| b.vectors.b_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.i8_nullable_sized_2.is_null(), |
| b.vectors.i8_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.i16_nullable_sized_2.is_null(), |
| b.vectors.i16_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.i32_nullable_sized_2.is_null(), |
| b.vectors.i32_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.i64_nullable_sized_2.is_null(), |
| b.vectors.i64_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.u8_nullable_sized_2.is_null(), |
| b.vectors.u8_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.u16_nullable_sized_2.is_null(), |
| b.vectors.u16_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.u32_nullable_sized_2.is_null(), |
| b.vectors.u32_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.u64_nullable_sized_2.is_null(), |
| b.vectors.u64_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.f32_nullable_sized_2.is_null(), |
| b.vectors.f32_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.f64_nullable_sized_2.is_null(), |
| b.vectors.f64_nullable_sized_2.is_null()); |
| EXPECT_EQ(a.vectors.handle_nullable_sized_2.is_null(), |
| b.vectors.handle_nullable_sized_2.is_null()); |
| |
| for (uint32_t i = 0; i < fidl::test::compatibility::vectors_size; ++i) { |
| for (uint8_t j = 0; j < kArbitraryConstant; ++j) { |
| EXPECT_TRUE(HandlesEq(a.vectors.handle_nullable_sized_2.get()[i][j], |
| b.vectors.handle_nullable_sized_2.get()[i][j])); |
| } |
| } |
| |
| // handles |
| EXPECT_TRUE(HandlesEq(a.handles.handle_handle, b.handles.handle_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.process_handle, b.handles.process_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.thread_handle, b.handles.thread_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.vmo_handle, b.handles.vmo_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.event_handle, b.handles.event_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.port_handle, b.handles.port_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.log_handle, b.handles.log_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.socket_handle, b.handles.socket_handle)); |
| EXPECT_TRUE( |
| HandlesEq(a.handles.eventpair_handle, b.handles.eventpair_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.job_handle, b.handles.job_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.vmar_handle, b.handles.vmar_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.fifo_handle, b.handles.fifo_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.timer_handle, b.handles.timer_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_handle_handle, |
| b.handles.nullable_handle_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_process_handle, |
| b.handles.nullable_process_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_thread_handle, |
| b.handles.nullable_thread_handle)); |
| EXPECT_TRUE( |
| HandlesEq(a.handles.nullable_vmo_handle, b.handles.nullable_vmo_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_channel_handle, |
| b.handles.nullable_channel_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_event_handle, |
| b.handles.nullable_event_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_port_handle, |
| b.handles.nullable_port_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_interrupt_handle, |
| b.handles.nullable_interrupt_handle)); |
| EXPECT_TRUE( |
| HandlesEq(a.handles.nullable_log_handle, b.handles.nullable_log_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_socket_handle, |
| b.handles.nullable_socket_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_eventpair_handle, |
| b.handles.nullable_eventpair_handle)); |
| EXPECT_TRUE( |
| HandlesEq(a.handles.nullable_job_handle, b.handles.nullable_job_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_vmar_handle, |
| b.handles.nullable_vmar_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_fifo_handle, |
| b.handles.nullable_fifo_handle)); |
| EXPECT_TRUE(HandlesEq(a.handles.nullable_timer_handle, |
| b.handles.nullable_timer_handle)); |
| |
| // strings |
| EXPECT_EQ(a.strings.s, b.strings.s); |
| EXPECT_EQ(a.strings.size_0_s, b.strings.size_0_s); |
| EXPECT_EQ(a.strings.size_1_s, b.strings.size_1_s); |
| EXPECT_EQ(a.strings.nullable_size_0_s.get(), |
| b.strings.nullable_size_0_s.get()); |
| EXPECT_EQ(a.strings.nullable_size_1_s.is_null(), |
| b.strings.nullable_size_1_s.is_null()); |
| |
| // enums |
| EXPECT_EQ(a.default_enum, b.default_enum); |
| EXPECT_EQ(a.i8_enum, b.i8_enum); |
| EXPECT_EQ(a.i16_enum, b.i16_enum); |
| EXPECT_EQ(a.i32_enum, b.i32_enum); |
| EXPECT_EQ(a.i64_enum, b.i64_enum); |
| EXPECT_EQ(a.u8_enum, b.u8_enum); |
| EXPECT_EQ(a.u16_enum, b.u16_enum); |
| EXPECT_EQ(a.u32_enum, b.u32_enum); |
| EXPECT_EQ(a.u64_enum, b.u64_enum); |
| |
| // structs |
| EXPECT_EQ(a.structs.s.s, b.structs.s.s); |
| EXPECT_EQ(a.structs.nullable_s, b.structs.nullable_s); |
| |
| // empty structs |
| EXPECT_TRUE(fidl::Equals(a.structs.es, b.structs.es)); |
| EXPECT_EQ(a.structs.es.__reserved, 0u); |
| |
| // unions |
| EXPECT_EQ(a.unions.u.is_s(), b.unions.u.is_s()); |
| EXPECT_EQ(a.unions.u.s(), b.unions.u.s()); |
| EXPECT_EQ(a.unions.nullable_u->is_b(), b.unions.nullable_u->is_b()); |
| EXPECT_EQ(a.unions.nullable_u->b(), b.unions.nullable_u->b()); |
| |
| // bool |
| EXPECT_EQ(a.b, b.b); |
| } |
| |
| std::string RandomUTF8(size_t count) { |
| // Prepare randomness. |
| std::default_random_engine rand_engine; |
| // Using randomness to avoid having to come up with varied values by hand. |
| // Seed deterministically so that this function's outputs are predictable. |
| rand_engine.seed(count); |
| std::uniform_int_distribution<uint32_t> uint32_distribution; |
| |
| std::string random_string; |
| random_string.reserve(count); |
| do { |
| // Generate a random 32 bit unsigned int to use a the code point. |
| uint32_t code_point = uint32_distribution(rand_engine); |
| // Mask the random number so that it can be encoded into the number of bytes |
| // remaining. |
| size_t remaining = count - random_string.size(); |
| if (remaining == 1) { |
| code_point &= 0x7F; |
| } else if (remaining == 2) { |
| code_point &= 0x7FF; |
| } else if (remaining == 3) { |
| code_point &= 0xFFFF; |
| } else { |
| // Mask to fall within the general range of code points. |
| code_point &= 0x1FFFFF; |
| } |
| // Check that it's really a valid code point, otherwise try again. |
| if (!fxl::IsValidCodepoint(code_point)) { |
| continue; |
| } |
| // Add the character to the random string. |
| fxl::WriteUnicodeCharacter(code_point, &random_string); |
| FXL_CHECK(random_string.size() <= count); |
| } while (random_string.size() < count); |
| return random_string; |
| } |
| |
| void Initialize(Struct* s) { |
| // Prepare randomness. |
| std::default_random_engine rand_engine; |
| // Using randomness to avoid having to come up with varied values by hand. |
| // Seed deterministically so that this function's outputs are predictable. |
| rand_engine.seed(42); |
| std::uniform_int_distribution<bool> bool_distribution; |
| std::uniform_int_distribution<int8_t> int8_distribution; |
| std::uniform_int_distribution<int16_t> int16_distribution; |
| std::uniform_int_distribution<int32_t> int32_distribution; |
| std::uniform_int_distribution<int64_t> int64_distribution; |
| std::uniform_int_distribution<uint8_t> uint8_distribution; |
| std::uniform_int_distribution<uint16_t> uint16_distribution; |
| std::uniform_int_distribution<uint32_t> uint32_distribution; |
| std::uniform_int_distribution<uint64_t> uint64_distribution; |
| std::uniform_real_distribution<float> float_distribution; |
| std::uniform_real_distribution<double> double_distribution; |
| std::string random_string = |
| RandomUTF8(fidl::test::compatibility::strings_size); |
| std::string random_short_string = RandomUTF8(kArbitraryConstant); |
| |
| // primitive_types |
| s->primitive_types.b = bool_distribution(rand_engine); |
| s->primitive_types.i8 = int8_distribution(rand_engine); |
| s->primitive_types.i16 = int16_distribution(rand_engine); |
| s->primitive_types.i32 = int32_distribution(rand_engine); |
| s->primitive_types.i64 = int64_distribution(rand_engine); |
| s->primitive_types.u8 = uint8_distribution(rand_engine); |
| s->primitive_types.u16 = uint16_distribution(rand_engine); |
| s->primitive_types.u32 = uint32_distribution(rand_engine); |
| s->primitive_types.u64 = uint64_distribution(rand_engine); |
| s->primitive_types.f32 = float_distribution(rand_engine); |
| s->primitive_types.f64 = double_distribution(rand_engine); |
| |
| // arrays |
| s->arrays.b_0[0] = bool_distribution(rand_engine); |
| s->arrays.i8_0[0] = int8_distribution(rand_engine); |
| s->arrays.i16_0[0] = int16_distribution(rand_engine); |
| s->arrays.i32_0[0] = int32_distribution(rand_engine); |
| s->arrays.i64_0[0] = int64_distribution(rand_engine); |
| s->arrays.u8_0[0] = uint8_distribution(rand_engine); |
| s->arrays.u16_0[0] = uint16_distribution(rand_engine); |
| s->arrays.u32_0[0] = uint32_distribution(rand_engine); |
| s->arrays.u64_0[0] = uint64_distribution(rand_engine); |
| s->arrays.f32_0[0] = float_distribution(rand_engine); |
| s->arrays.f64_0[0] = double_distribution(rand_engine); |
| s->arrays.handle_0[0] = Handle(); |
| |
| for (uint32_t i = 0; i < fidl::test::compatibility::arrays_size; ++i) { |
| s->arrays.b_1[i] = bool_distribution(rand_engine); |
| s->arrays.i8_1[i] = int8_distribution(rand_engine); |
| s->arrays.i16_1[i] = int16_distribution(rand_engine); |
| s->arrays.i32_1[i] = int32_distribution(rand_engine); |
| s->arrays.i64_1[i] = int64_distribution(rand_engine); |
| s->arrays.u8_1[i] = uint8_distribution(rand_engine); |
| s->arrays.u16_1[i] = uint16_distribution(rand_engine); |
| s->arrays.u32_1[i] = uint32_distribution(rand_engine); |
| s->arrays.u64_1[i] = uint64_distribution(rand_engine); |
| s->arrays.f32_1[i] = float_distribution(rand_engine); |
| s->arrays.f64_1[i] = double_distribution(rand_engine); |
| s->arrays.handle_1[i] = Handle(); |
| } |
| |
| // arrays_2d |
| for (uint32_t i = 0; i < fidl::test::compatibility::arrays_size; ++i) { |
| for (uint32_t j = 0; j < kArbitraryConstant; ++j) { |
| s->arrays_2d.b[i][j] = bool_distribution(rand_engine); |
| s->arrays_2d.i8[i][j] = int8_distribution(rand_engine); |
| s->arrays_2d.i16[i][j] = int16_distribution(rand_engine); |
| s->arrays_2d.i32[i][j] = int32_distribution(rand_engine); |
| s->arrays_2d.i64[i][j] = int64_distribution(rand_engine); |
| s->arrays_2d.u8[i][j] = uint8_distribution(rand_engine); |
| s->arrays_2d.u16[i][j] = uint16_distribution(rand_engine); |
| s->arrays_2d.u32[i][j] = uint32_distribution(rand_engine); |
| s->arrays_2d.u64[i][j] = uint64_distribution(rand_engine); |
| s->arrays_2d.f32[i][j] = float_distribution(rand_engine); |
| s->arrays_2d.f64[i][j] = double_distribution(rand_engine); |
| s->arrays_2d.handle_handle[i][j] = Handle(); |
| } |
| } |
| |
| // vectors |
| s->vectors.b_0 = VectorPtr<bool>( |
| std::vector<bool>(kArbitraryVectorSize, bool_distribution(rand_engine))); |
| s->vectors.i8_0 = VectorPtr<int8_t>(std::vector<int8_t>( |
| kArbitraryVectorSize, int8_distribution(rand_engine))); |
| s->vectors.i16_0 = VectorPtr<int16_t>(std::vector<int16_t>( |
| kArbitraryVectorSize, int16_distribution(rand_engine))); |
| s->vectors.i32_0 = VectorPtr<int32_t>(std::vector<int32_t>( |
| kArbitraryVectorSize, int32_distribution(rand_engine))); |
| s->vectors.i64_0 = VectorPtr<int64_t>(std::vector<int64_t>( |
| kArbitraryVectorSize, int64_distribution(rand_engine))); |
| s->vectors.u8_0 = VectorPtr<uint8_t>(std::vector<uint8_t>( |
| kArbitraryVectorSize, uint8_distribution(rand_engine))); |
| s->vectors.u16_0 = VectorPtr<uint16_t>(std::vector<uint16_t>( |
| kArbitraryVectorSize, uint16_distribution(rand_engine))); |
| s->vectors.u32_0 = VectorPtr<uint32_t>(std::vector<uint32_t>( |
| kArbitraryVectorSize, uint32_distribution(rand_engine))); |
| s->vectors.u64_0 = VectorPtr<uint64_t>(std::vector<uint64_t>( |
| kArbitraryVectorSize, uint64_distribution(rand_engine))); |
| s->vectors.f32_0 = VectorPtr<float>(std::vector<float>( |
| kArbitraryVectorSize, float_distribution(rand_engine))); |
| s->vectors.f64_0 = VectorPtr<double>(std::vector<double>( |
| kArbitraryVectorSize, double_distribution(rand_engine))); |
| |
| { |
| std::vector<zx::handle> underlying_vec; |
| for (uint8_t i = 0; i < kArbitraryVectorSize; ++i) { |
| underlying_vec.emplace_back(Handle()); |
| } |
| s->vectors.handle_0 = std::vector<zx::handle>(std::move(underlying_vec)); |
| } |
| |
| { |
| std::vector<std::vector<bool>> bool_outer_vector; |
| std::vector<std::vector<int8_t>> int8_outer_vector; |
| std::vector<std::vector<int16_t>> int16_outer_vector; |
| std::vector<std::vector<int32_t>> int32_outer_vector; |
| std::vector<std::vector<int64_t>> int64_outer_vector; |
| std::vector<std::vector<uint8_t>> uint8_outer_vector; |
| std::vector<std::vector<uint16_t>> uint16_outer_vector; |
| std::vector<std::vector<uint32_t>> uint32_outer_vector; |
| std::vector<std::vector<uint64_t>> uint64_outer_vector; |
| std::vector<std::vector<float>> float_outer_vector; |
| std::vector<std::vector<double>> double_outer_vector; |
| std::vector<std::vector<zx::handle>> handle_outer_vector; |
| for (uint8_t i = 0; i < kArbitraryVectorSize; ++i) { |
| bool_outer_vector.emplace_back(std::vector<bool>(std::vector<bool>( |
| kArbitraryConstant, bool_distribution(rand_engine)))); |
| int8_outer_vector.emplace_back(std::vector<int8_t>(std::vector<int8_t>( |
| kArbitraryConstant, int8_distribution(rand_engine)))); |
| int16_outer_vector.emplace_back(std::vector<int16_t>(std::vector<int16_t>( |
| kArbitraryConstant, int16_distribution(rand_engine)))); |
| int32_outer_vector.emplace_back(std::vector<int32_t>(std::vector<int32_t>( |
| kArbitraryConstant, int32_distribution(rand_engine)))); |
| int64_outer_vector.emplace_back(std::vector<int64_t>(std::vector<int64_t>( |
| kArbitraryConstant, int64_distribution(rand_engine)))); |
| uint8_outer_vector.emplace_back(std::vector<uint8_t>(std::vector<uint8_t>( |
| kArbitraryConstant, uint8_distribution(rand_engine)))); |
| uint16_outer_vector.emplace_back( |
| std::vector<uint16_t>(std::vector<uint16_t>( |
| kArbitraryConstant, uint16_distribution(rand_engine)))); |
| uint32_outer_vector.emplace_back( |
| std::vector<uint32_t>(std::vector<uint32_t>( |
| kArbitraryConstant, uint32_distribution(rand_engine)))); |
| uint64_outer_vector.emplace_back( |
| std::vector<uint64_t>(std::vector<uint64_t>( |
| kArbitraryConstant, uint64_distribution(rand_engine)))); |
| float_outer_vector.emplace_back(std::vector<float>(std::vector<float>( |
| kArbitraryConstant, float_distribution(rand_engine)))); |
| double_outer_vector.emplace_back(std::vector<double>(std::vector<double>( |
| kArbitraryConstant, double_distribution(rand_engine)))); |
| std::vector<zx::handle> handle_inner_vector; |
| for (uint8_t i = 0; i < kArbitraryConstant; ++i) { |
| handle_inner_vector.emplace_back(Handle()); |
| } |
| handle_outer_vector.emplace_back( |
| std::vector<zx::handle>(std::move(handle_inner_vector))); |
| } |
| s->vectors.b_1 = |
| std::vector<std::vector<bool>>(std::move(bool_outer_vector)); |
| s->vectors.i8_1 = |
| std::vector<std::vector<int8_t>>(std::move(int8_outer_vector)); |
| s->vectors.i16_1 = |
| std::vector<std::vector<int16_t>>(std::move(int16_outer_vector)); |
| s->vectors.i32_1 = |
| std::vector<std::vector<int32_t>>(std::move(int32_outer_vector)); |
| s->vectors.i64_1 = |
| std::vector<std::vector<int64_t>>(std::move(int64_outer_vector)); |
| s->vectors.u8_1 = |
| std::vector<std::vector<uint8_t>>(std::move(uint8_outer_vector)); |
| s->vectors.u16_1 = |
| std::vector<std::vector<uint16_t>>(std::move(uint16_outer_vector)); |
| s->vectors.u32_1 = |
| std::vector<std::vector<uint32_t>>(std::move(uint32_outer_vector)); |
| s->vectors.u64_1 = |
| std::vector<std::vector<uint64_t>>(std::move(uint64_outer_vector)); |
| s->vectors.f32_1 = |
| std::vector<std::vector<float>>(std::move(float_outer_vector)); |
| s->vectors.f64_1 = |
| std::vector<std::vector<double>>(std::move(double_outer_vector)); |
| s->vectors.handle_1 = |
| std::vector<std::vector<zx::handle>>(std::move(handle_outer_vector)); |
| } |
| |
| s->vectors.b_sized_0 = |
| VectorPtr<bool>(std::vector<bool>{bool_distribution(rand_engine)}); |
| s->vectors.i8_sized_0 = |
| VectorPtr<int8_t>(std::vector<int8_t>{int8_distribution(rand_engine)}); |
| s->vectors.i16_sized_0 = |
| VectorPtr<int16_t>(std::vector<int16_t>{int16_distribution(rand_engine)}); |
| s->vectors.i32_sized_0 = |
| VectorPtr<int32_t>(std::vector<int32_t>{int32_distribution(rand_engine)}); |
| s->vectors.i64_sized_0 = |
| VectorPtr<int64_t>(std::vector<int64_t>{int64_distribution(rand_engine)}); |
| s->vectors.u8_sized_0 = |
| VectorPtr<uint8_t>(std::vector<uint8_t>{uint8_distribution(rand_engine)}); |
| s->vectors.u16_sized_0 = VectorPtr<uint16_t>( |
| std::vector<uint16_t>{uint16_distribution(rand_engine)}); |
| s->vectors.u32_sized_0 = VectorPtr<uint32_t>( |
| std::vector<uint32_t>{uint32_distribution(rand_engine)}); |
| s->vectors.u64_sized_0 = VectorPtr<uint64_t>( |
| std::vector<uint64_t>{uint64_distribution(rand_engine)}); |
| s->vectors.f32_sized_0 = |
| VectorPtr<float>(std::vector<float>{float_distribution(rand_engine)}); |
| s->vectors.f64_sized_0 = |
| VectorPtr<double>(std::vector<double>{double_distribution(rand_engine)}); |
| |
| { |
| std::vector<zx::handle> underlying_vec; |
| underlying_vec.emplace_back(Handle()); |
| s->vectors.handle_sized_0 = |
| std::vector<zx::handle>(std::move(underlying_vec)); |
| } |
| |
| s->vectors.b_sized_1 = VectorPtr<bool>(std::vector<bool>( |
| fidl::test::compatibility::vectors_size, bool_distribution(rand_engine))); |
| s->vectors.i8_sized_1 = VectorPtr<int8_t>(std::vector<int8_t>( |
| fidl::test::compatibility::vectors_size, int8_distribution(rand_engine))); |
| s->vectors.i16_sized_1 = VectorPtr<int16_t>( |
| std::vector<int16_t>(fidl::test::compatibility::vectors_size, |
| int16_distribution(rand_engine))); |
| s->vectors.i32_sized_1 = VectorPtr<int32_t>( |
| std::vector<int32_t>(fidl::test::compatibility::vectors_size, |
| int32_distribution(rand_engine))); |
| s->vectors.i64_sized_1 = VectorPtr<int64_t>( |
| std::vector<int64_t>(fidl::test::compatibility::vectors_size, |
| int64_distribution(rand_engine))); |
| s->vectors.u8_sized_1 = VectorPtr<uint8_t>( |
| std::vector<uint8_t>(fidl::test::compatibility::vectors_size, |
| uint8_distribution(rand_engine))); |
| s->vectors.u16_sized_1 = VectorPtr<uint16_t>( |
| std::vector<uint16_t>(fidl::test::compatibility::vectors_size, |
| uint16_distribution(rand_engine))); |
| s->vectors.u32_sized_1 = VectorPtr<uint32_t>( |
| std::vector<uint32_t>(fidl::test::compatibility::vectors_size, |
| uint32_distribution(rand_engine))); |
| s->vectors.u64_sized_1 = VectorPtr<uint64_t>( |
| std::vector<uint64_t>(fidl::test::compatibility::vectors_size, |
| uint64_distribution(rand_engine))); |
| s->vectors.f32_sized_1 = VectorPtr<float>( |
| std::vector<float>(fidl::test::compatibility::vectors_size, |
| float_distribution(rand_engine))); |
| s->vectors.f64_sized_1 = VectorPtr<double>( |
| std::vector<double>(fidl::test::compatibility::vectors_size, |
| double_distribution(rand_engine))); |
| { |
| std::vector<zx::handle> underlying_vec; |
| for (uint32_t i = 0; i < fidl::test::compatibility::vectors_size; ++i) { |
| underlying_vec.emplace_back(Handle()); |
| } |
| s->vectors.handle_sized_1 = |
| std::vector<zx::handle>(std::move(underlying_vec)); |
| } |
| { |
| std::vector<std::vector<bool>> bool_outer_vector; |
| std::vector<std::vector<int8_t>> int8_outer_vector; |
| std::vector<std::vector<int16_t>> int16_outer_vector; |
| std::vector<std::vector<int32_t>> int32_outer_vector; |
| std::vector<std::vector<int64_t>> int64_outer_vector; |
| std::vector<std::vector<uint8_t>> uint8_outer_vector; |
| std::vector<std::vector<uint16_t>> uint16_outer_vector; |
| std::vector<std::vector<uint32_t>> uint32_outer_vector; |
| std::vector<std::vector<uint64_t>> uint64_outer_vector; |
| std::vector<std::vector<float>> float_outer_vector; |
| std::vector<std::vector<double>> double_outer_vector; |
| std::vector<std::vector<zx::handle>> handle_outer_vector; |
| for (uint32_t i = 0; i < fidl::test::compatibility::vectors_size; ++i) { |
| bool_outer_vector.emplace_back(std::vector<bool>(std::vector<bool>( |
| kArbitraryConstant, bool_distribution(rand_engine)))); |
| int8_outer_vector.emplace_back(std::vector<int8_t>(std::vector<int8_t>( |
| kArbitraryConstant, int8_distribution(rand_engine)))); |
| int16_outer_vector.emplace_back(std::vector<int16_t>(std::vector<int16_t>( |
| kArbitraryConstant, int16_distribution(rand_engine)))); |
| int32_outer_vector.emplace_back(std::vector<int32_t>(std::vector<int32_t>( |
| kArbitraryConstant, int32_distribution(rand_engine)))); |
| int64_outer_vector.emplace_back(std::vector<int64_t>(std::vector<int64_t>( |
| kArbitraryConstant, int64_distribution(rand_engine)))); |
| uint8_outer_vector.emplace_back(std::vector<uint8_t>(std::vector<uint8_t>( |
| kArbitraryConstant, uint8_distribution(rand_engine)))); |
| uint16_outer_vector.emplace_back( |
| std::vector<uint16_t>(std::vector<uint16_t>( |
| kArbitraryConstant, uint16_distribution(rand_engine)))); |
| uint32_outer_vector.emplace_back( |
| std::vector<uint32_t>(std::vector<uint32_t>( |
| kArbitraryConstant, uint32_distribution(rand_engine)))); |
| uint64_outer_vector.emplace_back( |
| std::vector<uint64_t>(std::vector<uint64_t>( |
| kArbitraryConstant, uint64_distribution(rand_engine)))); |
| float_outer_vector.emplace_back(std::vector<float>(std::vector<float>( |
| kArbitraryConstant, float_distribution(rand_engine)))); |
| double_outer_vector.emplace_back(std::vector<double>(std::vector<double>( |
| kArbitraryConstant, double_distribution(rand_engine)))); |
| std::vector<zx::handle> handle_inner_vector; |
| for (uint8_t i = 0; i < kArbitraryConstant; ++i) { |
| handle_inner_vector.emplace_back(Handle()); |
| } |
| handle_outer_vector.emplace_back( |
| std::vector<zx::handle>(std::move(handle_inner_vector))); |
| } |
| s->vectors.b_sized_2 = |
| std::vector<std::vector<bool>>(std::move(bool_outer_vector)); |
| s->vectors.i8_sized_2 = |
| std::vector<std::vector<int8_t>>(std::move(int8_outer_vector)); |
| s->vectors.i16_sized_2 = |
| std::vector<std::vector<int16_t>>(std::move(int16_outer_vector)); |
| s->vectors.i32_sized_2 = |
| std::vector<std::vector<int32_t>>(std::move(int32_outer_vector)); |
| s->vectors.i64_sized_2 = |
| std::vector<std::vector<int64_t>>(std::move(int64_outer_vector)); |
| s->vectors.u8_sized_2 = |
| std::vector<std::vector<uint8_t>>(std::move(uint8_outer_vector)); |
| s->vectors.u16_sized_2 = |
| std::vector<std::vector<uint16_t>>(std::move(uint16_outer_vector)); |
| s->vectors.u32_sized_2 = |
| std::vector<std::vector<uint32_t>>(std::move(uint32_outer_vector)); |
| s->vectors.u64_sized_2 = |
| std::vector<std::vector<uint64_t>>(std::move(uint64_outer_vector)); |
| s->vectors.f32_sized_2 = |
| std::vector<std::vector<float>>(std::move(float_outer_vector)); |
| s->vectors.f64_sized_2 = |
| std::vector<std::vector<double>>(std::move(double_outer_vector)); |
| s->vectors.handle_sized_2 = |
| std::vector<std::vector<zx::handle>>(std::move(handle_outer_vector)); |
| } |
| |
| // intentionally leave most of the nullable vectors as null, just set one |
| // from each category. |
| s->vectors.b_nullable_0 = |
| VectorPtr<bool>(std::vector<bool>{bool_distribution(rand_engine)}); |
| { |
| std::vector<std::vector<int8_t>> int8_outer_vector; |
| for (uint8_t i = 0; i < kArbitraryVectorSize; ++i) { |
| int8_outer_vector.emplace_back(VectorPtr<int8_t>(std::vector<int8_t>( |
| kArbitraryConstant, int8_distribution(rand_engine)))); |
| } |
| s->vectors.i8_nullable_1 = |
| VectorPtr<std::vector<int8_t>>(std::move(int8_outer_vector)); |
| } |
| s->vectors.i16_nullable_sized_0 = |
| VectorPtr<int16_t>(std::vector<int16_t>{int16_distribution(rand_engine)}); |
| s->vectors.f64_nullable_sized_1 = VectorPtr<double>( |
| std::vector<double>(fidl::test::compatibility::vectors_size, |
| double_distribution(rand_engine))); |
| { |
| std::vector<std::vector<zx::handle>> handle_outer_vector; |
| for (uint32_t i = 0; i < fidl::test::compatibility::vectors_size; ++i) { |
| std::vector<zx::handle> handle_inner_vector; |
| for (uint8_t i = 0; i < kArbitraryConstant; ++i) { |
| handle_inner_vector.emplace_back(Handle()); |
| } |
| handle_outer_vector.emplace_back( |
| std::vector<zx::handle>(std::move(handle_inner_vector))); |
| } |
| s->vectors.handle_nullable_sized_2 = |
| VectorPtr<std::vector<zx::handle>>(std::move(handle_outer_vector)); |
| } |
| |
| // handles |
| s->handles.handle_handle = Handle(); |
| |
| ASSERT_EQ(ZX_OK, zx::process::self()->duplicate(ZX_RIGHT_SAME_RIGHTS, |
| &s->handles.process_handle)); |
| ASSERT_EQ(ZX_OK, |
| zx::thread::create(*zx::unowned_process(zx::process::self()), |
| "dummy", 5u, 0u, &s->handles.thread_handle)); |
| ASSERT_EQ(ZX_OK, zx::vmo::create(0u, 0u, &s->handles.vmo_handle)); |
| ASSERT_EQ(ZX_OK, zx::event::create(0u, &s->handles.event_handle)); |
| ASSERT_EQ(ZX_OK, zx::port::create(0u, &s->handles.port_handle)); |
| ASSERT_EQ(ZX_OK, |
| zx::debuglog::create(zx::resource(), 0u, &s->handles.log_handle)); |
| |
| zx::socket socket1; |
| ASSERT_EQ(ZX_OK, zx::socket::create(0u, &s->handles.socket_handle, &socket1)); |
| |
| zx::eventpair eventpair1; |
| ASSERT_EQ(ZX_OK, zx::eventpair::create(0u, &s->handles.eventpair_handle, |
| &eventpair1)); |
| |
| ASSERT_EQ(ZX_OK, zx::job::create(*zx::job::default_job(), 0u, |
| &s->handles.job_handle)); |
| |
| uintptr_t vmar_addr; |
| ASSERT_EQ(ZX_OK, zx::vmar::root_self()->allocate( |
| 0u, getpagesize(), ZX_VM_CAN_MAP_READ, |
| &s->handles.vmar_handle, &vmar_addr)); |
| |
| zx::fifo fifo1; |
| ASSERT_EQ(ZX_OK, |
| zx::fifo::create(1u, 1u, 0u, &s->handles.fifo_handle, &fifo1)); |
| |
| ASSERT_EQ(ZX_OK, zx::timer::create(0u, ZX_CLOCK_MONOTONIC, |
| &s->handles.timer_handle)); |
| |
| // For the nullable ones, just set one of them. |
| s->handles.nullable_handle_handle = Handle(); |
| |
| // strings |
| s->strings.s = fidl::StringPtr(random_string); |
| s->strings.size_0_s = fidl::StringPtr(random_short_string); |
| s->strings.size_1_s = fidl::StringPtr(random_string); |
| s->strings.nullable_size_0_s = fidl::StringPtr(random_short_string); |
| |
| // enums |
| s->default_enum = fidl::test::compatibility::default_enum::kOne; |
| s->i8_enum = fidl::test::compatibility::i8_enum::kNegativeOne; |
| s->i16_enum = fidl::test::compatibility::i16_enum::kNegativeOne; |
| s->i32_enum = fidl::test::compatibility::i32_enum::kNegativeOne; |
| s->i64_enum = fidl::test::compatibility::i64_enum::kNegativeOne; |
| s->u8_enum = fidl::test::compatibility::u8_enum::kOne; |
| s->u16_enum = fidl::test::compatibility::u16_enum::kTwo; |
| s->u32_enum = fidl::test::compatibility::u32_enum::kThree; |
| s->u64_enum = fidl::test::compatibility::u64_enum::kFour; |
| |
| // structs |
| s->structs.s.s = fidl::StringPtr(random_string); |
| |
| // unions |
| s->unions.u.set_s(fidl::StringPtr(random_string)); |
| s->unions.nullable_u = fidl::test::compatibility::this_is_a_union::New(); |
| s->unions.nullable_u->set_b(bool_distribution(rand_engine)); |
| |
| // bool |
| s->b = bool_distribution(rand_engine); |
| } |
| |
| class CompatibilityTest |
| : public ::testing::TestWithParam<std::tuple<std::string, std::string>> { |
| protected: |
| void SetUp() override { |
| proxy_url_ = ::testing::get<0>(GetParam()); |
| server_url_ = ::testing::get<1>(GetParam()); |
| // The FIDL support lib requires async_get_default_dispatcher() to return |
| // non-null. |
| loop_.reset(new async::Loop(&kAsyncLoopConfigAttachToThread)); |
| } |
| std::string proxy_url_; |
| std::string server_url_; |
| std::unique_ptr<async::Loop> loop_; |
| }; |
| |
| std::vector<std::string> servers; |
| |
| using TestBody = std::function<void(async::Loop& loop, |
| fidl::test::compatibility::EchoPtr& proxy, |
| const std::string& server_url)>; |
| |
| void ForAllServers(TestBody body) { |
| for (auto const& proxy_url : servers) { |
| for (auto const& server_url : servers) { |
| std::cerr << proxy_url << " <-> " << server_url << std::endl; |
| async::Loop loop(&kAsyncLoopConfigAttachToThread); |
| fidl::test::compatibility::EchoClientApp proxy; |
| bool test_completed = false; |
| proxy.echo().set_error_handler([&proxy_url, &loop, &test_completed](zx_status_t status) { |
| if (!test_completed) { |
| loop.Quit(); |
| FAIL() << "Connection to " << proxy_url << " failed unexpectedly: " << status; |
| } |
| }); |
| proxy.Start(proxy_url); |
| |
| body(loop, proxy.echo(), server_url); |
| test_completed = true; |
| } |
| } |
| } |
| |
| TEST(Compatibility, EchoStruct) { |
| ForAllServers([](async::Loop& loop, fidl::test::compatibility::EchoPtr& proxy, |
| const std::string& server_url) { |
| Struct sent; |
| Initialize(&sent); |
| |
| Struct sent_clone; |
| sent.Clone(&sent_clone); |
| Struct resp_clone; |
| bool called_back = false; |
| proxy->EchoStruct(std::move(sent), server_url, |
| [&loop, &resp_clone, &called_back](Struct resp) { |
| ASSERT_EQ(ZX_OK, resp.Clone(&resp_clone)); |
| called_back = true; |
| loop.Quit(); |
| }); |
| |
| loop.Run(); |
| ASSERT_TRUE(called_back); |
| ExpectEq(sent_clone, resp_clone); |
| }); |
| } |
| |
| TEST(Compatibility, EchoStructNoRetval) { |
| ForAllServers([](async::Loop& loop, fidl::test::compatibility::EchoPtr& proxy, |
| const std::string& server_url) { |
| Struct sent; |
| Initialize(&sent); |
| |
| Struct sent_clone; |
| sent.Clone(&sent_clone); |
| fidl::test::compatibility::Struct resp_clone; |
| bool event_received = false; |
| proxy.events().EchoEvent = [&loop, &resp_clone, |
| &event_received](Struct resp) { |
| resp.Clone(&resp_clone); |
| event_received = true; |
| loop.Quit(); |
| }; |
| proxy->EchoStructNoRetVal(std::move(sent), server_url); |
| loop.Run(); |
| ASSERT_TRUE(event_received); |
| ExpectEq(sent_clone, resp_clone); |
| }); |
| } |
| |
| } // namespace |
| |
| int main(int argc, char** argv) { |
| testing::InitGoogleTest(&argc, argv); |
| |
| for (int i = 1; i < argc; i++) { |
| servers.push_back(argv[i]); |
| } |
| |
| FXL_CHECK(!servers.empty()) << kUsage; |
| |
| return RUN_ALL_TESTS(); |
| } |
