src/tests/fidl/conformance_suite/primitives.gidl

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

success("BoolTrue") {
    value = MyBool {
        value: true,
    },
    bytes = {
        v1 = [
            0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("BoolFalse") {
    value = MyBool {
        value: false,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("ByteZero") {
    value = MyByte {
        value: 0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Byte255") {
    value = MyByte {
        value: 255,
    },
    bytes = {
        v1 = [
            0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int8Min") {
    value = MyInt8 {
        value: -128,
    },
    bytes = {
        v1 = [
            0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int8Zero") {
    value = MyInt8 {
        value: 0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int8Max") {
    value = MyInt8 {
        value: 127,
    },
    bytes = {
        v1 = [
            0x7f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int16Min") {
    value = MyInt16 {
        value: -32768,
    },
    bytes = {
        v1 = [
            0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int16Zero") {
    value = MyInt16 {
        value: 0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int16Max") {
    value = MyInt16 {
        value: 32767,
    },
    bytes = {
        v1 = [
            0xff,0x7f,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int32Min") {
    value = MyInt32 {
        value: -2147483648,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int32Zero") {
    value = MyInt32 {
        value: 0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int32Max") {
    value = MyInt32 {
        value: 2147483647,
    },
    bytes = {
        v1 = [
            0xff,0xff,0xff,0x7f,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int64Min") {
    value = MyInt64 {
        value: -9223372036854775808,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
        ],
    },
}

success("Int64Zero") {
    value = MyInt64 {
        value: 0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Int64Max") {
    value = MyInt64 {
        value: 9223372036854775807,
    },
    bytes = {
        v1 = [
            0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
        ],
    },
}

success("Uint8Zero") {
    value = MyUint8 {
        value: 0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Uint8Max") {
    value = MyUint8 {
        value: 255,
    },
    bytes = {
        v1 = [
            0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Uint16Zero") {
    value = MyUint16 {
        value: 0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Uint16Max") {
    value = MyUint16 {
        value: 65535,
    },
    bytes = {
        v1 = [
            0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Uint32Zero") {
    value = MyUint32 {
        value: 0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Uint32Max") {
    value = MyUint32 {
        value: 4294967295,
    },
    bytes = {
        v1 = [
            0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Uint64Zero") {
    value = MyUint64 {
        value: 0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Uint64Max") {
    value = MyUint64 {
        value: 18446744073709551615,
    },
    bytes = {
        v1 = [
            0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
        ],
    },
}

// Note: floats are tricky and there may be failures do to cpu architecture
// and similar reasons.

success("Float32PositiveZero") {
    value = MyFloat32 {
        value: 0.0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32NegativeZero") {
    value = MyFloat32 {
        value: raw_float(0b1_00000000_00000000000000000000000),
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32PositiveOne") {
    value = MyFloat32 {
        value: 1.0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x80,0x3f,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32NegativeOne") {
    value = MyFloat32 {
        value: -1.0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x80,0xbf,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32Min") {
    value = MyFloat32 {
        value: -3.40282346638528859811704183484516925440e+38,
    },
    bytes = {
        v1 = [
            0xff,0xff,0x7f,0xff,0x00,0x00,0x00,0x00,
        ],
    },
}
success("Float32Max") {
    value = MyFloat32 {
        value: 3.40282346638528859811704183484516925440e+38,
    },
    bytes = {
        v1 = [
            0xff,0xff,0x7f,0x7f,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32SmallestNormalizedPositive") {
    value = MyFloat32 {
        value: 1.1754943508222875e-38,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32SmallestNormalizedNegative") {
    value = MyFloat32 {
        value: -1.1754943508222875e-38,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x80,0x80,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32LargestDenormalizedPositive") {
    value = MyFloat32 {
        value: 1.1754942106924411e-38,
    },
    bytes = {
        v1 = [
            0xff,0xff,0x7f,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32LargestDenormalizedNegative") {
    value = MyFloat32 {
        value: -1.1754942106924411e-38,
    },
    bytes = {
        v1 = [
            0xff,0xff,0x7f,0x80,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32SmallestDenormalizedPositive") {
    value = MyFloat32 {
        value: 1.401298464324817e-45,
    },
    bytes = {
        v1 = [
            0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32SmallestDenormalizedNegative") {
    value = MyFloat32 {
        value: -1.401298464324817e-45,
    },
    bytes = {
        v1 = [
            0x01,0x00,0x00,0x80,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32PositiveInfinity") {
    value = MyFloat32 {
        value: raw_float(0b0_11111111_00000000000000000000000),
    },
    bytes = {
        v1 = [
            0x00,0x00,0x80,0x7f,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float32NegativeInfinity") {
    value = MyFloat32 {
        value: raw_float(0b1_11111111_00000000000000000000000),
    },
    bytes = {
        v1 = [
            0x00,0x00,0x80,0xff,0x00,0x00,0x00,0x00,
        ],
    },
}

// No decode_success because NaN != NaN.
encode_success("Float32QuietNaN") {
    value = MyFloat32 {
        value: raw_float(0b0_11111111_10000000000000000000000),
    },
    bytes = {
        v1 = [
            0x00,0x00,0xc0,0x7f,0x00,0x00,0x00,0x00,
        ],
    },
}

// No decode_success because NaN != NaN.
encode_success("Float32SignallingNaN") {
    bindings_denylist = [dart],
    value = MyFloat32 {
        value: raw_float(0b0_11111111_01000000000000000000000),
    },
    bytes = {
        v1 = [
            0x00,0x00,0xa0,0x7f,0x00,0x00,0x00,0x00,
        ],
    },
}

// No decode_success because NaN != NaN.
encode_success("Float32SignallingNaNCovertedToQuiet") {
    // Dart only has double-precision floats. For FIDL float32, the bindings
    // encode using ByteData.setFloat32 (takes a double) and decode using
    // BytePart.getFloat32 (returns a double). For NaNs, these functions
    // truncate/zero-extend the mantissa AND SET ITS MOST SIGNIFICANT BIT (the
    // quiet bit). This effectively means that float32 signalling NaNs do not
    // exist in Dart; they always get converted to quiet NaNs on encode/decode.
    bindings_allowlist = [dart],
    value = MyFloat32 {
        value: raw_float(0b0_11111111_01000000000000000000000),
    },
    bytes = {
        v1 = [
            // 0xe0 instead of 0xa0: quiet bit set
            0x00,0x00,0xe0,0x7f,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float64PositiveZero") {
    value = MyFloat64 {
        value: 0.0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float64NegativeZero") {
    value = MyFloat64 {
        value: raw_float(0b1_00000000000_0000000000000000000000000000000000000000000000000000),
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
        ],
    },
}

success("Float64PositiveOne") {
    value = MyFloat64 {
        value: 1.0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f,
        ],
    },
}

success("Float64NegativeOne") {
    value = MyFloat64 {
        value: -1.0,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0xbf,
        ],
    },
}

success("Float64Min") {
    value = MyFloat64 {
        value: -1.797693134862315708145274237317043567981e+308,
    },
    bytes = {
        v1 = [
            0xff,0xff,0xff,0xff,0xff,0xff,0xef,0xff,
        ],
    },
}

success("Float64Max") {
    value = MyFloat64 {
        value: 1.797693134862315708145274237317043567981e+308,
    },
    bytes = {
        v1 = [
            0xff,0xff,0xff,0xff,0xff,0xff,0xef,0x7f,
        ],
    },
}

success("Float64SmallestNormalizedPositive") {
    value = MyFloat64 {
        value: 2.2250738585072014e-308,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,
        ],
    },
}

success("Float64SmallestNormalizedNegative") {
    value = MyFloat64 {
        value: -2.2250738585072014e-308,
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x80,
        ],
    },
}

success("Float64LargestDenormalizedPositive") {
    value = MyFloat64 {
        value: 2.225073858507201e-308,
    },
    bytes = {
        v1 = [
            0xff,0xff,0xff,0xff,0xff,0xff,0x0f,0x00,
        ],
    },
}

success("Float64LargestDenormalizedNegative") {
    value = MyFloat64 {
        value: -2.225073858507201e-308,
    },
    bytes = {
        v1 = [
            0xff,0xff,0xff,0xff,0xff,0xff,0x0f,0x80,
        ],
    },
}

success("Float64SmallestDenormalizedPositive") {
    value = MyFloat64 {
        value: 5.0e-324
    },
    bytes = {
        v1 = [
            0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        ],
    },
}

success("Float64SmallestDenormalizedNegative") {
    value = MyFloat64 {
        value: -5.0e-324
    },
    bytes = {
        v1 = [
            0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
        ],
    },
}

success("Float64PositiveInfinity") {
    value = MyFloat64 {
        value: raw_float(0b0_11111111111_0000000000000000000000000000000000000000000000000000),
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x7f,
        ],
    },
}

success("Float64NegativeInfinity") {
    value = MyFloat64 {
        value: raw_float(0b1_11111111111_0000000000000000000000000000000000000000000000000000),
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0xff,
        ],
    },
}

// No decode_success because NaN != NaN.
encode_success("Float64QuietNaN") {
    value = MyFloat64 {
        value: raw_float(0b0_11111111111_1000000000000000000000000000000000000000000000000000),
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0xf8,0x7f,
        ],
    },
}

// No decode_success because NaN != NaN.
encode_success("Float64SignallingNaN") {
    value = MyFloat64 {
        value: raw_float(0b0_11111111111_0100000000000000000000000000000000000000000000000000),
    },
    bytes = {
        v1 = [
            0x00,0x00,0x00,0x00,0x00,0x00,0xf4,0x7f,
        ],
    },
}