// 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.

// DO NOT EDIT; Cases below are generated with:
//
//     go run src/tests/fidl/conformance_suite/gen_strings.go > src/tests/fidl/conformance_suite/strings_utf8.gen.gidl
//

// single byte, min: 0
success("StringsValidCase1") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\x00",
    },
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            0,
            padding:7,
        ],
    },
}

// single byte, max: 127
success("StringsValidCase2") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\x7f",
    },
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            127,
            padding:7,
        ],
    },
}

// two bytes,   min: 128
success("StringsValidCase3") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xc2\x80",
    },
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            194,
            128,
            padding:6,
        ],
    },
}

// two bytes,   max: 2047
success("StringsValidCase4") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xdf\xbf",
    },
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            223,
            191,
            padding:6,
        ],
    },
}

// three bytes, min: 2048
success("StringsValidCase5") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xe1\x80\x80",
    },
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            225,
            128,
            128,
            padding:5,
        ],
    },
}

// three bytes, max: 65535
success("StringsValidCase6") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xef\xbf\xbf",
    },
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            239,
            191,
            191,
            padding:5,
        ],
    },
}

// four bytes,  min: 65536
success("StringsValidCase7") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xf0\x90\x80\x80",
    },
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            144,
            128,
            128,
            padding:4,
        ],
    },
}

// four bytes,  max: 1114111
success("StringsValidCase8") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xf4\x8f\xbf\xbf",
    },
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            244,
            143,
            191,
            191,
            padding:4,
        ],
    },
}

// 1 above max single byte
encode_failure("StringsInvalidCase1") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\x80",
    },
    err = STRING_NOT_UTF8,
}

// 1 above max single byte
decode_failure("StringsInvalidCase1") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            128,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}

// 1 below min two bytes
encode_failure("StringsInvalidCase2") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xc2\x7f",
    },
    err = STRING_NOT_UTF8,
}

// 1 below min two bytes
decode_failure("StringsInvalidCase2") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            194,
            127,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}

// 1 above max two bytes
encode_failure("StringsInvalidCase3") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xdf\xc0",
    },
    err = STRING_NOT_UTF8,
}

// 1 above max two bytes
decode_failure("StringsInvalidCase3") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            223,
            192,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}

// 1 below min three bytes
encode_failure("StringsInvalidCase4") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xe1\x80\x7f",
    },
    err = STRING_NOT_UTF8,
}

// 1 below min three bytes
decode_failure("StringsInvalidCase4") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            225,
            128,
            127,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// 1 above max three bytes
encode_failure("StringsInvalidCase5") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xef\xbf\xc0",
    },
    err = STRING_NOT_UTF8,
}

// 1 above max three bytes
decode_failure("StringsInvalidCase5") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            239,
            191,
            192,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// 1 below min four bytes
encode_failure("StringsInvalidCase6") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf0\x80\x80\x80",
    },
    err = STRING_NOT_UTF8,
}

// 1 below min four bytes
decode_failure("StringsInvalidCase6") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            128,
            128,
            128,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}

// 1 above max four bytes
encode_failure("StringsInvalidCase7") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf7\xbf\xbf\xc0",
    },
    err = STRING_NOT_UTF8,
}

// 1 above max four bytes
decode_failure("StringsInvalidCase7") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            247,
            191,
            191,
            192,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}


success("StringsValidCase9") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xc2\x80",
    },
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            194,
            128,
            padding:6,
        ],
    },
}

// first byte following two byte value not starting with 0b10
encode_failure("StringsInvalidCase8") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xc2\x7f",
    },
    err = STRING_NOT_UTF8,
}

// first byte following two byte value not starting with 0b10
decode_failure("StringsInvalidCase8") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            194,
            127,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}

// first byte following three byte value not starting with 0b10
encode_failure("StringsInvalidCase9") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xe1\x7f\x80",
    },
    err = STRING_NOT_UTF8,
}

// first byte following three byte value not starting with 0b10
decode_failure("StringsInvalidCase9") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            225,
            127,
            128,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// second byte following three byte value not starting with 0b10
encode_failure("StringsInvalidCase10") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xe1\x80\x7f",
    },
    err = STRING_NOT_UTF8,
}

// second byte following three byte value not starting with 0b10
decode_failure("StringsInvalidCase10") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            225,
            128,
            127,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}


success("StringsValidCase10") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xf0\x90\x80\x80",
    },
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            144,
            128,
            128,
            padding:4,
        ],
    },
}

