src/lib/fidl/c/coding_tables_tests/coding_tables.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 fidl.test.example.codingtables;

using fidl.test.example.codingtablesdeps as deplib;

type SomeStruct = struct {
    foo bool;
    bar int32;
};

// Tested in StructWithSomeFieldsRemoved.
// All fields in this struct don't have actions in coding tables.
type StructWithAllFieldsRemovedFromCodingTables = struct {
    a int8;
    b int8;
    c int16;
};

// Tested in StructWithSomeFieldsRemoved.
type StructWithPadding = struct {
    a int8;
    c int64;
};

type PaddingAtEndStruct = struct {
    a uint16;
    b uint8;
};

// Some fields in this struct should be removed from coding tables because
// they have no action and the walker can skip over them.
type StructWithSomeFieldsRemovedFromCodingTables = struct {
    padding_struct StructWithPadding; // not removed
    // PaddingAtEndStruct contains 3 bytes with 1 final byte of padding
    // When the struct is flattened, this becomes 5 bytes of padding.
    padding_at_end_struct PaddingAtEndStruct;
    reset_alignment uint64;
    foo int8; // removed
    // 1 bytes padding.
    arr array<StructWithAllFieldsRemovedFromCodingTables, 1>; // removed
    bool_array array<bool, 1>; // not removed
    // 1 byte padding.
    bar uint16; // removed
};

type MyXUnion = flexible union {
    1: foo bool;
    2: bar int32;
};

type MyStrictXUnion = strict union {
    1: foo bool;
    2: bar int32;
};

type MyTable = table {
    1: foo bool;
    2: bar int32;
    4: baz array<uint64, 42>;
    5: qux vector<uint64>:42;
};

type MyBits = strict bits : uint8 {
    HELLO = 0x1;
    WORLD = 0x10;
};

type MyEnum = strict enum : uint32 {
    FOO = 1;
    BAR = 42;
};

// Types defined to detect collisions in the mangled coding table output.
type A = struct {};

type A1 = struct {};

type NumberCollision = struct {
    a array<A, 11>;
    b array<A1, 1>;
    c vector<A>:11;
    d vector<A1>:1;
    e string:11;
    f string:1;
};

// fidlc will only expose coding tables for message types.
// However, we can obtain the coding tables for SomeStruct/MyXUnion etc. via the coding table
// for request message types, by defining dummy methods which take a single desired argument.
closed protocol Coding {
    strict SomeStruct(struct {
        s SomeStruct;
    });
    strict StructWithSomeFieldsRemovedFromCodingTables(struct {
        s StructWithSomeFieldsRemovedFromCodingTables;
    });

    // Various trickery to avoid directly refering a xunion/table inline,
    // which is not supported in the C bindings.
    strict MyXUnion(struct {
        x MyXUnion:optional;
    });
    strict MyStrictXUnion(struct {
        x MyStrictXUnion:optional;
    });

    // Ensuring support for multiple uses of the same nullable type.
    strict MyXUnion2(struct {
        x MyXUnion:optional;
    });
    strict MyStrictXUnion2(struct {
        x MyStrictXUnion:optional;
    });

    strict VectorOfMyTable(struct {
        t vector<MyTable>;
    });
    strict VectorOfMyXUnion(struct {
        x vector<MyXUnion>;
    });
    strict VectorOfMyStrictXUnion(struct {
        x vector<MyStrictXUnion>;
    });

    strict MyBits(struct {
        b MyBits;
    });
    strict MyEnum(struct {
        e MyEnum;
    });

    strict NumberCollision(struct {
        x NumberCollision;
    });

    strict ForeignXUnions(struct {
        tx deplib.MyXUnionA;
    }) -> (struct {
        rx deplib.MyXUnionA:optional;
    });
};