public/lib/fidl/compatibility_test/compatibility_test_service.fidl

// 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.

library fidl.test.compatibility;

struct this_is_a_struct { string s; };

struct this_is_an_empty_struct {};

union this_is_a_union {
  string s;
  bool b;
};

struct primitive_types {
  bool b;
  int8 i8;
  int16 i16;
  int32 i32;
  int64 i64;
  uint8 u8;
  uint16 u16;
  uint32 u32;
  uint64 u64;
  float32 f32;
  float64 f64;
};

struct default_values {
  bool b1 = true;
  bool b2 = false;
  int8 i8 = -23;
  int16 i16 = 34;
  int32 i32 = -34595;
  int64 i64 = 3948038;
  uint8 u8 = 0;
  uint16 u16 = 348;
  uint32 u32 = 9038;
  uint64 u64 = 19835;
  float32 f32 = 1.30;
  float64 f64 = 0.0000054;
  string s = "hello";
};

// Arbitrary, but must be small enough such that a single message doesn't exceed
// kMaxMessageSize or kMaxMessageHandles.
const uint32 arrays_size = 3;

struct arrays {
  array<bool>:1 b_0;
  array<int8>:1 i8_0;
  array<int16>:1 i16_0;
  array<int32>:1 i32_0;
  array<int64>:1 i64_0;
  array<uint8>:1 u8_0;
  array<uint16>:1 u16_0;
  array<uint32>:1 u32_0;
  array<uint64>:1 u64_0;
  array<float32>:1 f32_0;
  array<float64>:1 f64_0;
  array<handle>:1 handle_0;
  array<bool>:arrays_size b_1;
  array<int8>:arrays_size i8_1;
  array<int16>:arrays_size i16_1;
  array<int32>:arrays_size i32_1;
  array<int64>:arrays_size i64_1;
  array<uint8>:arrays_size u8_1;
  array<uint16>:arrays_size u16_1;
  array<uint32>:arrays_size u32_1;
  array<uint64>:arrays_size u64_1;
  array<float32>:arrays_size f32_1;
  array<float64>:arrays_size f64_1;
  array<handle>:arrays_size handle_1;
};

struct arrays_2d {
  array<array<bool>:2>:arrays_size b;
  array<array<int8>:2>:arrays_size i8;
  array<array<int16>:2>:arrays_size i16;
  array<array<int32>:2>:arrays_size i32;
  array<array<int64>:2>:arrays_size i64;
  array<array<uint8>:2>:arrays_size u8;
  array<array<uint16>:2>:arrays_size u16;
  array<array<uint32>:2>:arrays_size u32;
  array<array<uint64>:2>:arrays_size u64;
  array<array<float32>:2>:arrays_size f32;
  array<array<float64>:2>:arrays_size f64;
  array<array<handle>:2>:arrays_size handle_handle;
};

// Arbitrary, but must be small enough such that a single message doesn't exceed
// kMaxMessageSize or kMaxMessageHandles.
const uint32 vectors_size = 3;