// first byte following four byte value not starting with 0b10
encode_failure("StringsInvalidCase11") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf0\x7f\x80\x80",
    },
    err = STRING_NOT_UTF8,
}

// first byte following four byte value not starting with 0b10
decode_failure("StringsInvalidCase11") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            127,
            128,
            128,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}

// second byte following four byte value not starting with 0b10
encode_failure("StringsInvalidCase12") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf0\x90\x7f\x80",
    },
    err = STRING_NOT_UTF8,
}

// second byte following four byte value not starting with 0b10
decode_failure("StringsInvalidCase12") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            144,
            127,
            128,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}

// third byte following four byte value not starting with 0b10
encode_failure("StringsInvalidCase13") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf0\x90\x80\x7f",
    },
    err = STRING_NOT_UTF8,
}

// third byte following four byte value not starting with 0b10
decode_failure("StringsInvalidCase13") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            144,
            128,
            127,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}

// ascii slash
success("StringsValidCase11") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\x2f",
    },
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            47,
            padding:7,
        ],
    },
}

// slash (2)
encode_failure("StringsInvalidCase14") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xc0\xaf",
    },
    err = STRING_NOT_UTF8,
}

// slash (2)
decode_failure("StringsInvalidCase14") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            192,
            175,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}

// slash (3)
encode_failure("StringsInvalidCase15") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xe0\x80\xaf",
    },
    err = STRING_NOT_UTF8,
}

// slash (3)
decode_failure("StringsInvalidCase15") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            224,
            128,
            175,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// slash (4)
encode_failure("StringsInvalidCase16") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf0\x80\x80\xaf",
    },
    err = STRING_NOT_UTF8,
}

// slash (4)
decode_failure("StringsInvalidCase16") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            128,
            128,
            175,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+061D
success("StringsValidCase12") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xd8\x9d",
    },
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            216,
            157,
            padding:6,
        ],
    },
}

// U+05F6
success("StringsValidCase13") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xd7\xb6",
    },
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            215,
            182,
            padding:6,
        ],
    },
}

// U+0AF4
success("StringsValidCase14") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xe0\xab\xb4",
    },
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            224,
            171,
            180,
            padding:5,
        ],
    },
}

// U+0C52
success("StringsValidCase15") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xe0\xb1\x92",
    },
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            224,
            177,
            146,
            padding:5,
        ],
    },
}

// U+1E454
success("StringsValidCase16") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xf0\x9e\x91\x94",
    },
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            158,
            145,
            148,
            padding:4,
        ],
    },
}

// U+1F978
success("StringsValidCase17") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xf0\x9f\xa5\xb8",
    },
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            159,
            165,
            184,
            padding:4,
        ],
    },
}

// empty string
success("StringsValidCase18") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "",
    },
    bytes = {
        v1 = [
            // length, present
            num(0):8,
            repeat(0xff):8,

            // content
        ],
    },
}

// simply the letter a
success("StringsValidCase19") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\x61",
    },
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            97,
            padding:7,
        ],
    },
}

// euro sign, i.e \xe2\x82\xac
success("StringsValidCase20") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xe2\x82\xac",
    },
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            226,
            130,
            172,
            padding:5,
        ],
    },
}

// mix and match from earlier cases
success("StringsValidCase21") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\x00\xf4\x8f\xbf\xbf\x7f\xf0\x90\x80\x80\xc2\x80",
    },
    bytes = {
        v1 = [
            // length, present
            num(12):8,
            repeat(0xff):8,

            // content
            0,
            244,
            143,
            191,
            191,
            127,
            240,
            144,
            128,
            128,
            194,
            128,
            padding:4,
        ],
    },
}

// mix and match from earlier cases
success("StringsValidCase22") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xdf\xbf\xef\xbf\xbf\xe1\x80\x80",
    },
    bytes = {
        v1 = [
            // length, present
            num(8):8,
            repeat(0xff):8,

            // content
            223,
            191,
            239,
            191,
            191,
            225,
            128,
            128,
        ],
    },
}

// UTF-8 BOM
success("StringsValidCase23") {
    bindings_allowlist = [go,rust,],
    value = StringWrapper {
        str: "\xef\xbb\xbf",
    },
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            239,
            187,
            191,
            padding:5,
        ],
    },
}

// Partial UTF-8 BOM (1)
encode_failure("StringsInvalidCase17") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xef",
    },
    err = STRING_NOT_UTF8,
}

// Partial UTF-8 BOM (1)
decode_failure("StringsInvalidCase17") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            239,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}

