src/lib/fidl/llcpp/tests/integration/flexible.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 llcpptest.flexible.test;

using zx;

type FlexibleXUnion = flexible resource union {
    1: want_more_than_30_bytes array<uint8, 30>;
    2: want_more_than_4_handles array<zx.Handle:optional, 4>;
};

/// Only one of the fields will be set by the server. This allows
/// the transaction to infer which field is present. See flexible_test.cc.
type FlexibleTable = resource table {
    1: want_more_than_30_bytes_at_ordinal_3 array<uint8, 30>;
    2: want_more_than_4_handles_at_ordinal_4 array<zx.Handle:optional, 4>;
};

/// The server will be implemented manually to purposefully return xunion/tables
/// with an unknown ordinal.
closed protocol ReceiveFlexibleEnvelope {
    /// Receive a xunion with an unknown ordinal (suppose coming from a newer
    /// server) which contains more bytes than the current max message size.
    strict GetUnknownXUnionMoreBytes() -> (resource struct {
        xu FlexibleXUnion;
    });

    /// Receive a xunion with an unknown ordinal (suppose coming from a newer
    /// server) which contains more handles than the current max message handle
    /// count.
    strict GetUnknownXUnionMoreHandles() -> (resource struct {
        xu FlexibleXUnion;
    });

    /// Receive a table with an unknown ordinal (suppose coming from a newer
    /// server) which contains more bytes than the current max message size.
    strict GetUnknownTableMoreBytes() -> (resource struct {
        t FlexibleTable;
    });

    /// Receive a table with an unknown ordinal (suppose coming from a newer
    /// server) which contains more handles than the current max message handle
    /// count.
    strict GetUnknownTableMoreHandles() -> (resource struct {
        t FlexibleTable;
    });

    /// Receive a xunion with an unknown ordinal (suppose coming from a newer
    /// server) which contains more bytes than the current max message size.
    strict -> OnUnknownXUnionMoreBytes(FlexibleXUnion);

    /// Receive a xunion with an unknown ordinal (suppose coming from a newer
    /// server) which contains more handles than the current max message handle
    /// count.
    strict -> OnUnknownXUnionMoreHandles(FlexibleXUnion);

    /// Receive a table with an unknown ordinal (suppose coming from a newer
    /// server) which contains more bytes than the current max message size.
    strict -> OnUnknownTableMoreBytes(FlexibleTable);

    /// Receive a table with an unknown ordinal (suppose coming from a newer
    /// server) which contains more handles than the current max message handle
    /// count.
    strict -> OnUnknownTableMoreHandles(FlexibleTable);
};

type StrictBoundedXUnion = strict union {
    1: v vector<uint8>:200;
};

type StrictUnboundedXUnion = strict union {
    1: v vector<uint8>;
};

// TODO(yifeit): Test strict tables once they are supported in fidlc.

/// Test that the response to GetBoundedXUnion could be allocated on the stack,
/// while that to GetUnboundedXUnion is allocated on the heap, through
/// compile-time assertions.
closed protocol ReceiveStrictEnvelope {
    strict GetBoundedXUnion() -> (struct {
        xu StrictBoundedXUnion;
    });
    strict GetUnboundedXUnion() -> (struct {
        xu StrictUnboundedXUnion;
    });
};