struct vectors {
  vector<bool> b_0;
  vector<int8> i8_0;
  vector<int16> i16_0;
  vector<int32> i32_0;
  vector<int64> i64_0;
  vector<uint8> u8_0;
  vector<uint16> u16_0;
  vector<uint32> u32_0;
  vector<uint64> u64_0;
  vector<float32> f32_0;
  vector<float64> f64_0;
  vector<handle> handle_0;
  vector<vector<bool>:2> b_1;
  vector<vector<int8>:2> i8_1;
  vector<vector<int16>:2> i16_1;
  vector<vector<int32>:2> i32_1;
  vector<vector<int64>:2> i64_1;
  vector<vector<uint8>:2> u8_1;
  vector<vector<uint16>:2> u16_1;
  vector<vector<uint32>:2> u32_1;
  vector<vector<uint64>:2> u64_1;
  vector<vector<float32>:2> f32_1;
  vector<vector<float64>:2> f64_1;
  vector<vector<handle>:2> handle_1;
  vector<bool>:1 b_sized_0;
  vector<int8>:1 i8_sized_0;
  vector<int16>:1 i16_sized_0;
  vector<int32>:1 i32_sized_0;
  vector<int64>:1 i64_sized_0;
  vector<uint8>:1 u8_sized_0;
  vector<uint16>:1 u16_sized_0;
  vector<uint32>:1 u32_sized_0;
  vector<uint64>:1 u64_sized_0;
  vector<float32>:1 f32_sized_0;
  vector<float64>:1 f64_sized_0;
  vector<handle>:1 handle_sized_0;
  vector<bool>:vectors_size b_sized_1;
  vector<int8>:vectors_size i8_sized_1;
  vector<int16>:vectors_size i16_sized_1;
  vector<int32>:vectors_size i32_sized_1;
  vector<int64>:vectors_size i64_sized_1;
  vector<uint8>:vectors_size u8_sized_1;
  vector<uint16>:vectors_size u16_sized_1;
  vector<uint32>:vectors_size u32_sized_1;
  vector<uint64>:vectors_size u64_sized_1;
  vector<float32>:vectors_size f32_sized_1;
  vector<float64>:vectors_size f64_sized_1;
  vector<handle>:vectors_size handle_sized_1;
  vector<vector<bool>:2>:vectors_size b_sized_2;
  vector<vector<int8>:2>:vectors_size i8_sized_2;
  vector<vector<int16>:2>:vectors_size i16_sized_2;
  vector<vector<int32>:2>:vectors_size i32_sized_2;
  vector<vector<int64>:2>:vectors_size i64_sized_2;
  vector<vector<uint8>:2>:vectors_size u8_sized_2;
  vector<vector<uint16>:2>:vectors_size u16_sized_2;
  vector<vector<uint32>:2>:vectors_size u32_sized_2;
  vector<vector<uint64>:2>:vectors_size u64_sized_2;
  vector<vector<float32>:2>:vectors_size f32_sized_2;
  vector<vector<float64>:2>:vectors_size f64_sized_2;
  vector<vector<handle>:2>:vectors_size handle_sized_2;
  vector<bool>:1? b_nullable_0;
  vector<int8>:1? i8_nullable_0;
  vector<int16>:1? i16_nullable_0;
  vector<int32>:1? i32_nullable_0;
  vector<int64>:1? i64_nullable_0;
  vector<uint8>:1? u8_nullable_0;
  vector<uint16>:1? u16_nullable_0;
  vector<uint32>:1? u32_nullable_0;
  vector<uint64>:1? u64_nullable_0;
  vector<float32>:1? f32_nullable_0;
  vector<float64>:1? f64_nullable_0;
  vector<handle>:1? handle_nullable_0;
  vector<vector<bool>:2>? b_nullable_1;
  vector<vector<int8>:2>? i8_nullable_1;
  vector<vector<int16>:2>? i16_nullable_1;
  vector<vector<int32>:2>? i32_nullable_1;
  vector<vector<int64>:2>? i64_nullable_1;
  vector<vector<uint8>:2>? u8_nullable_1;
  vector<vector<uint16>:2>? u16_nullable_1;
  vector<vector<uint32>:2>? u32_nullable_1;
  vector<vector<uint64>:2>? u64_nullable_1;
  vector<vector<float32>:2>? f32_nullable_1;
  vector<vector<float64>:2>? f64_nullable_1;
  vector<vector<handle>:2>? handle_nullable_1;
  vector<bool>:1? b_nullable_sized_0;
  vector<int8>:1? i8_nullable_sized_0;
  vector<int16>:1? i16_nullable_sized_0;
  vector<int32>:1? i32_nullable_sized_0;
  vector<int64>:1? i64_nullable_sized_0;
  vector<uint8>:1? u8_nullable_sized_0;
  vector<uint16>:1? u16_nullable_sized_0;
  vector<uint32>:1? u32_nullable_sized_0;
  vector<uint64>:1? u64_nullable_sized_0;
  vector<float32>:1? f32_nullable_sized_0;
  vector<float64>:1? f64_nullable_sized_0;
  vector<handle>:1? handle_nullable_sized_0;
  vector<bool>:vectors_size? b_nullable_sized_1;
  vector<int8>:vectors_size? i8_nullable_sized_1;
  vector<int16>:vectors_size? i16_nullable_sized_1;
  vector<int32>:vectors_size? i32_nullable_sized_1;
  vector<int64>:vectors_size? i64_nullable_sized_1;
  vector<uint8>:vectors_size? u8_nullable_sized_1;
  vector<uint16>:vectors_size? u16_nullable_sized_1;
  vector<uint32>:vectors_size? u32_nullable_sized_1;
  vector<uint64>:vectors_size? u64_nullable_sized_1;
  vector<float32>:vectors_size? f32_nullable_sized_1;
  vector<float64>:vectors_size? f64_nullable_sized_1;
  vector<handle>:vectors_size? handle_nullable_sized_1;
  vector<vector<bool>:2>:vectors_size? b_nullable_sized_2;
  vector<vector<int8>:2>:vectors_size? i8_nullable_sized_2;
  vector<vector<int16>:2>:vectors_size? i16_nullable_sized_2;
  vector<vector<int32>:2>:vectors_size? i32_nullable_sized_2;
  vector<vector<int64>:2>:vectors_size? i64_nullable_sized_2;
  vector<vector<uint8>:2>:vectors_size? u8_nullable_sized_2;
  vector<vector<uint16>:2>:vectors_size? u16_nullable_sized_2;
  vector<vector<uint32>:2>:vectors_size? u32_nullable_sized_2;
  vector<vector<uint64>:2>:vectors_size? u64_nullable_sized_2;
  vector<vector<float32>:2>:vectors_size? f32_nullable_sized_2;
  vector<vector<float64>:2>:vectors_size? f64_nullable_sized_2;
  vector<vector<handle>:2>:vectors_size? handle_nullable_sized_2;
};