// Partial UTF-8 BOM (2)
encode_failure("StringsInvalidCase18") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xef\xbb",
    },
    err = STRING_NOT_UTF8,
}

// Partial UTF-8 BOM (2)
decode_failure("StringsInvalidCase18") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            239,
            187,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}

// invalid partial sequence
encode_failure("StringsInvalidCase19") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xdf\x80\x80",
    },
    err = STRING_NOT_UTF8,
}

// invalid partial sequence
decode_failure("StringsInvalidCase19") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            223,
            128,
            128,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// long U+0000, non shortest form
encode_failure("StringsInvalidCase20") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xe0\x80\x80",
    },
    err = STRING_NOT_UTF8,
}

// long U+0000, non shortest form
decode_failure("StringsInvalidCase20") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            224,
            128,
            128,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}


success("StringsValidCase24") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xe1\x80\x80",
    },
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            225,
            128,
            128,
            padding:5,
        ],
    },
}

// invalid 2 octet sequence
encode_failure("StringsInvalidCase21") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xc3\x28",
    },
    err = STRING_NOT_UTF8,
}

// invalid 2 octet sequence
decode_failure("StringsInvalidCase21") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            195,
            40,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}


success("StringsValidCase25") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\x0d",
    },
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            13,
            padding:7,
        ],
    },
}


success("StringsValidCase26") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\x0a",
    },
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            10,
            padding:7,
        ],
    },
}


success("StringsValidCase27") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\x61",
    },
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            97,
            padding:7,
        ],
    },
}


success("StringsValidCase28") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xc2\x81",
    },
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            194,
            129,
            padding:6,
        ],
    },
}


success("StringsValidCase29") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xe1\x80\xbf",
    },
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            225,
            128,
            191,
            padding:5,
        ],
    },
}


success("StringsValidCase30") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,dart,],
    value = StringWrapper {
        str: "\xf1\x80\xa0\xbf",
    },
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            241,
            128,
            160,
            191,
            padding:4,
        ],
    },
}

// UTF-8 BOM
success("StringsValidCase31") {
    bindings_allowlist = [go,rust,],
    value = StringWrapper {
        str: "\xef\xbb\xbf",
    },
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            239,
            187,
            191,
            padding:5,
        ],
    },
}


encode_failure("StringsInvalidCase22") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xc0",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase22") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            192,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase23") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xc1",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase23") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            193,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase24") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf5",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase24") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            245,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase25") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf6",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase25") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            246,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase26") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf7",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase26") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            247,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase27") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf8",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase27") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            248,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase28") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf9",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase28") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            249,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase29") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xfa",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase29") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            250,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase30") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xfb",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase30") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            251,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase31") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xfc",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase31") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            252,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase32") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xfd",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase32") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            253,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase33") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xfe",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase33") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            254,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase34") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xff",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase34") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(1):8,
            repeat(0xff):8,

            // content
            255,
            padding:7,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+D800, high surrogate, first
encode_failure("StringsInvalidCase35") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xed\xa0\x80",
    },
    err = STRING_NOT_UTF8,
}

// U+D800, high surrogate, first
decode_failure("StringsInvalidCase35") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            237,
            160,
            128,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// low surrogate, first
encode_failure("StringsInvalidCase36") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xed\xb0\x80",
    },
    err = STRING_NOT_UTF8,
}

// low surrogate, first
decode_failure("StringsInvalidCase36") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            237,
            176,
            128,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// low surrogate, last
encode_failure("StringsInvalidCase37") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xed\xbf\xbf",
    },
    err = STRING_NOT_UTF8,
}

// low surrogate, last
decode_failure("StringsInvalidCase37") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            237,
            191,
            191,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+0000
encode_failure("StringsInvalidCase38") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xc0\x80",
    },
    err = STRING_NOT_UTF8,
}

// U+0000
decode_failure("StringsInvalidCase38") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            192,
            128,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}

// "A"
encode_failure("StringsInvalidCase39") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xc1\x80",
    },
    err = STRING_NOT_UTF8,
}

// "A"
decode_failure("StringsInvalidCase39") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            193,
            128,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}

// "B"
encode_failure("StringsInvalidCase40") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xc1\x81",
    },
    err = STRING_NOT_UTF8,
}

// "B"
decode_failure("StringsInvalidCase40") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            193,
            129,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+0000
encode_failure("StringsInvalidCase41") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xe0\x80\x80",
    },
    err = STRING_NOT_UTF8,
}

// U+0000
decode_failure("StringsInvalidCase41") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            224,
            128,
            128,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+0080
