#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/float.h"
#include "math.h"

#if 0
#define printf(...) ((void)0)
#endif
#if 0
#define stop() return -1
#else
#define stop() rc=1
#endif
#define test_assert(x) ({ if (!(x)) { printf("Assertion failed: ");puts(#x);printf("  at " __FILE__ ":%d\n", __LINE__); stop(); } })
#define test_checkf(x, expected, msg) ({ if ((x) != (expected)) { printf("  %s: %f != %f\n", msg, x, expected); stop(); } })
#define test_checki(x, expected, msg) ({ if ((x) != (expected)) { printf("  %s: %d != %d\n", msg, x, expected); stop(); } })
#define test_checku(x, expected, msg) ({ if ((uint32_t)(x) != (uint32_t)(expected)) { printf("  %s: %u != %u\n", msg, x, expected); stop(); } })
#define test_checki64(x, expected, msg) ({ if ((x) != (expected)) { printf("  %s: %lld != %lld\n", msg, (int64_t)(x), (int64_t)(expected)); stop(); } })
#define test_checku64(x, expected, msg) ({ if ((uint64_t)(x) != (uint64_t)(expected)) { printf("  %s: %llu != %llu\n", msg, (uint64_t)(x), (uint64_t)(expected)); stop(); } })

// we only want these when we provided macros
#if !(LIB_PICO_FLOAT_COMPILER || defined(__riscv))
static inline float fix2float_8(int32_t m) { return fix2float(m, 8); }
static inline float fix2float_16(int32_t m) { return fix2float(m, 16); }
static inline float fix2float_24(int32_t m) { return fix2float(m, 24); }

static inline float ufix2float_8(uint32_t m) { return ufix2float(m, 8); }
static inline float ufix2float_16(uint32_t m) { return ufix2float(m, 16); }
static inline float ufix2float_24(uint32_t m) { return ufix2float(m, 24); }

static inline int32_t float2fix_12(float f) { return float2fix(f, 12); }
static inline uint32_t float2ufix_12(float f) { return float2ufix(f, 12); }
#endif

#if LIB_PICO_FLOAT_COMPILER || defined(__riscv)
#if __SOFTFP__ || defined(__riscv)
#define FREG "+r"
#else
#define FREG "+t"
#endif
// prevent the compiler from eliding the calculations
#define float2int_z(f) ({ float _f = f; pico_default_asm_volatile("" : FREG (_f)); float2 ## int_z(_f); })
#define float2uint_z(f) ({ float _f = f; pico_default_asm_volatile("" : FREG (_f)); float2 ## uint_z(_f); })
#define float2int64_z(f) ({ float _f = f; pico_default_asm_volatile("" : FREG (_f)); float2 ## int64_z(_f); })
#define float2uint64_z(f) ({ float _f = f; pico_default_asm_volatile("" : FREG (_f)); float2 ## uint64_z(_f); })
#define int2float(i) ({ int32_t _i = i; pico_default_asm_volatile("" : "+r" (_i)); int2 ## float(_i); })
#define uint2float(u) ({ uint32_t _u = u; pico_default_asm_volatile("" : "+r" (_u)); uint2 ## float(_u); })
#define int642float(i) ({ int64_t _i = i; pico_default_asm_volatile("" : "+r" (_i)); int642 ## float(_i); })
#define uint642float(u) ({ uint64_t _u = u; pico_default_asm_volatile("" : "+r" (_u)); uint642 ## float(_u); })
#endif

float make_positive_denormal_float(void) {
    union {
        float f;
        uint32_t u;
    } x;
    x.u = 0x00000001u;
    return x.f;
}

float make_negative_denormal_float(void) {
    union {
        float f;
        uint32_t u;
    } x;
    x.u = 0x80000001u;
    return x.f;
}

#if LIB_PICO_FLOAT_PICO_VFP
float __attribute__((naked)) call_int2float(int32_t i) {
    pico_default_asm_volatile("b int2float");
}

float __attribute__((naked)) call_uint2float(uint32_t u) {
    pico_default_asm_volatile("b uint2float");
}

int32_t __attribute__((naked)) call_float2int_z(float f) {
    pico_default_asm_volatile("b float2int_z");
}

uint32_t __attribute__((naked)) call_float2uint_z(float f) {
    pico_default_asm_volatile("b float2uint_z");
}

float __attribute__((naked)) call_fix2float(int32_t i, uint32_t n) {
    pico_default_asm_volatile("b fix2float");
}

float __attribute__((naked)) call_ufix2float(uint32_t u, uint32_t n) {
    pico_default_asm_volatile("b ufix2float");
}

int32_t __attribute__((naked)) call_float2fix(float f, uint32_t n) {
    pico_default_asm_volatile("b float2fix");
}

uint32_t __attribute__((naked)) call_float2ufix(float f, uint32_t n) {
    pico_default_asm_volatile("b float2ufix");
}

int32_t __attribute__((naked)) call_float2fix_z(float f, uint32_t n) {
    pico_default_asm_volatile("b float2fix_z");
}

uint32_t __attribute__((naked)) call_float2ufix_z(float f, uint32_t n) {
    pico_default_asm_volatile("b float2ufix_z");
}
#endif

