| // 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. |
| |
| success("SingleHandle") { |
| handle_defs = { |
| #0 = event(), |
| }, |
| value = SingleHandle{ |
| h: #0, |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| } |
| |
| encode_failure("AbsentNonOptionalHandle") { |
| value = SingleHandle{ |
| h: null, |
| }, |
| err = NON_NULLABLE_TYPE_WITH_NULL_VALUE, |
| } |
| |
| decode_failure("AbsentNonOptionalHandle") { |
| bytes = { |
| v2 = [ |
| repeat(0x00):4, padding:4, |
| ], |
| }, |
| type = SingleHandle, |
| err = NON_NULLABLE_TYPE_WITH_NULL_VALUE, |
| } |
| |
| success("SingleOptionalHandlePresent") { |
| handle_defs = { |
| #0 = event(), |
| }, |
| value = SingleOptionalHandle{ |
| h: #0, |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| } |
| |
| success("SingleOptionalHandleAbsent") { |
| value = SingleOptionalHandle{}, |
| bytes = { |
| v2 = [ |
| repeat(0x00):4, padding:4, |
| ], |
| }, |
| } |
| |
| decode_failure("SingleHandleMissingAndInvalidPresenceIndicator") { |
| bindings_denylist = [dart], |
| bytes = { |
| v2 = [ |
| repeat(0xab):4, padding:4, |
| ], |
| }, |
| type = SingleOptionalHandle, |
| err = INVALID_HANDLE_PRESENCE_INDICATOR, |
| } |
| |
| decode_failure("SingleHandleInvalidPresenceIndicator") { |
| bindings_denylist = [dart], |
| handle_defs = { |
| #0 = event(), |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xab):4, padding:4, |
| ], |
| }, |
| handles = {v2 = [#0]}, |
| type = SingleOptionalHandle, |
| err = INVALID_HANDLE_PRESENCE_INDICATOR, |
| } |
| |
| success("ArrayOfHandles") { |
| handle_defs = { |
| #0 = event(), |
| #1 = event(), |
| #2 = event(), |
| }, |
| value = ArrayOfHandles{ |
| a: [#2, #0, #1], |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #2, #0, #1, |
| ], |
| }, |
| } |
| |
| success("ArrayOfOptionalHandles") { |
| handle_defs = { |
| #0 = event(), |
| }, |
| value = ArrayOfOptionalHandles{ |
| a: [null, #0, null], |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0x00):4, repeat(0xff):4, repeat(0x00):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| } |
| |
| success("VectorOfHandles") { |
| handle_defs = { |
| #0 = event(), |
| #1 = event(), |
| #2 = event(), |
| }, |
| value = VectorOfHandles{ |
| v: [#2, #0, #1], |
| }, |
| bytes = { |
| v2 = [ |
| num(3):8, repeat(0xff):8, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #2, #0, #1, |
| ], |
| }, |
| } |
| |
| success("BoxOfSingleHandlePresentBox") { |
| handle_defs = { |
| #0 = event(), |
| }, |
| value = BoxOfSingleHandle{ |
| b: SingleHandle{ |
| h: #0, |
| }, |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xff):8, |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| } |
| |
| success("BoxOfSingleHandleAbsentBox") { |
| value = BoxOfSingleHandle{}, |
| bytes = { |
| v2 = [ |
| repeat(0x00):8, |
| ], |
| }, |
| } |
| |
| success("BoxOfSingleOptionalHandlePresentBoxPresentHandle") { |
| handle_defs = { |
| #0 = event(), |
| }, |
| value = BoxOfSingleOptionalHandle{ |
| b: SingleOptionalHandle{ |
| h: #0, |
| }, |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xff):8, |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| } |
| |
| success("BoxOfSingleOptionalHandlePresentBoxAbsentHandle") { |
| value = BoxOfSingleOptionalHandle{ |
| b: SingleOptionalHandle{}, |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xff):8, |
| repeat(0x00):4, padding:4, |
| ], |
| }, |
| } |
| |
| success("BoxOfSingleOptionalHandleAbsentBox") { |
| value = BoxOfSingleOptionalHandle{}, |
| bytes = { |
| v2 = [ |
| repeat(0x00):8, |
| ], |
| }, |
| } |
| |
| success("StructOfOptionalUnionOfHandlePresent") { |
| handle_defs = { |
| #0 = event(), |
| }, |
| value = StructOfOptionalUnionOfHandle{ |
| u: UnionOfHandle{ |
| h: #0, |
| }, |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):4, num(1):2, num(1):2, // inlined envelope |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| } |
| |
| success("StructOfOptionalUnionOfHandleAbsent") { |
| value = StructOfOptionalUnionOfHandle{}, |
| bytes = { |
| v2 = [ |
| num(0):8, // zero ordinal |
| num(0):4, num(0):2, num(0):2, // empty envelope |
| ], |
| }, |
| } |
| |
| // When a failure is encountered, bindings must ensure that handles located |
| // both before and after the failure are closed. A third handle is included |
| // in the test to ensure that there are no double-closes in encoders that |
| // do not exit early upon failure. |
| encode_failure("HandlesBeforeAndAfterFailureAreClosed") { |
| // TODO(96626): Should close handles in some constraint violation cases. |
| bindings_denylist = [hlcpp, go, dart], |
| handle_defs = { |
| #0 = event(), |
| #1 = event(), |
| #2 = event(), |
| }, |
| value = AlternatingHandlesAndFailures{ |
| h1: #0, |
| failure_trigger1: "abc", |
| h2: #1, |
| failure_trigger2: "abc", |
| h3: #2, |
| }, |
| err = STRING_TOO_LONG, |
| } |
| |
| // When a failure is encountered, bindings must ensure that handles located |
| // both before and after the failure are closed. A third handle is included |
| // in the test to ensure that there are no double-closes in encoders that |
| // do not exit early upon failure. |
| decode_failure("HandlesBeforeAndAfterFailureAreClosed") { |
| // TODO(https://fxbug.dev/42051700) In rust, this is failing for an unknown reason. |
| // TODO(https://fxbug.dev/42051715) In dart, this is failing for an unknown reason. |
| bindings_denylist = [rust, dart], |
| handle_defs = { |
| #0 = event(), |
| #1 = event(), |
| #2 = event(), |
| }, |
| type = AlternatingHandlesAndFailures, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, padding:4, // h1 |
| num(3):8, // failure_trigger1 |
| repeat(0xff):8, |
| repeat(0xff):4, padding:4, // h2 |
| num(3):8, // failure_trigger2 |
| repeat(0xff):8, |
| repeat(0xff):4, padding:4, // h3 |
| |
| 0x61, 0x62, 0x63, padding:5, |
| 0x61, 0x62, 0x63, padding:5, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, #1, #2, |
| ], |
| }, |
| err = STRING_TOO_LONG, |
| } |
| |
| // Handles inside the vector should be closed even if the vector itself |
| // has a constraint error. |
| encode_failure("TooManyHandlesInVector") { |
| // TODO(96626): Should close handles in some constraint violation cases. |
| bindings_denylist = [llcpp, hlcpp, go, dart], |
| handle_defs = { |
| #0 = event(), |
| #1 = event(), |
| #2 = event(), |
| }, |
| value = VectorOfUpTo2Handles{ |
| v: [#2, #0, #1], |
| }, |
| err = COUNT_EXCEEDS_LIMIT, |
| } |
| |
| // Handle members coming after the string should be closed even if the string |
| // has a constraint error. |
| encode_failure("UnrelatedConstraintErrorBeforeHandle") { |
| // TODO(96626): Should close handles in some constraint violation cases. |
| bindings_denylist = [hlcpp, go, dart], |
| handle_defs = { |
| #0 = event(), |
| }, |
| value = ShortStringThenHandle{ |
| s: "long", |
| h: #0, |
| }, |
| err = STRING_TOO_LONG, |
| } |
| |
| success("VectorOfOptionalHandles") { |
| handle_defs = { |
| #0 = event(), |
| }, |
| value = VectorOfOptionalHandles{ |
| v: [null, #0, null], |
| }, |
| bytes = { |
| v2 = [ |
| num(3):8, repeat(0xff):8, |
| repeat(0x00):4, repeat(0xff):4, repeat(0x00):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| } |
| |
| success("MultipleHandleSubtypes") { |
| handle_defs = { |
| #0 = channel(), |
| #1 = event(), |
| #2 = channel(), |
| }, |
| value = MultipleHandleSubtypes{ |
| untyped: #0, |
| event: #1, |
| channel: #2, |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, #1, #2, |
| ], |
| }, |
| } |
| |
| decode_failure("TooManyHandles") { |
| bindings_denylist = [rust], |
| handle_defs = { |
| #0 = event(), |
| #1 = event(), |
| }, |
| type = SingleHandle, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, #1, |
| ], |
| }, |
| err = TOO_MANY_HANDLES_IN_MESSAGE, |
| } |
| |
| decode_failure("TooFewHandles") { |
| type = SingleHandle, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| err = TOO_FEW_HANDLES, |
| } |
| |
| // Currently channels max out at 64-handles. |
| success("ChannelMaxHandles") { |
| handle_defs = { |
| #0 = event(), #1 = event(), #2 = event(), #3 = event(), |
| #4 = event(), #5 = event(), #6 = event(), #7 = event(), |
| #8 = event(), #9 = event(), #10 = event(), #11 = event(), |
| #12 = event(), #13 = event(), #14 = event(), #15 = event(), |
| #16 = event(), #17 = event(), #18 = event(), #19 = event(), |
| #20 = event(), #21 = event(), #22 = event(), #23 = event(), |
| #24 = event(), #25 = event(), #26 = event(), #27 = event(), |
| #28 = event(), #29 = event(), #30 = event(), #31 = event(), |
| #32 = event(), #33 = event(), #34 = event(), #35 = event(), |
| #36 = event(), #37 = event(), #38 = event(), #39 = event(), |
| #40 = event(), #41 = event(), #42 = event(), #43 = event(), |
| #44 = event(), #45 = event(), #46 = event(), #47 = event(), |
| #48 = event(), #49 = event(), #50 = event(), #51 = event(), |
| #52 = event(), #53 = event(), #54 = event(), #55 = event(), |
| #56 = event(), #57 = event(), #58 = event(), #59 = event(), |
| #60 = event(), #61 = event(), #62 = event(), #63 = event(), |
| }, |
| value = VectorOfHandles{ |
| v: [ |
| #0, #1, #2, #3, #4, #5, #6, #7, |
| #8, #9, #10, #11, #12, #13, #14, #15, |
| #16, #17, #18, #19, #20, #21, #22, #23, |
| #24, #25, #26, #27, #28, #29, #30, #31, |
| #32, #33, #34, #35, #36, #37, #38, #39, |
| #40, #41, #42, #43, #44, #45, #46, #47, |
| #48, #49, #50, #51, #52, #53, #54, #55, |
| #56, #57, #58, #59, #60, #61, #62, #63, |
| ], |
| }, |
| bytes = { |
| v2 = [ |
| num(64):8, repeat(0xff):8, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, repeat(0xff):4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, #1, #2, #3, #4, #5, #6, #7, |
| #8, #9, #10, #11, #12, #13, #14, #15, |
| #16, #17, #18, #19, #20, #21, #22, #23, |
| #24, #25, #26, #27, #28, #29, #30, #31, |
| #32, #33, #34, #35, #36, #37, #38, #39, |
| #40, #41, #42, #43, #44, #45, #46, #47, |
| #48, #49, #50, #51, #52, #53, #54, #55, |
| #56, #57, #58, #59, #60, #61, #62, #63, |
| ], |
| }, |
| } |
| |
| // There should be support for at least 64 handles in unknown fields. |
| decode_success("ChannelMaxUnknownHandlesDropped") { |
| // TODO(https://fxbug.dev/42166276): Drop unknown data in all bindings. |
| bindings_denylist = [dart, go], |
| handle_defs = { |
| #0 = event(), #1 = event(), #2 = event(), #3 = event(), |
| #4 = event(), #5 = event(), #6 = event(), #7 = event(), |
| #8 = event(), #9 = event(), #10 = event(), #11 = event(), |
| #12 = event(), #13 = event(), #14 = event(), #15 = event(), |
| #16 = event(), #17 = event(), #18 = event(), #19 = event(), |
| #20 = event(), #21 = event(), #22 = event(), #23 = event(), |
| #24 = event(), #25 = event(), #26 = event(), #27 = event(), |
| #28 = event(), #29 = event(), #30 = event(), #31 = event(), |
| #32 = event(), #33 = event(), #34 = event(), #35 = event(), |
| #36 = event(), #37 = event(), #38 = event(), #39 = event(), |
| #40 = event(), #41 = event(), #42 = event(), #43 = event(), |
| #44 = event(), #45 = event(), #46 = event(), #47 = event(), |
| #48 = event(), #49 = event(), #50 = event(), #51 = event(), |
| #52 = event(), #53 = event(), #54 = event(), #55 = event(), |
| #56 = event(), #57 = event(), #58 = event(), #59 = event(), |
| #60 = event(), #61 = event(), #62 = event(), #63 = event(), |
| }, |
| value = EmptyResourceTableStruct{ |
| table: EmptyResourceTable{}, |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, repeat(0xff):8, // Table header |
| num(256):4, num(64):2, num(0):2, // Reserved envelope |
| repeat(0xff):256, // Handle values. |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, #1, #2, #3, #4, #5, #6, #7, |
| #8, #9, #10, #11, #12, #13, #14, #15, |
| #16, #17, #18, #19, #20, #21, #22, #23, |
| #24, #25, #26, #27, #28, #29, #30, #31, |
| #32, #33, #34, #35, #36, #37, #38, #39, |
| #40, #41, #42, #43, #44, #45, #46, #47, |
| #48, #49, #50, #51, #52, #53, #54, #55, |
| #56, #57, #58, #59, #60, #61, #62, #63, |
| ], |
| }, |
| } |
| |
| encode_success("ChannelMaxUnknownHandlesDropped") { |
| // TODO(https://fxbug.dev/42166276): Drop unknown data in all bindings. |
| // TODO(https://fxbug.dev/42067496): Implement the decode function in all backends. |
| bindings_allowlist = [rust], |
| handle_defs = { |
| #0 = event(), #1 = event(), #2 = event(), #3 = event(), |
| #4 = event(), #5 = event(), #6 = event(), #7 = event(), |
| #8 = event(), #9 = event(), #10 = event(), #11 = event(), |
| #12 = event(), #13 = event(), #14 = event(), #15 = event(), |
| #16 = event(), #17 = event(), #18 = event(), #19 = event(), |
| #20 = event(), #21 = event(), #22 = event(), #23 = event(), |
| #24 = event(), #25 = event(), #26 = event(), #27 = event(), |
| #28 = event(), #29 = event(), #30 = event(), #31 = event(), |
| #32 = event(), #33 = event(), #34 = event(), #35 = event(), |
| #36 = event(), #37 = event(), #38 = event(), #39 = event(), |
| #40 = event(), #41 = event(), #42 = event(), #43 = event(), |
| #44 = event(), #45 = event(), #46 = event(), #47 = event(), |
| #48 = event(), #49 = event(), #50 = event(), #51 = event(), |
| #52 = event(), #53 = event(), #54 = event(), #55 = event(), |
| #56 = event(), #57 = event(), #58 = event(), #59 = event(), |
| #60 = event(), #61 = event(), #62 = event(), #63 = event(), |
| }, |
| value = EmptyResourceTableStruct{ |
| table: decode({ |
| type = EmptyResourceTable, |
| bytes = { |
| v2 = [ |
| num(1):8, repeat(0xff):8, // Table header |
| num(256):4, num(64):2, num(0):2, // Reserved envelope |
| repeat(0xff):256, // Handle values. |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, #1, #2, #3, #4, #5, #6, #7, |
| #8, #9, #10, #11, #12, #13, #14, #15, |
| #16, #17, #18, #19, #20, #21, #22, #23, |
| #24, #25, #26, #27, #28, #29, #30, #31, |
| #32, #33, #34, #35, #36, #37, #38, #39, |
| #40, #41, #42, #43, #44, #45, #46, #47, |
| #48, #49, #50, #51, #52, #53, #54, #55, |
| #56, #57, #58, #59, #60, #61, #62, #63, |
| ], |
| }, |
| }), |
| }, |
| bytes = { |
| v2 = [ |
| num(0):8, repeat(0xff):8, // Table header |
| ], |
| }, |
| } |
| |
| // this test is the same as ChannelMaxUnknownHandlesDropped, but expects |
| // that the unknown data is stored in the value instead of discarded |
| success("ChannelMaxUnknownHandlesStored") { |
| // TODO(https://fxbug.dev/42166276): Remove in favor of ChannelMaxUnknownHandlesDropped. |
| bindings_allowlist = [dart, go], |
| handle_defs = { |
| #0 = event(), #1 = event(), #2 = event(), #3 = event(), |
| #4 = event(), #5 = event(), #6 = event(), #7 = event(), |
| #8 = event(), #9 = event(), #10 = event(), #11 = event(), |
| #12 = event(), #13 = event(), #14 = event(), #15 = event(), |
| #16 = event(), #17 = event(), #18 = event(), #19 = event(), |
| #20 = event(), #21 = event(), #22 = event(), #23 = event(), |
| #24 = event(), #25 = event(), #26 = event(), #27 = event(), |
| #28 = event(), #29 = event(), #30 = event(), #31 = event(), |
| #32 = event(), #33 = event(), #34 = event(), #35 = event(), |
| #36 = event(), #37 = event(), #38 = event(), #39 = event(), |
| #40 = event(), #41 = event(), #42 = event(), #43 = event(), |
| #44 = event(), #45 = event(), #46 = event(), #47 = event(), |
| #48 = event(), #49 = event(), #50 = event(), #51 = event(), |
| #52 = event(), #53 = event(), #54 = event(), #55 = event(), |
| #56 = event(), #57 = event(), #58 = event(), #59 = event(), |
| #60 = event(), #61 = event(), #62 = event(), #63 = event(), |
| }, |
| value = EmptyResourceTableStruct{ |
| table: EmptyResourceTable{ |
| 1: { |
| // 256 bytes for 64 handles' 4-byte presence markers. |
| bytes = [ |
| repeat(0xff):256, |
| ], |
| handles = [ |
| #0, #1, #2, #3, #4, #5, #6, #7, |
| #8, #9, #10, #11, #12, #13, #14, #15, |
| #16, #17, #18, #19, #20, #21, #22, #23, |
| #24, #25, #26, #27, #28, #29, #30, #31, |
| #32, #33, #34, #35, #36, #37, #38, #39, |
| #40, #41, #42, #43, #44, #45, #46, #47, |
| #48, #49, #50, #51, #52, #53, #54, #55, |
| #56, #57, #58, #59, #60, #61, #62, #63, |
| ], |
| }, |
| }, |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, repeat(0xff):8, // Table header |
| num(256):4, num(64):2, num(0):2, // Reserved envelope |
| repeat(0xff):256, // Handle values. |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, #1, #2, #3, #4, #5, #6, #7, |
| #8, #9, #10, #11, #12, #13, #14, #15, |
| #16, #17, #18, #19, #20, #21, #22, #23, |
| #24, #25, #26, #27, #28, #29, #30, #31, |
| #32, #33, #34, #35, #36, #37, #38, #39, |
| #40, #41, #42, #43, #44, #45, #46, #47, |
| #48, #49, #50, #51, #52, #53, #54, #55, |
| #56, #57, #58, #59, #60, #61, #62, #63, |
| ], |
| }, |
| } |
| |
| encode_success("EncodeHandleTypeAndRightsComeFromFIDL") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: channel_default), |
| }, |
| value = EventWithDefaultRights{ |
| h: #0, |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handle_dispositions = { |
| v2 = [ |
| {#0, type: event, rights: event_default}, |
| ], |
| }, |
| } |
| |
| decode_success("DecodeHandleHasExactTypeAndRights") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = event(rights: event_default), |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| value = EventWithDefaultRights{ |
| h: restrict(#0, type: event, rights: event_default), |
| }, |
| } |
| |
| decode_failure("DecodeHandleHasWrongType") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(), |
| }, |
| type = EventWithDefaultRights, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| err = INCORRECT_HANDLE_TYPE, |
| } |
| |
| decode_success("DecodeHandleHasExtraRights") { |
| // Rust does not support GIDL tests involving reducing rights. |
| bindings_allowlist = [llcpp, hlcpp, cpp, go], |
| handle_defs = { |
| #0 = event(rights: event_default), |
| }, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| value = EventWithReducedRights{ |
| h: restrict(#0, type: event, rights: basic), |
| }, |
| } |
| |
| decode_failure("DecodeHandleHasTooFewRights") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = event(rights: basic), |
| }, |
| type = EventWithDefaultRights, |
| bytes = { |
| v2 = [ |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| err = MISSING_REQUIRED_HANDLE_RIGHTS, |
| } |
| |
| // Vector and arrays can't hold handle type information in some bindings. |
| // Test this with structs, which may have different behavior than other types. |
| encode_success("EncodeArrayOfVectorOfEventInStruct") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: channel_default), |
| }, |
| value = ArrayOfVectorOfEventInStructWithReducedRights{h: [[#0]]}, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| repeat(0xff):4, |
| padding:4, |
| ], |
| }, |
| handle_dispositions = { |
| v2 = [ |
| {#0, type: event, rights: basic}, |
| ], |
| }, |
| } |
| |
| // Vector and arrays can't hold handle type information in some bindings. |
| // Test this with structs, which may have different behavior than other types. |
| encode_success("EncodeVectorOfArrayOfEventInStruct") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: channel_default), |
| }, |
| value = VectorOfArrayOfEventInStructWithReducedRights{h: [[#0]]}, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| repeat(0xff):4, |
| padding:4, |
| ], |
| }, |
| handle_dispositions = { |
| v2 = [ |
| {#0, type: event, rights: basic}, |
| ], |
| }, |
| } |
| |
| // Vector and arrays can't hold handle type information in some bindings. |
| // Test this with tables, which may have different behavior than other types. |
| encode_success("EncodeArrayOfVectorOfEventInTable") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: channel_default), |
| }, |
| value = ArrayOfVectorOfEventInTableWithReducedRightsStruct{ |
| t: ArrayOfVectorOfEventInTableWithReducedRights{ |
| h: [[#0]], |
| }, |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| |
| num(24):4, num(1):2, num(0):2, |
| |
| num(1):8, |
| repeat(0xff):8, |
| |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handle_dispositions = { |
| v2 = [ |
| {#0, type: event, rights: basic}, |
| ], |
| }, |
| } |
| |
| // Vector and arrays can't hold handle type information in some bindings. |
| // Test this with tables, which may have different behavior than other types. |
| encode_success("EncodeVectorOfArrayOfEventInTable") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: channel_default), |
| }, |
| value = VectorOfArrayOfEventInTableWithReducedRightsStruct{ |
| t: VectorOfArrayOfEventInTableWithReducedRights{ |
| h: [[#0]], |
| }, |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| |
| num(24):4, num(1):2, num(0):2, |
| |
| num(1):8, |
| repeat(0xff):8, |
| |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handle_dispositions = { |
| v2 = [ |
| {#0, type: event, rights: basic}, |
| ], |
| }, |
| } |
| |
| // Vector and arrays can't hold handle type information in some bindings. |
| // Test this with unions, which may have different behavior than other types. |
| encode_success("EncodeArrayOfVectorOfEventInUnion") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: channel_default), |
| }, |
| value = ArrayOfVectorOfEventInUnionWithReducedRightsStruct{ |
| u: ArrayOfVectorOfEventInUnionWithReducedRights{ |
| h: [[#0]], |
| }, |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| num(24):4, num(1):2, num(0):2, |
| |
| num(1):8, |
| repeat(0xff):8, |
| |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handle_dispositions = { |
| v2 = [ |
| {#0, type: event, rights: basic}, |
| ], |
| }, |
| } |
| |
| // Vector and arrays can't hold handle type information in some bindings. |
| // Test this with unions, which may have different behavior than other types. |
| encode_success("EncodeVectorOfArrayOfEventInUnion") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: channel_default), |
| }, |
| value = VectorOfArrayOfEventInUnionWithReducedRightsStruct{ |
| u: VectorOfArrayOfEventInUnionWithReducedRights{ |
| h: [[#0]], |
| }, |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| num(24):4, num(1):2, num(0):2, |
| |
| num(1):8, |
| repeat(0xff):8, |
| |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handle_dispositions = { |
| v2 = [ |
| {#0, type: event, rights: basic}, |
| ], |
| }, |
| } |
| |
| // Vector and arrays can't hold handle rights information in some bindings |
| // This behavior can also differ based on the type of the parent object holding |
| // the vector and arrays. |
| // Test whether handles in an array of a vector in a struct use the correct |
| // rights by reducing the rights. |
| decode_success("DecodeArrayOfVectorOfEventInStructExtraRights") { |
| // Rust does not support GIDL tests involving reducing rights. |
| bindings_allowlist = [llcpp, hlcpp, cpp, go], |
| handle_defs = { |
| #0 = event(rights: event_default), |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| repeat(0xff):4, |
| padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| value = ArrayOfVectorOfEventInStructWithReducedRights{ |
| h: [[restrict(#0, type: event, rights: basic)]], |
| }, |
| } |
| |
| decode_failure("DecodeArrayOfVectorOfEventInStructHasTooFewRights") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = event(rights: basic), |
| }, |
| type = ArrayOfVectorOfEventInStructWithDefaultRights, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| repeat(0xff):4, |
| padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| err = MISSING_REQUIRED_HANDLE_RIGHTS, |
| } |
| |
| // Vector and arrays can't hold handle type information in some bindings |
| // This behavior can also differ based on the type of the parent object holding |
| // the vector and arrays. |
| // Test whether handles in an array of a vector in a struct have the type |
| // checked by failing when there is a type mismatch. |
| decode_failure("DecodeArrayOfVectorOfEventInStructType") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: transfer), |
| }, |
| type = ArrayOfVectorOfEventInStructWithReducedRights, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| repeat(0xff):4, |
| padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| err = INCORRECT_HANDLE_TYPE, |
| } |
| |
| // Vector and arrays can't hold handle rights information in some bindings |
| // This behavior can also differ based on the type of the parent object holding |
| // the vector and arrays. |
| // Test whether handles in a vector of an array in a struct use the correct |
| // rights by reducing the rights. |
| decode_success("DecodeVectorOfArrayOfEventInStructExtraRights") { |
| // Rust does not support GIDL tests involving reducing rights. |
| bindings_allowlist = [llcpp, hlcpp, cpp, go], |
| handle_defs = { |
| #0 = event(rights: event_default), |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| repeat(0xff):4, |
| padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| value = VectorOfArrayOfEventInStructWithReducedRights{ |
| h: [[restrict(#0, type: event, rights: basic)]], |
| }, |
| } |
| |
| decode_failure("DecodeVectorOfArrayOfEventInStructHasTooFewRights") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = event(rights: basic), |
| }, |
| type = VectorOfArrayOfEventInStructWithDefaultRights, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| repeat(0xff):4, |
| padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| err = MISSING_REQUIRED_HANDLE_RIGHTS, |
| } |
| |
| // Vector and arrays can't hold handle type information in some bindings |
| // This behavior can also differ based on the type of the parent object holding |
| // the vector and arrays. |
| // Test whether handles in a vector of an array in a struct have the type |
| // checked by failing when there is a type mismatch. |
| decode_failure("DecodeVectorOfArrayOfEventInStructType") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: transfer), |
| }, |
| type = VectorOfArrayOfEventInStructWithReducedRights, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| repeat(0xff):4, |
| padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| err = INCORRECT_HANDLE_TYPE, |
| } |
| |
| // Vector and arrays can't hold handle rights information in some bindings |
| // This behavior can also differ based on the type of the parent object holding |
| // the vector and arrays. |
| // Test whether handles in an array of a vector in a table use the correct |
| // rights by reducing the rights. |
| decode_success("DecodeArrayOfVectorOfEventInTableExtraRights") { |
| // Rust does not support GIDL tests involving reducing rights. |
| bindings_allowlist = [llcpp, hlcpp, cpp, go], |
| handle_defs = { |
| #0 = event(rights: event_default), |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| |
| num(24):4, num(1):2, num(0):2, |
| |
| num(1):8, |
| repeat(0xff):8, |
| |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| value = ArrayOfVectorOfEventInTableWithReducedRightsStruct{ |
| t: ArrayOfVectorOfEventInTableWithReducedRights{ |
| h: [[restrict(#0, type: event, rights: basic)]], |
| }, |
| }, |
| } |
| |
| decode_failure("DecodeArrayOfVectorOfEventInTableHasTooFewRights") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = event(rights: basic), |
| }, |
| type = ArrayOfVectorOfEventInTableWithDefaultRightsStruct, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| |
| num(24):4, num(1):2, num(0):2, |
| |
| num(1):8, |
| repeat(0xff):8, |
| |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| err = MISSING_REQUIRED_HANDLE_RIGHTS, |
| } |
| |
| // Vector and arrays can't hold handle type information in some bindings |
| // This behavior can also differ based on the type of the parent object holding |
| // the vector and arrays. |
| // Test whether handles in an array of a vector in a table have the type |
| // checked by failing when there is a type mismatch. |
| decode_failure("DecodeArrayOfVectorOfEventInTableType") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: transfer), |
| }, |
| type = ArrayOfVectorOfEventInTableWithReducedRightsStruct, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| repeat(0xff):8, |
| |
| num(24):4, num(1):2, num(0):2, |
| |
| num(1):8, |
| repeat(0xff):8, |
| |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| err = INCORRECT_HANDLE_TYPE, |
| } |
| |
| // Vector and arrays can't hold handle rights information in some bindings |
| // This behavior can also differ based on the type of the parent object holding |
| // the vector and arrays. |
| // Test whether handles in an array of a vector in a union use the correct |
| // rights by reducing the rights. |
| decode_success("DecodeArrayOfVectorOfEventInUnionExtraRights") { |
| // Rust does not support GIDL tests involving reducing rights. |
| bindings_allowlist = [llcpp, hlcpp, cpp, go], |
| handle_defs = { |
| #0 = event(rights: event_default), |
| }, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| num(24):4, num(1):2, num(0):2, |
| |
| num(1):8, |
| repeat(0xff):8, |
| |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| value = ArrayOfVectorOfEventInUnionWithReducedRightsStruct{ |
| u: ArrayOfVectorOfEventInUnionWithReducedRights{ |
| h: [[restrict(#0, type: event, rights: basic)]], |
| }, |
| }, |
| } |
| |
| decode_failure("DecodeArrayOfVectorOfEventInUnionHasTooFewRights") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = event(rights: basic), |
| }, |
| type = ArrayOfVectorOfEventInUnionWithDefaultRightsStruct, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| num(24):4, num(1):2, num(0):2, |
| |
| num(1):8, |
| repeat(0xff):8, |
| |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| err = MISSING_REQUIRED_HANDLE_RIGHTS, |
| } |
| |
| // Vector and arrays can't hold handle type information in some bindings |
| // This behavior can also differ based on the type of the parent object holding |
| // the vector and arrays. |
| // Test whether handles in an array of a vector in a union have the type |
| // checked by failing when there is a type mismatch. |
| decode_failure("DecodeArrayOfVectorOfEventInUnionType") { |
| bindings_allowlist = [llcpp, hlcpp, cpp, go, rust, dart], |
| handle_defs = { |
| #0 = channel(rights: transfer), |
| }, |
| type = ArrayOfVectorOfEventInUnionWithReducedRightsStruct, |
| bytes = { |
| v2 = [ |
| num(1):8, |
| num(24):4, num(1):2, num(0):2, |
| |
| num(1):8, |
| repeat(0xff):8, |
| |
| repeat(0xff):4, padding:4, |
| ], |
| }, |
| handles = { |
| v2 = [ |
| #0, |
| ], |
| }, |
| err = INCORRECT_HANDLE_TYPE, |
| } |
