| // 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. |
| library test.fidlcodec.examples; |
| |
| using zx; |
| |
| protocol Echo { |
| EchoString(struct { |
| value string:<100, optional>; |
| }) -> (struct { |
| response string:<100, optional>; |
| }); |
| }; |
| |
| type Named = struct { |
| s string:200; |
| }; |
| |
| protocol FidlCodecTestProtocol { |
| Empty(); |
| String(struct { |
| s string:100; |
| }); |
| Named(Named); |
| Bool(struct { |
| b bool; |
| }); |
| Int8(struct { |
| i8 int8; |
| }); |
| Int16(struct { |
| i16 int16; |
| }); |
| Int32(struct { |
| i32 int32; |
| }); |
| Int64(struct { |
| i64 int64; |
| }); |
| Uint8(struct { |
| ui8 uint8; |
| }); |
| Uint16(struct { |
| ui16 uint16; |
| }); |
| Uint32(struct { |
| ui32 uint32; |
| }); |
| Uint64(struct { |
| ui64 uint64; |
| }); |
| Float32(struct { |
| f32 float32; |
| }); |
| Float64(struct { |
| f64 float64; |
| }); |
| |
| Complex(struct { |
| real int32; |
| imaginary int32; |
| }); |
| StringInt(struct { |
| s string:100; |
| i32 int32; |
| }); |
| StringIntTable(table { |
| 1: s string:100; |
| 2: i32 int32; |
| }); |
| StringIntUnion(union { |
| 1: s string:100; |
| 2: i32 int32; |
| }); |
| |
| Array1(struct { |
| b_1 array<int32, 1>; |
| }); |
| Array2(struct { |
| b_2 array<int32, 2>; |
| }); |
| Vector(struct { |
| v_1 vector<int32>:<10, optional>; |
| }); |
| |
| TwoStringArrayInt(struct { |
| arr array<string:100, 2>; |
| i32 int32; |
| }); |
| TwoStringVectorInt(struct { |
| vec vector<string:100>:10; |
| i32 int32; |
| }); |
| TwoStringVectors(struct { |
| v_1 vector<string:100>:10; |
| v_2 vector<string:100>:10; |
| }); |
| VectorUint8(struct { |
| v vector<uint8>:100; |
| }); |
| VectorUint32(struct { |
| v vector<uint32>:100; |
| }); |
| VectorStruct(struct { |
| v vector<SmallStruct>:100; |
| }); |
| ArrayStruct(struct { |
| a array<SmallStruct, 3>; |
| }); |
| VectorStruct2(struct { |
| v vector<SmallUnevenStruct>:100; |
| }); |
| ArrayStruct2(struct { |
| a array<SmallUnevenStruct, 3>; |
| }); |
| |
| Struct(struct { |
| p PrimitiveTypes; |
| }); |
| BoolStruct(struct { |
| s BoolStructType; |
| }); |
| NullableStruct(struct { |
| p box<PrimitiveTypes>; |
| }); |
| NullableStructAndInt(struct { |
| p box<PrimitiveTypes>; |
| i int32; |
| }); |
| ArrayNullableStruct(struct { |
| a array<box<TwoStringStruct>, 3>; |
| }); |
| |
| SmallStructAfterByte(struct { |
| u uint8; |
| s1 SmallStruct; |
| s2 SmallStruct; |
| }); |
| |
| TwoStringStructInt(struct { |
| s TwoStringStruct; |
| i32 int32; |
| }); |
| TwoStringNullableStructInt(struct { |
| s box<TwoStringStruct>; |
| i32 int32; |
| }); |
| |
| Union(struct { |
| isu IntStructUnion; |
| i int32; |
| }); |
| NullableUnion(struct { |
| isu IntStructUnion:optional; |
| i int32; |
| }); |
| NullableUnionIntFirst(struct { |
| i int32; |
| isu IntStructUnion:optional; |
| }); |
| ArrayNullableUnion(struct { |
| a array<IntStructUnion:optional, 3>; |
| }); |
| |
| XUnion(struct { |
| isu IntStructXunion; |
| i int32; |
| }); |
| NullableXUnion(struct { |
| isu IntStructXunion:optional; |
| i int32; |
| }); |
| NullableXUnionIntFirst(struct { |
| i int32; |
| isu IntStructXunion:optional; |
| }); |
| |
| ShortUnion(struct { |
| u U8U16Union; |
| i int32; |
| }); |
| ShortUnionReserved(struct { |
| u U8U16UnionReserved; |
| i int32; |
| }); |
| ShortXUnion(struct { |
| u U8U16Xunion; |
| i int32; |
| }); |
| RecursiveUnion(struct { |
| e DataElement; |
| }); |
| |
| U8U16UnionStruct(struct { |
| s U8U16UnionStructType; |
| }); |
| |
| DefaultEnumMessage(struct { |
| ev DefaultEnum; |
| }); |
| I8EnumMessage(struct { |
| ev I8Enum; |
| }); |
| I16EnumMessage(struct { |
| ev I16Enum; |
| }); |
| I32EnumMessage(struct { |
| ev I32Enum; |
| }); |
| I64EnumMessage(struct { |
| ev I64Enum; |
| }); |
| |
| DefaultBitsMessage(struct { |
| v DefaultBits; |
| }); |
| I8BitsMessage(struct { |
| v I8Bits; |
| }); |
| I16BitsMessage(struct { |
| v I16Bits; |
| }); |
| I32BitsMessage(struct { |
| v I32Bits; |
| }); |
| I64BitsMessage(struct { |
| v I64Bits; |
| }); |
| |
| Table(struct { |
| table ValueTable; |
| i int32; |
| }); |
| |
| Handle(resource struct { |
| ch zx.handle:CHANNEL; |
| }); |
| NullableHandle(resource struct { |
| ch zx.handle:<CHANNEL, optional>; |
| }); |
| HandleStructMessage(resource struct { |
| hs HandleStruct; |
| }); |
| HandleTableMessage(resource struct { |
| t HandleTable; |
| }); |
| TraversalOrderMessage(resource struct { |
| t TraversalOrder; |
| }); |
| TraversalMainMessage(resource struct { |
| v vector<box<TraversalMain>>:3; |
| s box<TraversalStruct>; |
| }); |
| |
| Protocol(resource struct { |
| ch client_end:ParamProtocol; |
| }); |
| }; |
| |
| type BoolStructType = struct { |
| b bool; |
| }; |
| |
| type PrimitiveTypes = struct { |
| s string:100; |
| b bool; |
| i8 int8; |
| i16 int16; |
| i32 int32; |
| i64 int64; |
| u8 uint8; |
| u16 uint16; |
| u32 uint32; |
| u64 uint64; |
| f32 float32; |
| f64 float64; |
| }; |
| |
| type SmallStruct = struct { |
| a uint8; |
| b uint8; |
| c uint8; |
| }; |
| |
| type SmallUnevenStruct = struct { |
| a uint32; |
| b uint8; |
| }; |
| |
| type TwoStringStruct = struct { |
| value1 string:100; |
| value2 string:100; |
| }; |
| |
| type IntStructUnion = strict union { |
| 1: variant_i int32; |
| 2: variant_tss TwoStringStruct; |
| }; |
| |
| type IntStructXunion = flexible union { |
| 1: variant_i int32; |
| 2: variant_tss TwoStringStruct; |
| }; |
| |
| type U8U16Union = strict union { |
| 1: variant_u8 uint8; |
| 2: variant_u16 uint16; |
| }; |
| |
| type U8U16UnionReserved = strict union { |
| 1: variant_u8 uint8; |
| 2: reserved; |
| 3: variant_u16 uint16; |
| }; |
| |
| type U8U16Xunion = flexible union { |
| 1: variant_u8 uint8; |
| 2: variant_u16 uint16; |
| }; |
| |
| // Mostly copied from sdk/fidl/fuchsia.bluetooth.bredr/service.fidl |
| |
| const MAX_SEQUENCE_LENGTH uint8 = 255; |
| const MAX_STRING_LENGTH uint16 = 1024; |
| |
| type DataElement = strict union { |
| 1: int8 int8; |
| 2: int16 int16; |
| 3: int32 int32; |
| 4: int64 int64; |
| 5: uint8 uint8; |
| 6: uint16 uint16; |
| 7: uint32 uint32; |
| 8: uint64 uint64; |
| 9: str string:MAX_STRING_LENGTH; |
| 10: b bool; |
| 11: sequence vector<DataElement:optional>:MAX_SEQUENCE_LENGTH; |
| 12: alternatives vector<DataElement:optional>:MAX_SEQUENCE_LENGTH; |
| }; |
| |
| type U8U16UnionStructType = struct { |
| u U8U16Union; |
| }; |
| |
| type DefaultEnum = strict enum { |
| X = 23; |
| }; |
| |
| type I8Enum = strict enum : int8 { |
| X = -23; |
| }; |
| |
| type I16Enum = strict enum : int16 { |
| X = -23; |
| }; |
| |
| type I32Enum = strict enum : int32 { |
| X = -23; |
| }; |
| |
| type I64Enum = strict enum : int64 { |
| X = -23; |
| }; |
| |
| type DefaultBits = strict bits { |
| A = 1; |
| B = 2; |
| C = 4; |
| D = 8; |
| }; |
| |
| type I8Bits = strict bits : uint8 { |
| A = 1; |
| B = 2; |
| C = 4; |
| D = 8; |
| }; |
| |
| type I16Bits = strict bits : uint16 { |
| A = 0x100; |
| B = 0x200; |
| C = 0x400; |
| D = 0x800; |
| }; |
| |
| type I32Bits = strict bits : uint64 { |
| A = 0x10000; |
| B = 0x20000; |
| C = 0x40000; |
| D = 0x80000; |
| }; |
| |
| type I64Bits = strict bits : uint64 { |
| A = 0x100000000; |
| B = 0x200000000; |
| C = 0x400000000; |
| D = 0x800000000; |
| }; |
| |
| type ValueTable = table { |
| 1: first_int16 int16; |
| 2: second_struct TwoStringStruct; |
| 3: reserved; |
| 4: third_union IntStructUnion; |
| }; |
| |
| type HandleStruct = resource struct { |
| h1 zx.handle:CHANNEL; |
| h2 zx.handle:CHANNEL; |
| h3 zx.handle:CHANNEL; |
| }; |
| |
| type OptHandleStruct = resource struct { |
| sh1 zx.handle:<CHANNEL, optional>; |
| sh2 zx.handle:<CHANNEL, optional>; |
| }; |
| |
| type HandleTable = resource table { |
| 1: h1 zx.handle:CHANNEL; |
| 2: s1 OptHandleStruct; |
| }; |
| |
| type TraversalOrder = resource struct { |
| s box<OptHandleStruct>; |
| h1 zx.handle:<CHANNEL, optional>; |
| h2 zx.handle:<CHANNEL, optional>; |
| }; |
| |
| type TraversalStruct = resource struct { |
| a uint32; |
| b zx.handle:<CHANNEL, optional>; |
| }; |
| |
| type TraversalMain = resource struct { |
| x uint32; |
| y box<TraversalStruct>; |
| }; |
| |
| protocol ParamProtocol { |
| Method(); |
| }; |