// We don't test handle types that don't support duplication
// (supports_duplication in zx/object_traits.h) or that require special
// privileges to create.
struct handles {
  handle handle_handle;
  handle<process> process_handle;
  handle<thread> thread_handle;
  handle<vmo> vmo_handle;
  handle<event> event_handle;
  handle<port> port_handle;
  handle<debuglog> log_handle;
  handle<socket> socket_handle;
  handle<eventpair> eventpair_handle;
  handle<job> job_handle;
  handle<vmar> vmar_handle;
  handle<fifo> fifo_handle;
  handle<timer> timer_handle;
  handle? nullable_handle_handle;
  handle<process>? nullable_process_handle;
  handle<thread>? nullable_thread_handle;
  handle<vmo>? nullable_vmo_handle;
  handle<channel>? nullable_channel_handle;
  handle<event>? nullable_event_handle;
  handle<port>? nullable_port_handle;
  handle<interrupt>? nullable_interrupt_handle;
  handle<debuglog>? nullable_log_handle;
  handle<socket>? nullable_socket_handle;
  handle<eventpair>? nullable_eventpair_handle;
  handle<job>? nullable_job_handle;
  handle<vmar>? nullable_vmar_handle;
  handle<fifo>? nullable_fifo_handle;
  handle<timer>? nullable_timer_handle;
};

// Arbitrary.
const uint32 strings_size = 32;

struct strings {
  string s;
  string? nullable_s;
  string:2 size_0_s;
  string:strings_size size_1_s;
  string:2? nullable_size_0_s;
  string:strings_size? nullable_size_1_s;
};

enum default_enum {
  kZero = 0;
  kOne = 1;
};

enum i8_enum : int8 {
  kNegativeOne = -1;
  kOne = 1;
};

enum i16_enum : int16 {
  kNegativeOne = -1;
  kOne = 1;
  kTwo = 2;
};

enum i32_enum : int32 {
  kNegativeOne = -1;
  kOne = 1;
  kTwo = 2;
  kThree = 3;
};

enum i64_enum : int64 {
  kNegativeOne = -1;
  kOne = 1;
  kTwo = 2;
  kThree = 3;
  kFour = 4;
};

enum u8_enum : uint8 {
  kOne = 1;
  kTwo = 2;
  kThree = 3;
  kFour = 4;
  kFive = 5;
};

enum u16_enum : uint16 {
  kOne = 1;
  kTwo = 2;
  kThree = 3;
  kFour = 4;
  kFive = 5;
  kSix = 6;
};

enum u32_enum : uint32 {
  kOne = 1;
  kTwo = 2;
  kThree = 3;
  kFour = 4;
  kFive = 5;
  kSix = 6;
  kSeven = 7;
};

enum u64_enum : uint64 {
  kOne = 1;
  kTwo = 2;
  kThree = 3;
  kFour = 4;
  kFive = 5;
  kSix = 6;
  kSeven = 7;
  kEight = 8;
};

struct structs {
  this_is_a_struct s;
  this_is_a_struct? nullable_s;
  this_is_an_empty_struct es;
};

struct unions {
  this_is_a_union u;
  this_is_a_union? nullable_u;
};

// This struct is meant to exercise almost all features of FIDL.
struct Struct {
  primitive_types primitive_types;
  default_values default_values;
  arrays arrays;
  arrays_2d arrays_2d;
  vectors vectors;
  handles handles;
  strings strings;
  default_enum default_enum;
  i8_enum i8_enum;
  i16_enum i16_enum;
  i32_enum i32_enum;
  i64_enum i64_enum;
  u8_enum u8_enum;
  u16_enum u16_enum;
  u32_enum u32_enum;
  u64_enum u64_enum;
  structs structs;
  unions unions;
  bool b;
};

[Discoverable]
interface Echo {
  // If |forward_to_server| is empty, just returns |value|.
  // If |forward_to_server| is not empty, it is treated as the URL of a server
  // which implements this interface. The server that recieves the non-empty
  // |forward_to_server| arg acts as a proxy for that other server.
  1: EchoStruct(Struct value, string forward_to_server) -> (Struct value);

  // Same as the above, but the server should use the event to return the
  // response, rather than a return value.
  2: EchoStructNoRetVal(Struct value, string forward_to_server);
  3: -> EchoEvent(Struct value);
};