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;

closed protocol Echo {
    strict EchoString(struct {
        value string:<100, optional>;
    }) -> (struct {
        response string:<100, optional>;
    });
};

type Named = struct {
    s string:200;
};

alias NamedAlias = Named;

alias StringAlias = string:100;

alias VectorAlias = vector<NamedAlias>:20;

alias HandleAlias = zx.Handle;

closed protocol FidlCodecTestProtocol {
    strict Empty();
    strict String(struct {
        s string:100;
    });
    strict Named(Named);
    strict Bool(struct {
        b bool;
    });
    strict Int8(struct {
        i8 int8;
    });
    strict Int16(struct {
        i16 int16;
    });
    strict Int32(struct {
        i32 int32;
    });
    strict Int64(struct {
        i64 int64;
    });
    strict Uint8(struct {
        ui8 uint8;
    });
    strict Uint16(struct {
        ui16 uint16;
    });
    strict Uint32(struct {
        ui32 uint32;
    });
    strict Uint64(struct {
        ui64 uint64;
    });
    strict Float32(struct {
        f32 float32;
    });
    strict Float64(struct {
        f64 float64;
    });

    strict Complex(struct {
        real int32;
        imaginary int32;
    });
    strict StringInt(struct {
        s string:100;
        i32 int32;
    });
    strict StringIntTable(table {
        1: s string:100;
        2: i32 int32;
    });
    strict StringIntUnion(union {
        1: s string:100;
        2: i32 int32;
    });
    strict StructIntUnion(union {
        1: structomatic struct {
            s string:100;
            i32 int32;
        };
        2: i32 int32;
    });
    strict Array1(struct {
        b_1 array<int32, 1>;
    });
    strict Array2(struct {
        b_2 array<int32, 2>;
    });
    strict Vector(struct {
        v_1 vector<int32>:<10, optional>;
    });

    strict TwoStringArrayInt(struct {
        arr array<string:100, 2>;
        i32 int32;
    });
    strict TwoStringVectorInt(struct {
        vec vector<string:100>:10;
        i32 int32;
    });
    strict TwoStringVectors(struct {
        v_1 vector<string:100>:10;
        v_2 vector<string:100>:10;
    });
    strict VectorUint8(struct {
        v vector<uint8>:100;
    });
    strict VectorUint32(struct {
        v vector<uint32>:100;
    });
    strict VectorStruct(struct {
        v vector<SmallStruct>:100;
    });
    strict ArrayStruct(struct {
        a array<SmallStruct, 3>;
    });
    strict VectorStruct2(struct {
        v vector<SmallUnevenStruct>:100;
    });
    strict ArrayStruct2(struct {
        a array<SmallUnevenStruct, 3>;
    });

    strict Struct(struct {
        p PrimitiveTypes;
    });
    strict BoolStruct(struct {
        s BoolStructType;
    });
    strict NullableStruct(struct {
        p box<PrimitiveTypes>;
    });
    strict NullableStructAndInt(struct {
        p box<PrimitiveTypes>;
        i int32;
    });
    strict ArrayNullableStruct(struct {
        a array<box<TwoStringStruct>, 3>;
    });

    strict SmallStructAfterByte(struct {
        u uint8;
        s1 SmallStruct;
        s2 SmallStruct;
    });

    strict TwoStringStructInt(struct {
        s TwoStringStruct;
        i32 int32;
    });
    strict TwoStringNullableStructInt(struct {
        s box<TwoStringStruct>;
        i32 int32;
    });

    strict Union(struct {
        isu IntStructUnion;
        i int32;
    });
    strict NullableUnion(struct {
        isu IntStructUnion:optional;
        i int32;
    });
    strict NullableUnionIntFirst(struct {
        i int32;
        isu IntStructUnion:optional;
    });
    strict ArrayNullableUnion(struct {
        a array<IntStructUnion:optional, 3>;
    });

    strict XUnion(struct {
        isu IntStructXunion;
        i int32;
    });
    strict NullableXUnion(struct {
        isu IntStructXunion:optional;
        i int32;
    });
    strict NullableXUnionIntFirst(struct {
        i int32;
        isu IntStructXunion:optional;
    });

    strict ShortUnion(struct {
        u U8U16Union;
        i int32;
    });
    strict ShortUnionReserved(struct {
        u U8U16UnionReserved;
        i int32;
    });
    strict ShortXUnion(struct {
        u U8U16Xunion;
        i int32;
    });
    strict RecursiveUnion(struct {
        e DataElement;
    });

    strict U8U16UnionStruct(struct {
        s U8U16UnionStructType;
    });

    strict DefaultEnumMessage(struct {
        ev DefaultEnum;
    });
    strict I8EnumMessage(struct {
        ev I8Enum;
    });
    strict I16EnumMessage(struct {
        ev I16Enum;
    });
    strict I32EnumMessage(struct {
        ev I32Enum;
    });
    strict I64EnumMessage(struct {
        ev I64Enum;
    });

    strict DefaultBitsMessage(struct {
        v DefaultBits;
    });
    strict I8BitsMessage(struct {
        v I8Bits;
    });
    strict I16BitsMessage(struct {
        v I16Bits;
    });
    strict I32BitsMessage(struct {
        v I32Bits;
    });
    strict I64BitsMessage(struct {
        v I64Bits;
    });

    strict Table(struct {
        table ValueTable;
        i int32;
    });

    strict TableToBool(struct {
        setattr ValueTable;
        i int32;
    }) -> (struct {
        finally bool;
    });

    strict Handle(resource struct {
        ch zx.Handle:CHANNEL;
    });
    strict NullableHandle(resource struct {
        ch zx.Handle:<CHANNEL, optional>;
    });
    strict HandleStructMessage(resource struct {
        hs HandleStruct;
    });
    strict HandleTableMessage(resource struct {
        t HandleTable;
    });
    strict TraversalOrderMessage(resource struct {
        t TraversalOrder;
    });
    strict TraversalMainMessage(resource struct {
        v vector<box<TraversalMain>>:3;
        s box<TraversalStruct>;
    });

    // Named ProtocolMethod because the natural bindings
    // do not support a method named Protocol.
    strict ProtocolMethod(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;
    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;
const ALWAYS_TRUE bool = true;
const PI float32 = 3.14159265;
const BITS DefaultEnum = DefaultEnum.X;

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;
    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>;
};

closed protocol ParamProtocol {
    strict Method();
};