int test() {
    int rc = 0;
    printf("=== custom_float_funcs_test ");
#if PICO_C_COMPILER_IS_CLANG
    printf("(LLVM)");
#elif PICO_C_COMPILER_IS_GNU
    printf("(GCC)");
#endif
#if defined(__ARM_PCS_VFP)
    printf(" (hard)");
#endif
    printf("\n");
#if LIB_PICO_FLOAT_PICO_DCP
    printf("--- using DCP\n");
#elif LIB_PICO_FLOAT_PICO_VFP
    printf("--- using VFP\n");
#elif LIB_PICO_FLOAT_COMPILER
    printf("--- using compiler\n");
#endif

#if PICO_FLOAT_HAS_INT32_TO_FLOAT_CONVERSIONS
    printf("int2float\n");
    test_checkf(int2float(0), 0.0f, "int2float1");
    test_checkf(int2float(-1), -1.0f, "int2float2");
    test_checkf(int2float(1), 1.0f, "int2float3");
    test_checkf(int2float(INT32_MAX), 2147483647.0f, "int2float4");
    test_checkf(int2float(INT32_MIN), -2147483648.0f, "int2float5");
    // check rounding
    test_checkf(int2float(2147483391), 2147483392.0f, "int2float6");
    test_checkf(int2float(2147483456), 2147483392.0f, "int2float7");
    test_checkf(int2float(2147483457), 2147483520.0f, "int2float8");
    test_checkf(int2float(2147483483), 2147483520.0f, "int2float9");
    test_checkf(int2float(2147483584), 2147483648.0f, "int2float10");

#if LIB_PICO_FLOAT_PICO_VFP
    printf("call_int2float\n");
    test_checkf(call_int2float(0), 0.0f, "call_int2float1");
    test_checkf(call_int2float(-1), -1.0f, "call_int2float2");
    test_checkf(call_int2float(1), 1.0f, "call_int2float3");
    test_checkf(call_int2float(INT32_MAX), 2147483647.0f, "call_int2float4");
    test_checkf(call_int2float(INT32_MIN), -2147483648.0f, "call_int2float5");
    // check rounding
    test_checkf(call_int2float(2147483391), 2147483392.0f, "call_int2float6");
    test_checkf(call_int2float(2147483456), 2147483392.0f, "call_int2float7");
    test_checkf(call_int2float(2147483457), 2147483520.0f, "call_int2float8");
    test_checkf(call_int2float(2147483483), 2147483520.0f, "call_int2float9");
    test_checkf(call_int2float(2147483584), 2147483648.0f, "call_int2float10");
#endif

    printf("uint2float\n");
    test_checkf(uint2float(0), 0.0f, "uint2float1");
    test_checkf(uint2float(1), 1.0f, "uint2float2");
    test_checkf(uint2float(INT32_MAX), 2147483647.0f, "uint2float3");
    // todo test correct rounding around maximum precision
    test_checkf(uint2float(UINT32_MAX), 4294967295.0f, "uint2float4");

#if LIB_PICO_FLOAT_PICO_VFP
    printf("call_uint2float\n");
    test_checkf(call_uint2float(0), 0.0f, "call_uint2float1");
    test_checkf(call_uint2float(1), 1.0f, "call_uint2float2");
    test_checkf(call_uint2float(INT32_MAX), 2147483647.0f, "call_uint2float3");
    // todo test correct rounding around maximum precision
    test_checkf(call_uint2float(UINT32_MAX), 4294967295.0f, "call_uint2float4");
#endif
#endif

#if PICO_FLOAT_HAS_INT64_TO_FLOAT_CONVERSIONS
    printf("int642float\n");
    test_checkf(int642float(0), 0.0f, "int642float1");
    test_checkf(int642float(-1), -1.0f, "int642float2");
    test_checkf(int642float(1), 1.0f, "int642float3");
    test_checkf(int642float(INT32_MAX-1), 2147483646.0f, "int642float4"); // note equality is within 1ulp
    test_checkf(int642float(INT32_MAX), 2147483647.0f, "int642float5"); // note equality is within 1ulp
    test_checkf(int642float(INT32_MAX+1ll), 2147483648.0f, "int642float6");
    test_checkf(int642float(INT32_MIN-1ll), -2147483649.0f, "int642float7"); // note equality is within 1ulp
    test_checkf(int642float(INT32_MIN), -2147483648.0f, "int642float8");
    test_checkf(int642float(INT32_MIN+1ll), -2147483647.0f, "int642float9"); // note equality is within 1ulp
    // todo test correct rounding around maximum precision
    test_checkf(int642float(INT64_MAX), 9223372036854775807.0f, "int642float10");
    test_checkf(int642float(INT64_MIN), -9223372036854775808.0f, "int642float11");

    printf("uint642float\n");
    test_checkf(uint642float(0), 0.0f, "uint642float1");
    test_checkf(uint642float(1), 1.0f, "uint642float2");
    test_checkf(uint642float(INT32_MAX-1), 2147483646.0f, "uint642float3"); // note equality is within 1ulp
    test_checkf(uint642float(INT32_MAX), 2147483647.0f, "uint642float4"); // note equality is within 1ulp
    test_checkf(uint642float(INT32_MAX+1ll), 2147483648.0f, "uint642float5");
    test_checkf(uint642float(INT64_MAX), 9223372036854775807.0f, "uint642float6");
    // todo test correct rounding around maximum precision
    test_checkf(uint642float(UINT64_MAX), 18446744073709551615.0f, "uint642float7");
#endif

    union {
        uint32_t u;
        float f;
    } u32f;

#if PICO_FLOAT_HAS_FIX32_TO_FLOAT_CONVERSIONS
    printf("fix2float\n");
    // todo test correct rounding around maximum precision
    test_checkf(fix2float(-3, 1), -1.5f, "fix2float1");
    test_checkf(fix2float(-3, 1), -1.5f, "fix2float2");
    test_checkf(fix2float(-3, -4), -48.0f, "fix2float3");

#if LIB_PICO_FLOAT_PICO_VFP
#ifndef fix2float
#error fix2float not actually overridden
#endif
    printf("call_fix2float\n");
    // todo test correct rounding around maximum precision
    test_checkf(call_fix2float(-3, 1), -1.5f, "call_fix2float1");
    test_checkf(call_fix2float(-3, 1), -1.5f, "call_fix2float2");
    test_checkf(call_fix2float(-3, -4), -48.0f, "call_fix2float3");
#endif

    printf("ufix2float\n");
    // todo test correct rounding around maximum precision
    test_checkf(ufix2float(0xa0000000, 30), 2.5f, "ufix2float1");
    test_checkf(ufix2float(3, -4), 48.0f, "ufix2float2");

#if LIB_PICO_FLOAT_PICO_VFP
#ifndef ufix2float
#error ufix2float not actually overridden
#endif

    printf("call_ufix2float\n");
    // todo test correct rounding around maximum precision
    test_checkf(call_ufix2float(0xa0000000, 30), 2.5f, "call_ufix2float1");
    test_checkf(call_ufix2float(3, -4), 48.0f, "call_ufix2float2");
#endif

    printf("fix2float_N\n");
    test_checkf(fix2float_8(128), 0.5f, "fix2float_8_1");
    test_checkf(fix2float_8(-128), -0.5f, "fix2float_8_2");
    test_checkf(fix2float_16(8192), 0.125f, "fix2float_16_1");
    test_checkf(fix2float_16(-8192), -0.125f, "fix2float_16_2");
    test_checkf(fix2float_24(3<<23), 1.5f, "fix2float_24_1");
    test_checkf(fix2float_24(-(3<<23)), -1.5f, "fix2float_24_2");

    printf("ufix2float_N\n");
    test_checkf(ufix2float_8(128), 0.5f, "ufix2float_8_1");
    test_checkf(ufix2float_8(-128), 16777216.f, "ufix2float_8_2");
    test_checkf(ufix2float_16(8192), 0.125f, "ufix2float_16_1");
    test_checkf(ufix2float_16(-8192), 65535.875f, "ufix2float_16_2");
    test_checkf(ufix2float_24(3<<23), 1.5f, "ufix2float_24_1");
    test_checkf(ufix2float_24(-(3<<23)), 254.5f, "ufix2float_24_2");

#endif

#if PICO_FLOAT_HAS_FIX64_TO_FLOAT_CONVERSIONS
    printf("fix642float\n");
    // todo test correct rounding around maximum precision
    test_checkf(fix642float(-0xa000000000ll, 38), -2.5f, "fix642float1");
    test_checkf(fix642float(-3, -34), -51539607552.0f, "fix642float2");

#ifdef fix642float
#error fix642float overridden, so original needs testing
#endif

    printf("ufix642float\n");
    // todo test correct rounding around maximum precision
    test_checkf(ufix642float(0xa000000000ll, 38), 2.5f, "ufix642float1");
    test_checkf(ufix642float(3, -34), 51539607552.0f, "ufix642float2");

#ifdef ufix642float
#error ufix642float overridden, so original needs testing
#endif
#endif

#if PICO_FLOAT_HAS_FLOAT_TO_FIX32_M_CONVERSIONS
    printf("float2fix\n");
    test_checki(float2fix(-0.5f, 8), -0x80, "float2fix0");
    test_checki(float2fix(3.5f, 8), 0x380, "float2fix1");
    test_checki(float2fix(-3.5f, 8), -0x380, "float2fix2");
    test_checki(float2fix(32768.0f, 16), INT32_MAX, "float2fix3");
    test_checki(float2fix(65536.0f, 16), INT32_MAX, "float2fix4");
    test_checki(float2fix(-65536.0f, 16), INT32_MIN, "float2fix4b");
    test_checki(float2fix(INFINITY, 16), INT32_MAX, "float2fix5");
    test_checki(float2fix(-INFINITY, 16), INT32_MIN, "float2fix5b");
    test_checki(float2fix(INFINITY, -16), INT32_MAX, "float2fix5c");
    test_checki(float2fix(-INFINITY, -16), INT32_MIN, "float2fix5d");
    test_checki(float2fix(INFINITY, 0), INT32_MAX, "float2fix5e");
    test_checki(float2fix(-INFINITY, 0), INT32_MIN, "float2fix5f");
    test_checki(float2fix(3.24999f, 2), 12, "float2fix6");
    test_checki(float2fix(3.25f, 2), 13, "float2fix7");
    test_checki(float2fix(-3.24999f, 2), -13, "float2fix8");
    test_checki(float2fix(-3.25f, 2), -13, "float2fix9");
    test_checki(float2fix(-0.75f, 1), -2, "float2fix10");
    test_checki(float2fix(-3.0f, -1), -2, "float2fix11"); // not very useful
    u32f.u = 0x7f012345;
    test_checki(float2fix(u32f.f, 0), INT32_MAX, "float2fix12a");
    test_checki(float2fix(u32f.f, 1), INT32_MAX, "float2fix12b");
    test_checki(float2fix(u32f.f, 2), INT32_MAX, "float2fix12c");
    u32f.u = 0xff012345;
    test_checki(float2fix(u32f.f, 0), INT32_MIN, "float2fix13a");
    test_checki(float2fix(u32f.f, 1), INT32_MIN, "float2fix13b");
    test_checki(float2fix(u32f.f, 2), INT32_MIN, "float2fix13c");

#if LIB_PICO_FLOAT_PICO_VFP
#ifndef float2fix
#error float2fix not actually overridden
#endif
    printf("call_float2fix\n");
    test_checki(call_float2fix(-0.5f, 8), -0x80, "call_float2fix0");
    test_checki(call_float2fix(3.5f, 8), 0x380, "call_float2fix1");
    test_checki(call_float2fix(-3.5f, 8), -0x380, "call_float2fix2");
    test_checki(call_float2fix(32768.0f, 16), INT32_MAX, "call_float2fix3");
    test_checki(call_float2fix(65536.0f, 16), INT32_MAX, "call_float2fix4");
    test_checki(call_float2fix(-65536.0f, 16), INT32_MIN, "call_float2fix4b");
    test_checki(call_float2fix(INFINITY, 16), INT32_MAX, "call_float2fix5");
    test_checki(call_float2fix(-INFINITY, 16), INT32_MIN, "call_float2fix5b");
    test_checki(call_float2fix(INFINITY, -16), INT32_MAX, "call_float2fix5c");
    test_checki(call_float2fix(-INFINITY, -16), INT32_MIN, "call_float2fix5d");
    test_checki(call_float2fix(INFINITY, 0), INT32_MAX, "call_float2fix5e");
    test_checki(call_float2fix(-INFINITY, 0), INT32_MIN, "call_float2fix5f");
    test_checki(call_float2fix(3.24999f, 2), 12, "call_float2fix6");
    test_checki(call_float2fix(3.25f, 2), 13, "call_float2fix7");
    test_checki(call_float2fix(-3.24999f, 2), -13, "call_float2fix8");
    test_checki(call_float2fix(-3.25f, 2), -13, "call_float2fix9");
    test_checki(call_float2fix(-0.75f, 1), -2, "call_float2fix10");
    test_checki(call_float2fix(-3.0f, -1), -2, "call_float2fix11"); // not very useful
    u32f.u = 0x7f012345;
    test_checki(call_float2fix(u32f.f, 0), INT32_MAX, "call_float2fix12a");
    test_checki(call_float2fix(u32f.f, 1), INT32_MAX, "call_float2fix12b");
    test_checki(call_float2fix(u32f.f, 2), INT32_MAX, "call_float2fix12c");
    u32f.u = 0xff012345;
    test_checki(call_float2fix(u32f.f, 0), INT32_MIN, "call_float2fix13a");
    test_checki(call_float2fix(u32f.f, 1), INT32_MIN, "call_float2fix13b");
    test_checki(call_float2fix(u32f.f, 2), INT32_MIN, "call_float2fix13c");
#endif

    printf("float2ufix\n");
    test_checku(float2ufix(3.5f, 8), 0x380, "float2ufix1");
    test_checku(float2ufix(-3.5f, 8), 0, "float2ufix2");
    test_checku(float2ufix(32768.0f, 16), 32768 << 16, "float2ufix3");
    test_checku(float2ufix(65536.0f, 16), UINT32_MAX, "float2ufix4");
    test_checku(float2ufix(INFINITY, 16), UINT32_MAX, "float2ufix5");
    test_checku(float2ufix(-INFINITY, 16), 0, "float2ufix5b");
    test_checku(float2ufix(INFINITY, -16), UINT32_MAX, "float2ufix5c");
    test_checku(float2ufix(-INFINITY, -16), 0, "float2ufix5d");
    test_checku(float2ufix(INFINITY, 0), UINT32_MAX, "float2ufix5e");
    test_checku(float2ufix(-INFINITY, 0), 0, "float2ufix5f");
    test_checku(float2ufix(3.24999f, 2), 12, "float2ufix6");
    test_checku(float2ufix(3.25f, 2), 13, "float2ufix7");
    test_checku(float2ufix(3.0f, -1), 1, "float2ufix8"); // not very useful
    u32f.u = 0x7f012345;
    test_checku(float2ufix(u32f.f, 0), UINT32_MAX, "float2ufix9a");
    test_checku(float2ufix(u32f.f, 1), UINT32_MAX, "float2ufix9b");
    test_checku(float2ufix(u32f.f, 2), UINT32_MAX, "float2ufix9c");
    u32f.u = 0xff012345;
    test_checku(float2ufix(u32f.f, 0), 0, "float2ufix10a");
    test_checku(float2ufix(u32f.f, 1), 0, "float2ufix10b");
    test_checku(float2ufix(u32f.f, 2), 0, "float2ufix10c");

#if LIB_PICO_FLOAT_PICO_VFP
#ifndef float2ufix
#error float2ufix not actually overridden
#endif
    printf("call_float2ufix\n");
    test_checku(call_float2ufix(3.5f, 8), 0x380, "call_float2ufix1");
    test_checku(call_float2ufix(-3.5f, 8), 0, "call_float2ufix2");
    test_checku(call_float2ufix(32768.0f, 16), 32768 << 16, "call_float2ufix3");
    test_checku(call_float2ufix(65536.0f, 16), UINT32_MAX, "call_float2ufix4");
    test_checku(call_float2ufix(INFINITY, 16), UINT32_MAX, "call_float2ufix5");
    test_checku(call_float2ufix(-INFINITY, 16), 0, "call_float2ufix5b");
    test_checku(call_float2ufix(INFINITY, -16), UINT32_MAX, "call_float2ufix5c");
    test_checku(call_float2ufix(-INFINITY, -16), 0, "call_float2ufix5d");
    test_checku(call_float2ufix(INFINITY, 0), UINT32_MAX, "call_float2ufix5e");
    test_checku(call_float2ufix(-INFINITY, 0), 0, "call_float2ufix5f");
    test_checku(call_float2ufix(3.24999f, 2), 12, "call_float2ufix6");
    test_checku(call_float2ufix(3.25f, 2), 13, "call_float2ufix7");
    test_checku(call_float2ufix(3.0f, -1), 1, "call_float2ufix8"); // not very useful
    u32f.u = 0x7f012345;
    test_checku(call_float2ufix(u32f.f, 0), UINT32_MAX, "call_float2ufix9a");
    test_checku(call_float2ufix(u32f.f, 1), UINT32_MAX, "call_float2ufix9b");
    test_checku(call_float2ufix(u32f.f, 2), UINT32_MAX, "call_float2ufix9c");
    u32f.u = 0xff012345;
    test_checku(call_float2ufix(u32f.f, 0), 0, "call_float2ufix10a");
    test_checku(call_float2ufix(u32f.f, 1), 0, "call_float2ufix10b");
    test_checku(call_float2ufix(u32f.f, 2), 0, "call_float2ufix10c");
#endif
#endif

#if PICO_FLOAT_HAS_FLOAT_TO_FIX64_M_CONVERSIONS
    printf("float2fix64\n");
    test_checki64(float2fix64(3.5f, 8), 0x380, "float2fix64_1");
    test_checki64(float2fix64(-3.5f, 8), -0x380, "float2fix64_2");
    test_checki64(float2fix64(32768.0f, 16), 32768ll << 16, "float2fix64_3");
    test_checki64(float2fix64(65536.0f, 16), 65536ll << 16, "float2fix64_4");
    test_checki64(float2fix64(2147483648.0f, 16), 2147483648ll << 16, "float2fix64_4b");
    test_checki64(float2fix64(65536.0f * 65536.0f * 32768.0f, 16), INT64_MAX, "float2fix64_4c");
    test_checki64(float2fix64(INFINITY, 16), INT64_MAX, "float2fix64_5");
    test_checki64(float2fix64(-INFINITY, 16), INT64_MIN, "float2fix64_5b");
    test_checki64(float2fix64(INFINITY, -16), INT64_MAX, "float2fix64_5c");
    test_checki64(float2fix64(-INFINITY, -16), INT64_MIN, "float2fix64_5d");
    test_checki64(float2fix64(INFINITY, 0), INT64_MAX, "float2fix64_5e");
    test_checki64(float2fix64(-INFINITY, 0), INT64_MIN, "float2fix64_5f");
    test_checki64(float2fix64(3.24999f, 2), 12, "float2fix64_6");
    test_checki64(float2fix64(3.25f, 2), 13, "float2fix64_7");
    test_checki64(float2fix64(-3.24999f, 2), -13, "float2fix64_8");
    test_checki64(float2fix64(-3.25f, 2), -13, "float2fix64_9");
    test_checki64(float2fix64(-3.0f, -1), -2, "float2fix64_10"); // not very useful
    u32f.u = 0x7f012345;
    test_checki64(float2fix64(u32f.f, 0), INT64_MAX, "float2fix64_11a");
    test_checki64(float2fix64(u32f.f, 1), INT64_MAX, "float2fix64_11b");
    test_checki64(float2fix64(u32f.f, 2), INT64_MAX, "float2fix64_11c");
    u32f.u = 0xff012345;
    test_checki64(float2fix64(u32f.f, 0), INT64_MIN, "float2fix64_12a");
    test_checki64(float2fix64(u32f.f, 1), INT64_MIN, "float2fix64_12b");
    test_checki64(float2fix64(u32f.f, 2), INT64_MIN, "float2fix64_12c");

#ifdef float2fix64
#error float2fix64 overridden, so original needs testing
#endif

    printf("float2ufix64\n");
    test_checku64(float2ufix64(3.5f, 8), 0x380, "float2ufix64_1");
    test_checku64(float2ufix64(-3.5f, 8), 0, "float2ufix64_2");
    test_checku64(float2ufix64(32768.0f, 16), 32768ull << 16, "float2ufix64_3");
    test_checku64(float2ufix64(65536.0f, 16), 65536ull << 16, "float2ufix64_4");
    test_checku64(float2ufix64(2147483648.0f, 16), 2147483648ull << 16, "float2ufix64_4b");
    test_checku64(float2ufix64(INFINITY, 16), UINT64_MAX, "float2ufix64_5");
    test_checku64(float2ufix64(-INFINITY, 16), 0, "float2ufix64_5b");
    test_checku64(float2ufix64(INFINITY, -16), UINT64_MAX, "float2ufix64_5c");
    test_checku64(float2ufix64(-INFINITY, -16), 0, "float2ufix64_5d");
    test_checku64(float2ufix64(INFINITY, 0), UINT64_MAX, "float2ufix64_5e");
    test_checku64(float2ufix64(-INFINITY, 0), 0, "float2ufix64_5f");
    test_checku64(float2ufix64(3.24999f, 2), 12, "float2ufix64_6");
    test_checku64(float2ufix64(3.25f, 2), 13, "float2ufix64_7");
    test_checku64(float2ufix64(3.0f, -1), 1, "float2ufix64_8"); // not very useful
    u32f.u = 0x7f012345;
    test_checku64(float2ufix64(u32f.f, 0), UINT64_MAX, "float2ufix64_9a");
    test_checku64(float2ufix64(u32f.f, 1), UINT64_MAX, "float2ufix64_9b");
    test_checku64(float2ufix64(u32f.f, 2), UINT64_MAX, "float2ufix64_9c");
    u32f.u = 0xff012345;
    test_checku64(float2ufix64(u32f.f, 0), 0, "float2ufix64_10a");
    test_checku64(float2ufix64(u32f.f, 1), 0, "float2ufix64_10b");
    test_checku64(float2ufix64(u32f.f, 2), 0, "float2ufix64_10c");

#ifdef float2ufix64
#error float2ufix64 overridden, so original needs testing
#endif
#endif

#if PICO_FLOAT_HAS_FLOAT_TO_FIX32_Z_CONVERSIONS
    printf("float2fix_z\n");
    test_checki(float2fix_z(3.5f, 8), 0x380, "float2fix_z1");
    test_checki(float2fix_z(-3.5f, 8), -0x380, "float2fix_z2");
    test_checki(float2fix_z(32768.0f, 16), INT32_MAX, "float2fix_z3");
    test_checki(float2fix_z(65536.0f, 16), INT32_MAX, "float2fix_z4");
    test_checki(float2fix_z(INFINITY, 16), INT32_MAX, "float2fix_z5");
    test_checki(float2fix_z(-INFINITY, 16), INT32_MIN, "float2fix_z5b");
    test_checki(float2fix_z(INFINITY, -16), INT32_MAX, "float2fix_z5c");
    test_checki(float2fix_z(-INFINITY, -16), INT32_MIN, "float2fix_z5d");
    test_checki(float2fix_z(INFINITY, 0), INT32_MAX, "float2fix_z5e");
    test_checki(float2fix_z(-INFINITY, 0), INT32_MIN, "float2fix_z5f");
    test_checki(float2fix_z(3.24999f, 2), 12, "float2fix_z6");
    test_checki(float2fix_z(3.25f, 2), 13, "float2fix_z7");
    test_checki(float2fix_z(-3.24999f, 2), -12, "float2fix_z8");
    test_checki(float2fix_z(-3.25f, 2), -13, "float2fix_z9");
    test_checki(float2fix_z(-0.75f, 1), -1, "float2fix_z10");
    test_checki(float2fix_z(-3.0f, -1), -1, "float2fix_z11"); // not very useful
    u32f.u = 0x7f012345;
    test_checki(float2fix_z(u32f.f, 0), INT32_MAX, "float2fix_z12a");
    test_checki(float2fix_z(u32f.f, 1), INT32_MAX, "float2fix_z12b");
    test_checki(float2fix_z(u32f.f, 2), INT32_MAX, "float2fix_z12c");
    u32f.u = 0xff012345;
    test_checki(float2fix_z(u32f.f, 0), INT32_MIN, "float2fix_z13a");
    test_checki(float2fix_z(u32f.f, 1), INT32_MIN, "float2fix_z13b");
    test_checki(float2fix_z(u32f.f, 2), INT32_MIN, "float2fix_z13c");

#if LIB_PICO_FLOAT_PICO_VFP
    printf("call_float2fix_z\n");
    test_checki(call_float2fix_z(3.5f, 8), 0x380, "call_float2fix_z1");
    test_checki(call_float2fix_z(-3.5f, 8), -0x380, "call_float2fix_z2");
    test_checki(call_float2fix_z(32768.0f, 16), INT32_MAX, "call_float2fix_z3");
    test_checki(call_float2fix_z(65536.0f, 16), INT32_MAX, "call_float2fix_z4");
    test_checki(call_float2fix_z(INFINITY, 16), INT32_MAX, "call_float2fix_z5");
    test_checki(call_float2fix_z(-INFINITY, 16), INT32_MIN, "call_float2fix_z5b");
    test_checki(call_float2fix_z(INFINITY, -16), INT32_MAX, "call_float2fix_z5c");
    test_checki(call_float2fix_z(-INFINITY, -16), INT32_MIN, "call_float2fix_z5d");
    test_checki(call_float2fix_z(INFINITY, 0), INT32_MAX, "call_float2fix_z5e");
    test_checki(call_float2fix_z(-INFINITY, 0), INT32_MIN, "call_float2fix_z5f");
    test_checki(call_float2fix_z(3.24999f, 2), 12, "call_float2fix_z6");
    test_checki(call_float2fix_z(3.25f, 2), 13, "call_float2fix_z7");
    test_checki(call_float2fix_z(-3.24999f, 2), -12, "call_float2fix_z8");
    test_checki(call_float2fix_z(-3.25f, 2), -13, "call_float2fix_z9");
    test_checki(call_float2fix_z(-0.75f, 1), -1, "call_float2fix_z10");
    test_checki(call_float2fix_z(-3.0f, -1), -1, "call_float2fix_z11"); // not very useful
    u32f.u = 0x7f012345;
    test_checki(call_float2fix_z(u32f.f, 0), INT32_MAX, "call_float2fix_z12a");
    test_checki(call_float2fix_z(u32f.f, 1), INT32_MAX, "call_float2fix_z12b");
    test_checki(call_float2fix_z(u32f.f, 2), INT32_MAX, "call_float2fix_z12c");
    u32f.u = 0xff012345;
    test_checki(call_float2fix_z(u32f.f, 0), INT32_MIN, "call_float2fix_z13a");
    test_checki(call_float2fix_z(u32f.f, 1), INT32_MIN, "call_float2fix_z13b");
    test_checki(call_float2fix_z(u32f.f, 2), INT32_MIN, "call_float2fix_z13c");
#endif

    printf("float2ufix_z\n");
    test_checku(float2ufix_z(3.5f, 8), 0x380, "float2ufix_z1");
    test_checku(float2ufix_z(-3.5f, 8), 0, "float2ufix_z2");
    test_checku(float2ufix_z(32768.0f, 16), 32768 << 16, "float2ufix_z3");
    test_checku(float2ufix_z(65536.0f, 16), UINT32_MAX, "float2ufix_z4");
    test_checku(float2ufix_z(INFINITY, 16), UINT32_MAX, "float2ufix_z5");
    test_checku(float2ufix_z(-INFINITY, 16), 0, "float2ufix_z5b");
    test_checku(float2ufix_z(INFINITY, -16), UINT32_MAX, "float2ufix_z5c");
    test_checku(float2ufix_z(-INFINITY, -16), 0, "float2ufix_z5d");
    test_checku(float2ufix_z(INFINITY, 0), UINT32_MAX, "float2ufix_z5e");
    test_checku(float2ufix_z(-INFINITY, 0), 0, "float2ufix_z5f");
    test_checku(float2ufix_z(3.24999f, 2), 12, "float2ufix_z6");
    test_checku(float2ufix_z(3.25f, 2), 13, "float2ufix_z7");
    test_checku(float2ufix_z(3.0f, -1), 1, "float2ufix_z8"); // not very useful
    u32f.u = 0x7f012345;
    test_checku(float2ufix_z(u32f.f, 0), UINT32_MAX, "float2ufix_z9a");
    test_checku(float2ufix_z(u32f.f, 1), UINT32_MAX, "float2ufix_z9b");
    test_checku(float2ufix_z(u32f.f, 2), UINT32_MAX, "float2ufix_z9c");
    u32f.u = 0xff012345;
    test_checku(float2ufix_z(u32f.f, 0), 0, "float2ufix_z10a");
    test_checku(float2ufix_z(u32f.f, 1), 0, "float2ufix_z10b");
    test_checku(float2ufix_z(u32f.f, 2), 0, "float2ufix_z10c");

#if LIB_PICO_FLOAT_PICO_VFP
    printf("call_float2ufix_z\n");
    test_checku(call_float2ufix_z(3.5f, 8), 0x380, "call_float2ufix_z1");
    test_checku(call_float2ufix_z(-3.5f, 8), 0, "call_float2ufix_z2");
    test_checku(call_float2ufix_z(32768.0f, 16), 32768 << 16, "call_float2ufix_z3");
    test_checku(call_float2ufix_z(65536.0f, 16), UINT32_MAX, "call_float2ufix_z4");
    test_checku(call_float2ufix_z(INFINITY, 16), UINT32_MAX, "call_float2ufix_z5");
    test_checku(call_float2ufix_z(-INFINITY, 16), 0, "call_float2ufix_z5b");
    test_checku(call_float2ufix_z(INFINITY, -16), UINT32_MAX, "call_float2ufix_z5c");
    test_checku(call_float2ufix_z(-INFINITY, -16), 0, "call_float2ufix_z5d");
    test_checku(call_float2ufix_z(INFINITY, 0), UINT32_MAX, "call_float2ufix_z5e");
    test_checku(call_float2ufix_z(-INFINITY, 0), 0, "call_float2ufix_z5f");
    test_checku(call_float2ufix_z(3.24999f, 2), 12, "call_float2ufix_z6");
    test_checku(call_float2ufix_z(3.25f, 2), 13, "call_float2ufix_z7");
    test_checku(call_float2ufix_z(3.0f, -1), 1, "call_float2ufix_z8"); // not very useful
    u32f.u = 0x7f012345;
    test_checku(call_float2ufix_z(u32f.f, 0), UINT32_MAX, "call_float2ufix_z9a");
    test_checku(call_float2ufix_z(u32f.f, 1), UINT32_MAX, "call_float2ufix_z9b");
    test_checku(call_float2ufix_z(u32f.f, 2), UINT32_MAX, "call_float2ufix_z9c");
    u32f.u = 0xff012345;
    test_checku(call_float2ufix_z(u32f.f, 0), 0, "call_float2ufix_z10a");
    test_checku(call_float2ufix_z(u32f.f, 1), 0, "call_float2ufix_z10b");
    test_checku(call_float2ufix_z(u32f.f, 2), 0, "call_float2ufix_z10c");
#endif
#endif

#if PICO_FLOAT_HAS_FLOAT_TO_FIX64_Z_CONVERSIONS
    printf("float2fix64_z\n");
    test_checki64(float2fix64_z(3.5f, 8), 0x380, "float2fix64_z1");
    test_checki64(float2fix64_z(-3.5f, 8), -0x380, "float2fix64_z2");
    test_checki64(float2fix64_z(32768.0f, 16), 32768ll << 16, "float2fix64_z3");
    test_checki64(float2fix64_z(65536.0f, 16), 65536ll << 16, "float2fix64_z4");
    test_checki64(float2fix64_z(65536.0f * 65536.0f * 32768.0f, 16), INT64_MAX, "float2fix64_z4b");
    test_checki64(float2fix64_z(INFINITY, 16), INT64_MAX, "float2fix64_z5");
    test_checki64(float2fix64_z(-INFINITY, 16), INT64_MIN, "float2fix64_z5b");
    test_checki64(float2fix64_z(INFINITY, -16), INT64_MAX, "float2fix64_z5c");
    test_checki64(float2fix64_z(-INFINITY, -16), INT64_MIN, "float2fix64_z5d");
    test_checki64(float2fix64_z(INFINITY, 0), INT64_MAX, "float2fix64_z5e");
    test_checki64(float2fix64_z(-INFINITY, 0), INT64_MIN, "float2fix64_z5f");
    test_checki64(float2fix64_z(3.24999f, 2), 12, "float2fix64_z6");
    test_checki64(float2fix64_z(3.25f, 2), 13, "float2fix64_z7");
    test_checki64(float2fix64_z(-3.24999f, 2), -12, "float2fix64_z8");
    test_checki64(float2fix64_z(-3.25f, 2), -13, "float2fix64_z9");
    test_checki64(float2fix64_z(-3.0f, -1), -1, "float2fix64_z10"); // not very useful
    u32f.u = 0x7f012345;
    test_checki64(float2fix64_z(u32f.f, 0), INT64_MAX, "float2fix64_z11a");
    test_checki64(float2fix64_z(u32f.f, 1), INT64_MAX, "float2fix64_z11b");
    test_checki64(float2fix64_z(u32f.f, 2), INT64_MAX, "float2fix64_z11c");
    u32f.u = 0xff012345;
    test_checki64(float2fix64_z(u32f.f, 0), INT64_MIN, "float2fix64_z12a");
    test_checki64(float2fix64_z(u32f.f, 1), INT64_MIN, "float2fix64_z12b");
    test_checki64(float2fix64_z(u32f.f, 2), INT64_MIN, "float2fix64_z12c");
#ifdef float2fix64_z
#error float2fix64_z overridden, so original needs testing
#endif

    printf("float2ufix64_z\n");
    test_checku64(float2ufix64_z(3.5f, 8), 0x380, "float2ufix64_z1");
    test_checku64(float2ufix64_z(-3.5f, 8), 0, "float2ufix64_z2");
    test_checku64(float2ufix64_z(32768.0f, 16), 32768ll << 16, "float2ufix64_z3");
    test_checku64(float2ufix64_z(65536.0f, 16), 65536ll << 16, "float2ufix64_z4");
    test_checku64(float2ufix64_z(65536.0f * 65536.0f * 65536.0f, 16), UINT64_MAX, "float2ufix64_z4b");
    test_checku64(float2ufix64_z(INFINITY, 16), UINT64_MAX, "float2ufix64_z5");
    test_checku64(float2ufix64_z(-INFINITY, 16), 0, "float2ufix64_z5b");
    test_checku64(float2ufix64_z(INFINITY, -16), UINT64_MAX, "float2ufix64_z5c");
    test_checku64(float2ufix64_z(-INFINITY, -16), 0, "float2ufix64_z5d");
    test_checku64(float2ufix64_z(INFINITY, 0), UINT64_MAX, "float2ufix64_z5e");
    test_checku64(float2ufix64_z(-INFINITY, 0), 0, "float2ufix64_z5f");
    test_checku64(float2ufix64_z(3.24999f, 2), 12, "float2ufix64_z6");
    test_checku64(float2ufix64_z(3.25f, 2), 13, "float2ufix64_z7");
    test_checku64(float2ufix64_z(3.0f, -1), 1, "float2ufix64_z8"); // not very useful
    u32f.u = 0x7f012345;
    test_checku64(float2ufix64_z(u32f.f, 0), UINT64_MAX, "float2ufix64_z9a");
    test_checku64(float2ufix64_z(u32f.f, 1), UINT64_MAX, "float2ufix64_z9b");
    test_checku64(float2ufix64_z(u32f.f, 2), UINT64_MAX, "float2ufix64_z9c");
    u32f.u = 0xff012345;
    test_checku64(float2ufix64_z(u32f.f, 0), 0, "float2ufix64_z10a");
    test_checku64(float2ufix64_z(u32f.f, 1), 0, "float2ufix64_z10b");
    test_checku64(float2ufix64_z(u32f.f, 2), 0, "float2ufix64_z10c");
#ifdef float2ufix64_z
#error float2ufix64_z overridden, so original needs testing
#endif
#endif

#if PICO_FLOAT_HAS_FLOAT_TO_INT32_M_CONVERSIONS
    printf("float2int\n");
    test_checki(float2int(0.0f), 0, "float2int1");
    test_checki(float2int(0.25f), 0, "float2int1b");
    test_checki(float2int(0.5f), 0, "float2int2");
    test_checki(float2int(0.75f), 0, "float2int2b");
    test_checki(float2int(1.0f), 1, "float2int3");
    test_checki(float2int(-10.0f), -10, "float2int3b");
    test_checki(float2int(-0.0f), 0, "float2int3c");
    test_checki(float2int(-0.25f), -1, "float2int4");
    test_checki(float2int(-0.5f), -1, "float2int4b");
    test_checki(float2int(-0.75f), -1, "float2int5");
    test_checki(float2int(-1.0f), -1, "float2int5b");
    // todo test correct rounding around maximum precision
    test_checki(float2int(2147483647.0f), INT32_MAX, "float2int6");
    test_checki(float2int(21474836470.0f), INT32_MAX, "float2int7");
    test_checki(float2int(-2147483648.0f), INT32_MIN, "float2int8");
    test_checki(float2int(-21474836480.0f), INT32_MIN, "float2int9");
    test_checki(float2int(-2.5f), -3, "float2int10");
    test_checki(float2int(-2.4f), -3, "float2int11");
#ifdef float2int
#error float2int overridden, so original needs testing
#endif

    printf("float2uint\n");
    test_checku(float2uint(0.0f), 0, "float2uint1");
    test_checku(float2uint(0.25f), 0, "float2uint2");
    test_checku(float2uint(0.5f), 0, "float2uint3");
    test_checku(float2uint(0.75f), 0, "float2uint4");
    test_checku(float2uint(1.0f), 1, "float2uint5");
    test_checku(float2uint(2147483647.0f), INT32_MAX+1u, "float2uint6"); // note loss of precision
    test_checku(float2uint(2147483648.0f), INT32_MAX+1u, "float2uint7");
    test_checku(float2uint(4294967294.5f), UINT32_MAX, "float2uint8"); // note loss of precision
    test_checku(float2uint(4294967295.0f), UINT32_MAX, "float2uint9");
    test_checku(float2uint(42949672950.0f), UINT32_MAX, "float2uint10");
#ifdef float2uint
#error float2uint overridden, so original needs testing
#endif
#endif

#if PICO_FLOAT_HAS_FLOAT_TO_INT64_M_CONVERSIONS
    printf("float2int64\n");
    test_checki64(float2int64(0.0f), 0, "float2int64_1");
    test_checki64(float2int64(0.25f), 0, "float2int64_1b");
    test_checki64(float2int64(0.5f), 0, "float2int64_2");
    test_checki64(float2int64(0.75f), 0, "float2int64_2b");
    test_checki64(float2int64(1.0f), 1, "float2int64_3");
    test_checki64(float2int64(-10.0f), -10, "float2int64_3b");
    test_checki64(float2int64(-0.0f), 0, "float2int64_3c");
    test_checki64(float2int64(-0.25f), -1, "float2int64_4");
    test_checki64(float2int64(-0.5f), -1, "float2int64_4b");
    test_checki64(float2int64(-0.75f), -1, "float2int64_5");
    test_checki64(float2int64(-1.0f), -1, "float2int64_5b");
    // todo test correct rounding around maximum precision
    test_checki64(float2int64(2147483647.0f), INT32_MAX+1ll, "float2int64_6");
    test_checki64(float2int64(21474836470.0f), 21474836480ll, "float2int64_7"); // note loss of precision
    test_checki64(float2int64(-2147483648.0f), INT32_MIN, "float2int64_8");
    test_checki64(float2int64(-21474836480.0f), -21474836480ll, "float2int64_9");
    test_checki64(float2int64(-2.5f), -3, "float2int64_10");
    test_checki64(float2int64(-2.4f), -3, "float2int64_11");
#ifdef float2uint64
#error float2uint64 overridden, so original needs testing
#endif


    printf("float2uint64\n");
    test_checku64(float2uint64(0.0f), 0, "float2uint64_1");
    test_checku64(float2uint64(0.25f), 0, "float2uint64_2");
    test_checku64(float2uint64(0.5f), 0, "float2uint64_3");
    test_checku64(float2uint64(0.75f), 0, "float2uint64_4");
    test_checku64(float2uint64(1.0f), 1, "float2uint64_5");
    test_checku64(float2uint64(2147483647.0f), INT32_MAX+1u, "float2uint64_6"); // note loss of precision
    test_checku64(float2uint64(2147483648.0f), INT32_MAX+1u, "float2uint64_7");
    test_checku64(float2uint64(4294967294.5f), 4294967296ull, "float2uint64_8"); // note loss of precision
    test_checku64(float2uint64(4294967295.0f), 4294967296ull, "float2uint64_9"); // note loss of precision
    test_checku64(float2uint64(42949672950.0f), 42949672960ull, "float2uint64_10"); // note loss of precision
#endif

    // // These methods round towards 0.

#if PICO_FLOAT_HAS_FLOAT_TO_INT32_Z_CONVERSIONS
    printf("float2int_z\n");
    test_checki(float2int_z(0.0f), 0, "float2int_z1");
    test_checki(float2int_z(0.25f), 0, "float2int_z1b");
    test_checki(float2int_z(0.5f), 0, "float2int_z2");
    test_checki(float2int_z(0.75f), 0, "float2int_z2b");
    test_checki(float2int_z(1.0f), 1, "float2int_z3");
    test_checki(float2int_z(-10.0f), -10, "float2int_z3b");
    test_checki(float2int_z(-0.0f), 0, "float2int_z3c");
    test_checki(float2int_z(-0.25f), 0, "float2int_z4");
    test_checki(float2int_z(-0.5f), 0, "float2int_z4b");
    test_checki(float2int_z(-0.75f), 0, "float2int_z5");
    test_checki(float2int_z(-1.0f), -1, "float2int_z5b");
    // todo test correct rounding around maximum precision
    test_checki(float2int_z(2147483647.0f), INT32_MAX, "float2int_z6");
    test_checki(float2int_z(21474836470.0f), INT32_MAX, "float2int_z7");
    test_checki(float2int_z(-2147483648.0f), INT32_MIN, "float2int_z8");
    test_checki(float2int_z(-21474836480.0f), INT32_MIN, "float2int_z9");
    test_checki(float2int_z(-2.5f), -2, "float2int_z10");
    test_checki(float2int_z(-2.4f), -2, "float2int_z11");
    test_checki(float2int_z(make_positive_denormal_float()), 0, "float2int_z12");
    test_checki(float2int_z(make_negative_denormal_float()), 0, "float2int_z13");

#if LIB_PICO_FLOAT_PICO_VFP
    // the override is actually an inline func
// #ifndef float2int_z
// #error float2int_z not actually overridden
// #endif
    printf("call_float2int_z\n");
    test_checki(call_float2int_z(0.0f), 0, "call_float2int_z1");
    test_checki(call_float2int_z(0.25f), 0, "call_float2int_z1b");
    test_checki(call_float2int_z(0.5f), 0, "call_float2int_z2");
    test_checki(call_float2int_z(0.75f), 0, "call_float2int_z2b");
    test_checki(call_float2int_z(1.0f), 1, "call_float2int_z3");
    test_checki(call_float2int_z(-10.0f), -10, "call_float2int_z3b");
    test_checki(call_float2int_z(-0.0f), 0, "call_float2int_z3c");
    test_checki(call_float2int_z(-0.25f), 0, "call_float2int_z4");
    test_checki(call_float2int_z(-0.5f), 0, "call_float2int_z4b");
    test_checki(call_float2int_z(-0.75f), 0, "call_float2int_z5");
    test_checki(call_float2int_z(-1.0f), -1, "call_float2int_z5b");
    // todo test correct rounding around maximum precision
    test_checki(call_float2int_z(2147483647.0f), INT32_MAX, "call_float2int_z6");
    test_checki(call_float2int_z(21474836470.0f), INT32_MAX, "call_float2int_z7");
    test_checki(call_float2int_z(-2147483648.0f), INT32_MIN, "call_float2int_z8");
    test_checki(call_float2int_z(-21474836480.0f), INT32_MIN, "call_float2int_z9");
    test_checki(call_float2int_z(-2.5f), -2, "call_float2int_z10");
    test_checki(call_float2int_z(-2.4f), -2, "call_float2int_z11");
    test_checki(call_float2int_z(make_positive_denormal_float()), 0, "call_float2int_z12");
    test_checki(call_float2int_z(make_negative_denormal_float()), 0, "call_float2int_z13");
#endif

    printf("float2uint_z\n");
    test_checku(float2uint_z(0.0f), 0, "float2uint_z1");
    test_checku(float2uint_z(0.25f), 0, "float2uint_z2");
    test_checku(float2uint_z(0.5f), 0, "float2uint_z3");
    test_checku(float2uint_z(0.75f), 0, "float2uint_z4");
    test_checku(float2uint_z(1.0f), 1, "float2uint_z5");
    test_checku(float2uint_z(2147483647.0f), INT32_MAX+1u, "float2uint_z6"); // note loss of precision
    test_checku(float2uint_z(2147483648.0f), INT32_MAX+1u, "float2uint_z7");
    // todo test correct rounding around maximum precision
    test_checku(float2uint_z(4294967294.5f), UINT32_MAX, "float2uint_z8"); // note loss of precision
    test_checku(float2uint_z(4294967295.0f), UINT32_MAX, "float2uint_z9");
    test_checku(float2uint_z(42949672950.0f), UINT32_MAX, "float2uint_z10");
    test_checku(float2uint_z(make_positive_denormal_float()), 0, "float2uint_z11");
    test_checku(float2uint_z(make_negative_denormal_float()), 0, "float2uint_z12");

#if LIB_PICO_FLOAT_PICO_VFP
    // the override is actually an inline func
// #ifndef float2uint_z
// #error float2uint_z not actually overridden
// #endif
    printf("call_float2uint_z\n");
    test_checku(call_float2uint_z(0.0f), 0, "call_float2uint_z1");
    test_checku(call_float2uint_z(0.25f), 0, "call_float2uint_z2");
    test_checku(call_float2uint_z(0.5f), 0, "call_float2uint_z3");
    test_checku(call_float2uint_z(0.75f), 0, "call_float2uint_z4");
    test_checku(call_float2uint_z(1.0f), 1, "call_float2uint_z5");
    test_checku(call_float2uint_z(2147483647.0f), INT32_MAX+1u, "call_float2uint_z6"); // note loss of precision
    test_checku(call_float2uint_z(2147483648.0f), INT32_MAX+1u, "call_float2uint_z7");
    // todo test correct rounding around maximum precision
    test_checku(call_float2uint_z(4294967294.5f), UINT32_MAX, "call_float2uint_z8"); // note loss of precision
    test_checku(call_float2uint_z(4294967295.0f), UINT32_MAX, "call_float2uint_z9");
    test_checku(call_float2uint_z(42949672950.0f), UINT32_MAX, "call_float2uint_z10");
    test_checku(call_float2uint_z(make_positive_denormal_float()), 0, "call_float2uint_z11");
    test_checku(call_float2uint_z(make_negative_denormal_float()), 0, "call_float2uint_z12");
#endif
#endif

#if PICO_FLOAT_HAS_FLOAT_TO_INT64_Z_CONVERSIONS
    printf("float2int64_z\n");
    test_checki64(float2int64_z(0.0f), 0, "float2int64_z1");
    test_checki64(float2int64_z(0.25f), 0, "float2int64_z1b");
    test_checki64(float2int64_z(0.5f), 0, "float2int64_z2");
    test_checki64(float2int64_z(0.75f), 0, "float2int64_z2b");
    test_checki64(float2int64_z(1.0f), 1, "float2int64_z3");
    test_checki64(float2int64_z(-10.0f), -10, "float2int64_z3b");
    test_checki64(float2int64_z(-0.0f), 0, "float2int64_z3c");
    test_checki64(float2int64_z(-0.25f), 0, "float2int64_z4");
    test_checki64(float2int64_z(-0.5f), 0, "float2int64_z4b");
    test_checki64(float2int64_z(-0.75f), 0, "float2int64_z5");
    test_checki64(float2int64_z(-1.0f), -1, "float2int64_z5b");
    test_checki64(float2int64_z(2147483647.0f), 2147483648ll, "float2int64_z6"); // note loss of precision
    test_checki64(float2int64_z(21474836470.0f), 21474836480ll, "float2int64_z7"); // note loss of precision
    test_checki64(float2int64_z(-2147483648.0f), INT32_MIN, "float2int64_z8");
    test_checki64(float2int64_z(-21474836480.0f), -21474836480ll, "float2int64_z9");
    test_checki64(float2int64_z(-2.5f), -2, "float2int64_z10");
    test_checki64(float2int64_z(-2.4f), -2, "float2int64_z11");
    test_checki64(float2int64_z(make_positive_denormal_float()), 0, "float2int64_z12");
    test_checki64(float2int64_z(make_negative_denormal_float()), 0, "float2int64_z13");

    printf("float2uint64_z\n");
    test_checku64(float2uint64_z(0.0f), 0, "float2uint64_z1");
    test_checku64(float2uint64_z(0.25f), 0, "float2uint64_z2");
    test_checku64(float2uint64_z(0.5f), 0, "float2uint64_z3");
    test_checku64(float2uint64_z(0.75f), 0, "float2uint64_z4");
    test_checku64(float2uint64_z(1.0f), 1, "float2uint64_z5");
    test_checku64(float2uint64_z(2147483647.0f), INT32_MAX+1u, "float2uint64_z6"); // note loss of precision
    test_checku64(float2uint64_z(2147483648.0f), INT32_MAX+1u, "float2uint64_z7");
    test_checku64(float2uint64_z(4294967294.5f), 4294967296ull, "float2uint64_z8"); // note loss of precision
    test_checku64(float2uint64_z(4294967295.0f), 4294967296ull, "float2uint64_z9"); // note loss of precision
    test_checku64(float2uint64_z(42949672950.0f), 42949672960ull, "float2uint64_z10"); // note loss of precision
    test_checku64(float2uint64_z(make_positive_denormal_float()), 0, "float2uint64_z11");
    test_checku64(float2uint64_z(make_negative_denormal_float()), 0, "float2uint64_z12");
#endif
    // float exp10f(float x);
    // void sincosf(float x, float *sinx, float *cosx);
    // float powintf(float x, int y);
    return rc;
}

int main() {
    stdio_init_all();
    int rc = test();
    if (rc) {
        printf("FAILED\n");
    } else {
        printf("PASSED\n");
    }
}
