src/lib/fidl_codec/testdata/types.test.fidl

// 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();
};