src/tests/fidl/conformance_suite/float.gidl

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

success("Float32NegativeInfinity") {
    value = MyFloat32{
        value: raw_float(0b1_11111111_00000000000000000000000),
    },
    bytes = {
        v2 = [
            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 = {
        v2 = [
            0x00, 0x00, 0xc0, 0x7f, 0x00, 0x00, 0x00, 0x00,
        ],
    },
}

// No decode_success because NaN != NaN.
encode_success("Float32SignallingNaN") {
    // Dart and Python only represent 64 bit floats (no 32 bit floats).
    // When converting a 32 bit NaN to a 64 bit NaN and back, there is a small
    // section of data that isn't correctly converted. There are two kinds of
    // NaN values: quiet and signalling (hence the quiet/signalling tests).
    //
    // When in Dart/Python, converting from a 32-bit float to a 64-bit float
    // default sets the value from signalling to a default quiet value.
    //
    // See the following Python example:
    //
    // >>> import struct
    // >>> f = struct.unpack('>f', b'\x7f\xa0\x00\x00')[0]) # Signalling float.
    // >>> struct.pack('>f', f)
    // b'\x7f\xe0\x00\x00'  # Quiet float.
    bindings_denylist = [dart, fuchsia_controller],
    value = MyFloat32{
        value: raw_float(0b0_11111111_01000000000000000000000),
    },
    bytes = {
        v2 = [
            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 = {
        v2 = [
            // 0xe0 instead of 0xa0: quiet bit set
            0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00,
        ],
    },
}

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

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

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

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

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

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

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

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

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

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

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

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

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

success("Float64NegativeInfinity") {
    value = MyFloat64{
        value: raw_float(0b1_11111111111_0000000000000000000000000000000000000000000000000000),
    },
    bytes = {
        v2 = [
            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 = {
        v2 = [
            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 = {
        v2 = [
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x7f,
        ],
    },
}