src/tests/fidl/conformance_suite/enums_strict.gidl

// 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("StrictEnumInt8Struct") {
    value = StrictEnumInt8Struct {
        e: 0x01,
    },
    bytes = {
        v1 = [
            0x01, padding:7,
        ],
    },
}

success("StrictEnumInt16Struct") {
    value = StrictEnumInt16Struct {
        e: 0x0102,
    },
    bytes = {
        v1 = [
            0x02, 0x01, padding:6,
        ],
    },
}

success("StrictEnumInt32Struct") {
    value = StrictEnumInt32Struct {
        e: 0x01020304,
    },
    bytes = {
        v1 = [
            0x04, 0x03, 0x02, 0x01, padding:4,
        ],
    },
}

success("StrictEnumInt64Struct") {
    value = StrictEnumInt64Struct {
        e: 0x0102030405060708,
    },
    bytes = {
        v1 = [
            0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
        ],
    },
}

success("StrictEnumUint8Struct") {
    value = StrictEnumUint8Struct {
        e: 0x01,
    },
    bytes = {
        v1 = [
            0x01, padding:7,
        ],
    },
}

success("StrictEnumUint16Struct") {
    value = StrictEnumUint16Struct {
        e: 0x0102,
    },
    bytes = {
        v1 = [
            0x02, 0x01, padding:6,
        ],
    },
}

success("StrictEnumUint32Struct") {
    value = StrictEnumUint32Struct {
        e: 0x01020304,
    },
    bytes = {
        v1 = [
            0x04, 0x03, 0x02, 0x01, padding:4,
        ],
    },
}

success("StrictEnumUint64Struct") {
    value = StrictEnumUint64Struct {
        e: 0x0102030405060708,
    },
    bytes = {
        v1 = [
            0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
        ],
    },
}

encode_failure("StrictEnumInt8StructUnknownValue") {
    // Rust: cannot construct invalid enum.
    bindings_denylist = [rust],
    value = StrictEnumInt8Struct {
        e: 0x08, // invalid value
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

encode_failure("StrictEnumInt16StructUnknownValue") {
    // Rust: cannot construct invalid enum.
    bindings_denylist = [rust],
    value = StrictEnumInt16Struct {
        e: 0x08, // invalid value
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

encode_failure("StrictEnumInt32StructUnknownValue") {
    // Rust: cannot construct invalid enum.
    bindings_denylist = [rust],
    value = StrictEnumInt32Struct {
        e: 0x08, // invalid value
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

encode_failure("StrictEnumInt64StructUnknownValue") {
    // Rust: cannot construct invalid enum.
    bindings_denylist = [rust],
    value = StrictEnumInt64Struct {
        e: 0x08, // invalid value
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

encode_failure("StrictEnumUint8StructUnknownValue") {
    // Rust: cannot construct invalid enum.
    bindings_denylist = [rust],
    value = StrictEnumUint8Struct {
        e: 0x08, // invalid value
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

encode_failure("StrictEnumUint16StructUnknownValue") {
    // Rust: cannot construct invalid enum.
    bindings_denylist = [rust],
    value = StrictEnumUint16Struct {
        e: 0x08, // invalid value
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

encode_failure("StrictEnumUint32StructUnknownValue") {
    // Rust: cannot construct invalid enum.
    bindings_denylist = [rust],
    value = StrictEnumUint32Struct {
        e: 0x08, // invalid value
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

encode_failure("StrictEnumUint64StructUnknownValue") {
    // Rust: cannot construct invalid enum.
    bindings_denylist = [rust],
    value = StrictEnumUint64Struct {
        e: 0x08, // invalid value
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

decode_failure("StrictEnumInt8StructUnknownValue") {
    type = StrictEnumInt8Struct,
    bytes = {
        v1 = [
            0xaa, padding:7,
        ],
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

decode_failure("StrictEnumInt16StructUnknownValue") {
    type = StrictEnumInt16Struct,
    bytes = {
        v1 = [
            0xaa, 0xaa, padding:6,
        ],
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

decode_failure("StrictEnumInt32StructUnknownValue") {
    type = StrictEnumInt32Struct,
    bytes = {
        v1 = [
            0xaa, 0xaa, 0xaa, 0xaa, padding:4,
        ],
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

decode_failure("StrictEnumInt64StructUnknownValue") {
    type = StrictEnumInt64Struct,
    bytes = {
        v1 = [
            0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
        ],
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

decode_failure("StrictEnumUint8StructUnknownValue") {
    type = StrictEnumUint8Struct,
    bytes = {
        v1 = [
            0xaa, padding:7,
        ],
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

decode_failure("StrictEnumUint16StructUnknownValue") {
    type = StrictEnumUint16Struct,
    bytes = {
        v1 = [
            0xaa, 0xaa, padding:6,
        ],
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

decode_failure("StrictEnumUint32StructUnknownValue") {
    type = StrictEnumUint32Struct,
    bytes = {
        v1 = [
            0xaa, 0xaa, 0xaa, 0xaa, padding:4,
        ],
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}

decode_failure("StrictEnumUint64StructUnknownValue") {
    type = StrictEnumUint64Struct,
    bytes = {
        v1 = [
            0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
        ],
    },
    err = STRICT_ENUM_UNKNOWN_VALUE,
}