encode_failure("StringsInvalidCase42") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xe0\x82\x80",
    },
    err = STRING_NOT_UTF8,
}

// U+0080
decode_failure("StringsInvalidCase42") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            224,
            130,
            128,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+07ff
encode_failure("StringsInvalidCase43") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xe0\x9f\xbf",
    },
    err = STRING_NOT_UTF8,
}

// U+07ff
decode_failure("StringsInvalidCase43") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(3):8,
            repeat(0xff):8,

            // content
            224,
            159,
            191,
            padding:5,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+000D
encode_failure("StringsInvalidCase44") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf0\x80\x80\x8d",
    },
    err = STRING_NOT_UTF8,
}

// U+000D
decode_failure("StringsInvalidCase44") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            128,
            128,
            141,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+0091
encode_failure("StringsInvalidCase45") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf0\x80\x82\x91",
    },
    err = STRING_NOT_UTF8,
}

// U+0091
decode_failure("StringsInvalidCase45") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            128,
            130,
            145,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+0800
encode_failure("StringsInvalidCase46") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf0\x80\xa0\x80",
    },
    err = STRING_NOT_UTF8,
}

// U+0800
decode_failure("StringsInvalidCase46") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            128,
            160,
            128,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+FEFF (BOM)
encode_failure("StringsInvalidCase47") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf0\x8f\xbb\xbf",
    },
    err = STRING_NOT_UTF8,
}

// U+FEFF (BOM)
decode_failure("StringsInvalidCase47") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            240,
            143,
            187,
            191,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+003F
encode_failure("StringsInvalidCase48") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf8\x80\x80\x80\xbf",
    },
    err = STRING_NOT_UTF8,
}

// U+003F
decode_failure("StringsInvalidCase48") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(5):8,
            repeat(0xff):8,

            // content
            248,
            128,
            128,
            128,
            191,
            padding:3,
        ],
    },
    err = STRING_NOT_UTF8,
}


encode_failure("StringsInvalidCase49") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xfc\x80\x80\x80\xa0\xa5",
    },
    err = STRING_NOT_UTF8,
}


decode_failure("StringsInvalidCase49") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(6):8,
            repeat(0xff):8,

            // content
            252,
            128,
            128,
            128,
            160,
            165,
            padding:2,
        ],
    },
    err = STRING_NOT_UTF8,
}

// U+110000
encode_failure("StringsInvalidCase50") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf4\x90\x80\x80",
    },
    err = STRING_NOT_UTF8,
}

// U+110000
decode_failure("StringsInvalidCase50") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(4):8,
            repeat(0xff):8,

            // content
            244,
            144,
            128,
            128,
            padding:4,
        ],
    },
    err = STRING_NOT_UTF8,
}

// 5 bytes
encode_failure("StringsInvalidCase51") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xf8\xa0\xbf\x80\xbf",
    },
    err = STRING_NOT_UTF8,
}

// 5 bytes
decode_failure("StringsInvalidCase51") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(5):8,
            repeat(0xff):8,

            // content
            248,
            160,
            191,
            128,
            191,
            padding:3,
        ],
    },
    err = STRING_NOT_UTF8,
}

// 6 bytes
encode_failure("StringsInvalidCase52") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xfc\x9c\xbf\x80\xbf\x80",
    },
    err = STRING_NOT_UTF8,
}

// 6 bytes
decode_failure("StringsInvalidCase52") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(6):8,
            repeat(0xff):8,

            // content
            252,
            156,
            191,
            128,
            191,
            128,
            padding:2,
        ],
    },
    err = STRING_NOT_UTF8,
}

// BOMs in UTF-16 BE
encode_failure("StringsInvalidCase53") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xfe\xff",
    },
    err = STRING_NOT_UTF8,
}

// BOMs in UTF-16 BE
decode_failure("StringsInvalidCase53") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            254,
            255,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}

// BOMs in UTF-16 LE
encode_failure("StringsInvalidCase54") {
    bindings_allowlist = [go,hlcpp,llcpp,],
    value = StringWrapper {
        str: "\xff\xfe",
    },
    err = STRING_NOT_UTF8,
}

// BOMs in UTF-16 LE
decode_failure("StringsInvalidCase54") {
    bindings_allowlist = [go,rust,hlcpp,llcpp,],
    type = StringWrapper,
    bytes = {
        v1 = [
            // length, present
            num(2):8,
            repeat(0xff):8,

            // content
            255,
            254,
            padding:6,
        ],
    },
    err = STRING_NOT_UTF8,
}