src/lib/fidl/llcpp/tests/integration/handle_raii.test.fidl

// Copyright 2020 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.handleraii.test;

using zx;

type HandleStruct = resource struct {
    h zx.Handle:EVENT;
};

type HandleStructStruct = resource struct {
    s HandleStruct;
};

type MultiFieldStruct = resource struct {
    h1 zx.Handle:EVENT;
    s HandleStruct;
    h2 zx.Handle:EVENT;
};

type HandleStructOptionalStruct = resource struct {
    s box<HandleStruct>;
};

type VectorStruct = resource struct {
    v vector<HandleStruct>;
};

type ArrayStruct = resource struct {
    a array<HandleStruct, 3>;
};

type HandleUnion = strict resource union {
    1: h1 zx.Handle:EVENT;
    2: h2 HandleStruct;
};

type HandleUnionStruct = resource struct {
    u HandleUnion;
};

type HandleUnionOptionalStruct = resource struct {
    u HandleUnion:optional;
};

type HandleTable = resource table {
    1: h1 zx.Handle:EVENT;
    2: h2 HandleStruct;
};

type HandleTableStruct = resource struct {
    t HandleTable;
};

closed protocol HandleProvider {
    strict GetHandle() -> (resource struct {
        value zx.Handle:EVENT;
    });
    strict GetHandleStruct() -> (resource struct {
        value HandleStruct;
    });
    strict GetHandleStructStruct() -> (resource struct {
        value HandleStructStruct;
    });
    strict GetMultiFieldStruct() -> (resource struct {
        value MultiFieldStruct;
    });
    strict GetMultiArgs() -> (resource struct {
        h1 zx.Handle:EVENT;
        s HandleStruct;
        h2 zx.Handle:EVENT;
    });
    strict GetVectorStruct(struct {
        count uint32;
    }) -> (resource struct {
        value VectorStruct;
    });
    strict GetArrayStruct() -> (resource struct {
        value ArrayStruct;
    });
    strict GetHandleUnion(struct {
        field int32;
    }) -> (resource struct {
        value HandleUnion;
    });
    strict GetHandleUnionStruct(struct {
        field int32;
    }) -> (resource struct {
        value HandleUnionStruct;
    });
    strict GetHandleTable(struct {
        fields uint32;
    }) -> (resource struct {
        value HandleTable;
    });
    strict GetHandleTableStruct(struct {
        fields uint32;
    }) -> (resource struct {
        value HandleTableStruct;
    });

    strict GetOptionalHandleStruct(struct {
        defined bool;
    }) -> (resource struct {
        value box<HandleStruct>;
    });
    strict GetOptionalHandleUnion(struct {
        field int32;
    }) -> (resource struct {
        value HandleUnion:optional;
    });
    strict GetOptionalHandleUnionStruct(struct {
        defined bool;
        field int32;
    }) -> (resource struct {
        value box<HandleUnionStruct>;
    });
    strict GetOptionalHandleTableStruct(struct {
        defined bool;
        fields uint32;
    }) -> (resource struct {
        value box<HandleTableStruct>;
    });

    strict GetHandleStructOptionalStruct(struct {
        defined bool;
    }) -> (resource struct {
        value HandleStructOptionalStruct;
    });
    strict GetHandleUnionOptionalStruct(struct {
        defined bool;
        field int32;
    }) -> (resource struct {
        value HandleUnionOptionalStruct;
    });

    strict GetVectorOfHandle(struct {
        count uint32;
    }) -> (resource struct {
        value vector<zx.Handle:EVENT>;
    });
    strict GetVectorOfVectorOfHandle(struct {
        count1 uint32;
        count2 uint32;
    }) -> (resource struct {
        value vector<vector<zx.Handle:EVENT>>;
    });
    strict GetVectorOfVectorOfVectorOfHandle(struct {
        count1 uint32;
        count2 uint32;
        count3 uint32;
    }) -> (resource struct {
        value vector<vector<vector<zx.Handle:EVENT>>>;
    });

    strict GetVectorOfHandleStruct(struct {
        count uint32;
    }) -> (resource struct {
        value vector<HandleStruct>;
    });
    strict GetVectorOfVectorOfHandleStruct(struct {
        count1 uint32;
        count2 uint32;
    }) -> (resource struct {
        value vector<vector<HandleStruct>>;
    });
    strict GetVectorOfVectorOfVectorOfHandleStruct(struct {
        count1 uint32;
        count2 uint32;
        count3 uint32;
    }) -> (resource struct {
        value vector<vector<vector<HandleStruct>>>;
    });

    strict GetArrayOfHandle() -> (resource struct {
        value array<zx.Handle:EVENT, 2>;
    });
    strict GetArrayOfArrayOfHandle() -> (resource struct {
        value array<array<zx.Handle:EVENT, 2>, 3>;
    });
    strict GetArrayOfArrayOfArrayOfHandle() -> (resource struct {
        value array<array<array<zx.Handle:EVENT, 2>, 3>, 4>;
    });

    strict GetArrayOfHandleStruct() -> (resource struct {
        value array<HandleStruct, 2>;
    });
    strict GetArrayOfArrayOfHandleStruct() -> (resource struct {
        value array<array<HandleStruct, 2>, 3>;
    });
    strict GetArrayOfArrayOfArrayOfHandleStruct() -> (resource struct {
        value array<array<array<HandleStruct, 2>, 3>, 4>;
    });

    strict GetMixed1(struct {
        count uint32;
    }) -> (resource struct {
        value array<vector<zx.Handle:EVENT>, 2>;
    });
    strict GetMixed2(struct {
        count uint32;
    }) -> (resource struct {
        value vector<array<zx.Handle:EVENT, 2>>;
    });
};