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