[thirdparty/openssl.git] / test / params_conversion_test.c

/*
 * Copyright 2019-2022 The OpenSSL Project Authors. All Rights Reserved.
 * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <string.h>
#include <openssl/params.h>
#include "testutil.h"

/* On machines that dont support <inttypes.h> just disable the tests */
#if !defined(OPENSSL_NO_INTTYPES_H)

# ifdef OPENSSL_SYS_VMS
#  define strtoumax strtoull
#  define strtoimax strtoll
# endif

typedef struct {
    OSSL_PARAM *param;
    int32_t i32;
    int64_t i64;
    uint32_t u32;
    uint64_t u64;
    double d;
    int valid_i32, valid_i64, valid_u32, valid_u64, valid_d;
    void *ref, *datum;
    size_t size;
} PARAM_CONVERSION;

static int param_conversion_load_stanza(PARAM_CONVERSION *pc, const STANZA *s)
{

    static int32_t datum_i32, ref_i32;
    static int64_t datum_i64, ref_i64;
    static uint32_t datum_u32, ref_u32;
    static uint64_t datum_u64, ref_u64;
    static double datum_d, ref_d;
    static OSSL_PARAM params[] = {
        OSSL_PARAM_int32("int32",   &datum_i32),
        OSSL_PARAM_int64("int64",   &datum_i64),
        OSSL_PARAM_uint32("uint32", &datum_u32),
        OSSL_PARAM_uint64("uint64", &datum_u64),
        OSSL_PARAM_double("double", &datum_d),
        OSSL_PARAM_END
    };
    int def_i32 = 0, def_i64 = 0, def_u32 = 0, def_u64 = 0, def_d = 0;
    const PAIR *pp = s->pairs;
    const char *type = NULL;
    char *p;
    int i;

    memset(pc, 0, sizeof(*pc));

    for (i = 0; i < s->numpairs; i++, pp++) {
        p = "";
        if (OPENSSL_strcasecmp(pp->key, "type") == 0) {
            if (type != NULL) {
                TEST_info("Line %d: multiple type lines", s->curr);
                return 0;
            }
            pc->param = OSSL_PARAM_locate(params, type = pp->value);
            if (pc->param == NULL) {
                TEST_info("Line %d: unknown type line", s->curr);
                return 0;
            }
        } else if (OPENSSL_strcasecmp(pp->key, "int32") == 0) {
            if (def_i32++) {
                TEST_info("Line %d: multiple int32 lines", s->curr);
                return 0;
            }
            if (OPENSSL_strcasecmp(pp->value, "invalid") != 0) {
                pc->valid_i32 = 1;
                pc->i32 = (int32_t)strtoimax(pp->value, &p, 10);
            }
        } else if (OPENSSL_strcasecmp(pp->key, "int64") == 0) {
            if (def_i64++) {
                TEST_info("Line %d: multiple int64 lines", s->curr);
                return 0;
            }
            if (OPENSSL_strcasecmp(pp->value, "invalid") != 0) {
                pc->valid_i64 = 1;
                pc->i64 = (int64_t)strtoimax(pp->value, &p, 10);
            }
        } else if (OPENSSL_strcasecmp(pp->key, "uint32") == 0) {
            if (def_u32++) {
                TEST_info("Line %d: multiple uint32 lines", s->curr);
                return 0;
            }
            if (OPENSSL_strcasecmp(pp->value, "invalid") != 0) {
                pc->valid_u32 = 1;
                pc->u32 = (uint32_t)strtoumax(pp->value, &p, 10);
            }
        } else if (OPENSSL_strcasecmp(pp->key, "uint64") == 0) {
            if (def_u64++) {
                TEST_info("Line %d: multiple uint64 lines", s->curr);
                return 0;
            }
            if (OPENSSL_strcasecmp(pp->value, "invalid") != 0) {
                pc->valid_u64 = 1;
                pc->u64 = (uint64_t)strtoumax(pp->value, &p, 10);
            }
        } else if (OPENSSL_strcasecmp(pp->key, "double") == 0) {
            if (def_d++) {
                TEST_info("Line %d: multiple double lines", s->curr);
                return 0;
            }
            if (OPENSSL_strcasecmp(pp->value, "invalid") != 0) {
                pc->valid_d = 1;
                pc->d = strtod(pp->value, &p);
            }
        } else {
            TEST_info("Line %d: unknown keyword %s", s->curr, pp->key);
            return 0;
        }
        if (*p != '\0') {
            TEST_info("Line %d: extra characters at end '%s' for %s",
                      s->curr, p, pp->key);
            return 0;
        }
    }

    if (!TEST_ptr(type)) {
        TEST_info("Line %d: type not found", s->curr);
        return 0;
    }

    if (OPENSSL_strcasecmp(type, "int32") == 0) {
        if (!TEST_true(def_i32) || !TEST_true(pc->valid_i32)) {
            TEST_note("errant int32 on line %d", s->curr);
            return 0;
        }
        datum_i32 = ref_i32 = pc->i32;
        pc->datum = &datum_i32;
        pc->ref = &ref_i32;
        pc->size = sizeof(ref_i32);
    } else if (OPENSSL_strcasecmp(type, "int64") == 0) {
        if (!TEST_true(def_i64) || !TEST_true(pc->valid_i64)) {
            TEST_note("errant int64 on line %d", s->curr);
            return 0;
        }
        datum_i64 = ref_i64 = pc->i64;
        pc->datum = &datum_i64;
        pc->ref = &ref_i64;
        pc->size = sizeof(ref_i64);
    } else if (OPENSSL_strcasecmp(type, "uint32") == 0) {
        if (!TEST_true(def_u32) || !TEST_true(pc->valid_u32)) {
            TEST_note("errant uint32 on line %d", s->curr);
            return 0;
        }
        datum_u32 = ref_u32 = pc->u32;
        pc->datum = &datum_u32;
        pc->ref = &ref_u32;
        pc->size = sizeof(ref_u32);
    } else if (OPENSSL_strcasecmp(type, "uint64") == 0) {
        if (!TEST_true(def_u64) || !TEST_true(pc->valid_u64)) {
            TEST_note("errant uint64 on line %d", s->curr);
            return 0;
        }
        datum_u64 = ref_u64 = pc->u64;
        pc->datum = &datum_u64;
        pc->ref = &ref_u64;
        pc->size = sizeof(ref_u64);
    } else if (OPENSSL_strcasecmp(type, "double") == 0) {
        if (!TEST_true(def_d) || !TEST_true(pc->valid_d)) {
            TEST_note("errant double on line %d", s->curr);
            return 0;
        }
        datum_d = ref_d = pc->d;
        pc->datum = &datum_d;
        pc->ref = &ref_d;
        pc->size = sizeof(ref_d);
    } else {
        TEST_error("type unknown at line %d", s->curr);
        return 0;
    }
    return 1;
}

static int param_conversion_test(const PARAM_CONVERSION *pc, int line)
{
    int32_t i32;
    int64_t i64;
    uint32_t u32;
    uint64_t u64;
    double d;

    if (!pc->valid_i32) {
        if (!TEST_false(OSSL_PARAM_get_int32(pc->param, &i32))
                || !TEST_ulong_ne(ERR_get_error(), 0)) {
            TEST_note("unexpected valid conversion to int32 on line %d", line);
            return 0;
        }
    } else {
        if (!TEST_true(OSSL_PARAM_get_int32(pc->param, &i32))
            || !TEST_true(i32 == pc->i32)) {
            TEST_note("unexpected conversion to int32 on line %d", line);
            return 0;
        }
        memset(pc->datum, 44, pc->size);
        if (!TEST_true(OSSL_PARAM_set_int32(pc->param, i32))
            || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
            TEST_note("unexpected valid conversion from int32 on line %d",
                      line);
            return 0;
        }
    }

    if (!pc->valid_i64) {
        if (!TEST_false(OSSL_PARAM_get_int64(pc->param, &i64))
                || !TEST_ulong_ne(ERR_get_error(), 0)) {
            TEST_note("unexpected valid conversion to int64 on line %d", line);
            return 0;
        }
    } else {
        if (!TEST_true(OSSL_PARAM_get_int64(pc->param, &i64))
            || !TEST_true(i64 == pc->i64)) {
            TEST_note("unexpected conversion to int64 on line %d", line);
            return 0;
        }
        memset(pc->datum, 44, pc->size);
        if (!TEST_true(OSSL_PARAM_set_int64(pc->param, i64))
            || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
            TEST_note("unexpected valid conversion from int64 on line %d",
                      line);
            return 0;
        }
    }

    if (!pc->valid_u32) {
        if (!TEST_false(OSSL_PARAM_get_uint32(pc->param, &u32))
                || !TEST_ulong_ne(ERR_get_error(), 0)) {
            TEST_note("unexpected valid conversion to uint32 on line %d", line);
            return 0;
        }
    } else {
        if (!TEST_true(OSSL_PARAM_get_uint32(pc->param, &u32))
            || !TEST_true(u32 == pc->u32)) {
            TEST_note("unexpected conversion to uint32 on line %d", line);
            return 0;
        }
        memset(pc->datum, 44, pc->size);
        if (!TEST_true(OSSL_PARAM_set_uint32(pc->param, u32))
            || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
            TEST_note("unexpected valid conversion from uint32 on line %d",
                      line);
            return 0;
        }
    }

    if (!pc->valid_u64) {
        if (!TEST_false(OSSL_PARAM_get_uint64(pc->param, &u64))
                || !TEST_ulong_ne(ERR_get_error(), 0)) {
            TEST_note("unexpected valid conversion to uint64 on line %d", line);
            return 0;
        }
    } else {
        if (!TEST_true(OSSL_PARAM_get_uint64(pc->param, &u64))
            || !TEST_true(u64 == pc->u64)) {
            TEST_note("unexpected conversion to uint64 on line %d", line);
            return 0;
        }
        memset(pc->datum, 44, pc->size);
        if (!TEST_true(OSSL_PARAM_set_uint64(pc->param, u64))
            || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
            TEST_note("unexpected valid conversion from uint64 on line %d",
                      line);
            return 0;
        }
    }

    if (!pc->valid_d) {
        if (!TEST_false(OSSL_PARAM_get_double(pc->param, &d))
                || !TEST_ulong_ne(ERR_get_error(), 0)) {
            TEST_note("unexpected valid conversion to double on line %d", line);
            return 0;
        }
    } else {
        if (!TEST_true(OSSL_PARAM_get_double(pc->param, &d))) {
            TEST_note("unable to convert to double on line %d", line);
            return 0;
        }
        /*
         * Check for not a number (NaN) without using the libm functions.
         * When d is a NaN, the standard requires d == d to be false.
         * It's less clear if d != d should be true even though it generally is.
         * Hence we use the equality test and a not.
         */
        if (!(d == d)) {
            /*
             * We've encountered a NaN so check it's really meant to be a NaN.
             * We ignore the case where the two values are both different NaN,
             * that's not resolvable without knowing the underlying format
             * or using libm functions.
             */
            if (!TEST_false(pc->d == pc->d)) {
                TEST_note("unexpected NaN on line %d", line);
                return 0;
            }
        } else if (!TEST_true(d == pc->d)) {
            TEST_note("unexpected conversion to double on line %d", line);
            return 0;
        }
        memset(pc->datum, 44, pc->size);
        if (!TEST_true(OSSL_PARAM_set_double(pc->param, d))
            || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
            TEST_note("unexpected valid conversion from double on line %d",
                      line);
            return 0;
        }
    }

    return 1;
}

static int run_param_file_tests(int i)
{
    STANZA *s;
    PARAM_CONVERSION pc;
    const char *testfile = test_get_argument(i);
    int res = 1;

    if (!TEST_ptr(s = OPENSSL_zalloc(sizeof(*s))))
        return 0;
    if (!test_start_file(s, testfile)) {
        OPENSSL_free(s);
        return 0;
    }

    while (!BIO_eof(s->fp)) {
        if (!test_readstanza(s)) {
            res = 0;
            goto end;
        }
        if (s->numpairs != 0)
            if (!param_conversion_load_stanza(&pc, s)
                || !param_conversion_test(&pc, s->curr))
                res = 0;
        test_clearstanza(s);
    }
end:
    test_end_file(s);
    OPENSSL_free(s);
    return res;
}

#endif /* OPENSSL_NO_INTTYPES_H */

OPT_TEST_DECLARE_USAGE("file...\n")

int setup_tests(void)
{
    size_t n;

    if (!test_skip_common_options()) {
        TEST_error("Error parsing test options\n");
        return 0;
    }

    n = test_get_argument_count();
    if (n == 0)
        return 0;

#if !defined(OPENSSL_NO_INTTYPES_H)
    ADD_ALL_TESTS(run_param_file_tests, n);
#endif /* OPENSSL_NO_INTTYPES_H */

    return 1;
}
Commit	Line	Data
9830e7ea	1	/*
fecb3aae	2	* Copyright 2019-2022 The OpenSSL Project Authors. All Rights Reserved.
9830e7ea P	3	* Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
	4	*
	5	* Licensed under the Apache License 2.0 (the "License"). You may not use
	6	* this file except in compliance with the License. You can obtain a copy
	7	* in the file LICENSE in the source distribution or at
	8	* https://www.openssl.org/source/license.html
	9	*/
	10
	11	#include <string.h>
9830e7ea P	12	#include <openssl/params.h>
	13	#include "testutil.h"
	14
a1f04782 SL	15	/* On machines that dont support <inttypes.h> just disable the tests */
	16	#if !defined(OPENSSL_NO_INTTYPES_H)
	17
b5461192 RL	18	# ifdef OPENSSL_SYS_VMS
	19	# define strtoumax strtoull
	20	# define strtoimax strtoll
	21	# endif
	22
9830e7ea	23	typedef struct {
4e7991b4	24	OSSL_PARAM *param;
9830e7ea P	25	int32_t i32;
	26	int64_t i64;
	27	uint32_t u32;
	28	uint64_t u64;
	29	double d;
	30	int valid_i32, valid_i64, valid_u32, valid_u64, valid_d;
	31	void ref, datum;
	32	size_t size;
	33	} PARAM_CONVERSION;
	34
	35	static int param_conversion_load_stanza(PARAM_CONVERSION pc, const STANZA s)
	36	{
	37
	38	static int32_t datum_i32, ref_i32;
	39	static int64_t datum_i64, ref_i64;
	40	static uint32_t datum_u32, ref_u32;
	41	static uint64_t datum_u64, ref_u64;
	42	static double datum_d, ref_d;
4e7991b4	43	static OSSL_PARAM params[] = {
9830e7ea P	44	OSSL_PARAM_int32("int32", &datum_i32),
	45	OSSL_PARAM_int64("int64", &datum_i64),
	46	OSSL_PARAM_uint32("uint32", &datum_u32),
	47	OSSL_PARAM_uint64("uint64", &datum_u64),
	48	OSSL_PARAM_double("double", &datum_d),
	49	OSSL_PARAM_END
	50	};
	51	int def_i32 = 0, def_i64 = 0, def_u32 = 0, def_u64 = 0, def_d = 0;
	52	const PAIR *pp = s->pairs;
	53	const char *type = NULL;
	54	char *p;
	55	int i;
	56
	57	memset(pc, 0, sizeof(*pc));
	58
	59	for (i = 0; i < s->numpairs; i++, pp++) {
	60	p = "";
fba140c7	61	if (OPENSSL_strcasecmp(pp->key, "type") == 0) {
9830e7ea P	62	if (type != NULL) {
	63	TEST_info("Line %d: multiple type lines", s->curr);
	64	return 0;
	65	}
	66	pc->param = OSSL_PARAM_locate(params, type = pp->value);
	67	if (pc->param == NULL) {
	68	TEST_info("Line %d: unknown type line", s->curr);
	69	return 0;
	70	}
fba140c7	71	} else if (OPENSSL_strcasecmp(pp->key, "int32") == 0) {
9830e7ea P	72	if (def_i32++) {
	73	TEST_info("Line %d: multiple int32 lines", s->curr);
	74	return 0;
	75	}
fba140c7	76	if (OPENSSL_strcasecmp(pp->value, "invalid") != 0) {
9830e7ea P	77	pc->valid_i32 = 1;
	78	pc->i32 = (int32_t)strtoimax(pp->value, &p, 10);
	79	}
fba140c7	80	} else if (OPENSSL_strcasecmp(pp->key, "int64") == 0) {
9830e7ea P	81	if (def_i64++) {
	82	TEST_info("Line %d: multiple int64 lines", s->curr);
	83	return 0;
	84	}
fba140c7	85	if (OPENSSL_strcasecmp(pp->value, "invalid") != 0) {
9830e7ea P	86	pc->valid_i64 = 1;
	87	pc->i64 = (int64_t)strtoimax(pp->value, &p, 10);
	88	}
fba140c7	89	} else if (OPENSSL_strcasecmp(pp->key, "uint32") == 0) {
9830e7ea P	90	if (def_u32++) {
	91	TEST_info("Line %d: multiple uint32 lines", s->curr);
	92	return 0;
	93	}
fba140c7	94	if (OPENSSL_strcasecmp(pp->value, "invalid") != 0) {
9830e7ea P	95	pc->valid_u32 = 1;
	96	pc->u32 = (uint32_t)strtoumax(pp->value, &p, 10);
	97	}
fba140c7	98	} else if (OPENSSL_strcasecmp(pp->key, "uint64") == 0) {
9830e7ea P	99	if (def_u64++) {
	100	TEST_info("Line %d: multiple uint64 lines", s->curr);
	101	return 0;
	102	}
fba140c7	103	if (OPENSSL_strcasecmp(pp->value, "invalid") != 0) {
9830e7ea P	104	pc->valid_u64 = 1;
	105	pc->u64 = (uint64_t)strtoumax(pp->value, &p, 10);
	106	}
fba140c7	107	} else if (OPENSSL_strcasecmp(pp->key, "double") == 0) {
9830e7ea P	108	if (def_d++) {
	109	TEST_info("Line %d: multiple double lines", s->curr);
	110	return 0;
	111	}
fba140c7	112	if (OPENSSL_strcasecmp(pp->value, "invalid") != 0) {
9830e7ea P	113	pc->valid_d = 1;
	114	pc->d = strtod(pp->value, &p);
	115	}
	116	} else {
	117	TEST_info("Line %d: unknown keyword %s", s->curr, pp->key);
	118	return 0;
	119	}
	120	if (*p != '\0') {
	121	TEST_info("Line %d: extra characters at end '%s' for %s",
	122	s->curr, p, pp->key);
	123	return 0;
	124	}
	125	}
	126
	127	if (!TEST_ptr(type)) {
	128	TEST_info("Line %d: type not found", s->curr);
	129	return 0;
	130	}
	131
fba140c7	132	if (OPENSSL_strcasecmp(type, "int32") == 0) {
9830e7ea P	133	if (!TEST_true(def_i32) \|\| !TEST_true(pc->valid_i32)) {
	134	TEST_note("errant int32 on line %d", s->curr);
	135	return 0;
	136	}
	137	datum_i32 = ref_i32 = pc->i32;
	138	pc->datum = &datum_i32;
	139	pc->ref = &ref_i32;
	140	pc->size = sizeof(ref_i32);
fba140c7	141	} else if (OPENSSL_strcasecmp(type, "int64") == 0) {
9830e7ea P	142	if (!TEST_true(def_i64) \|\| !TEST_true(pc->valid_i64)) {
	143	TEST_note("errant int64 on line %d", s->curr);
	144	return 0;
	145	}
	146	datum_i64 = ref_i64 = pc->i64;
	147	pc->datum = &datum_i64;
	148	pc->ref = &ref_i64;
	149	pc->size = sizeof(ref_i64);
fba140c7	150	} else if (OPENSSL_strcasecmp(type, "uint32") == 0) {
9830e7ea P	151	if (!TEST_true(def_u32) \|\| !TEST_true(pc->valid_u32)) {
	152	TEST_note("errant uint32 on line %d", s->curr);
	153	return 0;
	154	}
	155	datum_u32 = ref_u32 = pc->u32;
	156	pc->datum = &datum_u32;
	157	pc->ref = &ref_u32;
	158	pc->size = sizeof(ref_u32);
fba140c7	159	} else if (OPENSSL_strcasecmp(type, "uint64") == 0) {
9830e7ea P	160	if (!TEST_true(def_u64) \|\| !TEST_true(pc->valid_u64)) {
	161	TEST_note("errant uint64 on line %d", s->curr);
	162	return 0;
	163	}
	164	datum_u64 = ref_u64 = pc->u64;
	165	pc->datum = &datum_u64;
	166	pc->ref = &ref_u64;
	167	pc->size = sizeof(ref_u64);
fba140c7	168	} else if (OPENSSL_strcasecmp(type, "double") == 0) {
9830e7ea P	169	if (!TEST_true(def_d) \|\| !TEST_true(pc->valid_d)) {
	170	TEST_note("errant double on line %d", s->curr);
	171	return 0;
	172	}
	173	datum_d = ref_d = pc->d;
	174	pc->datum = &datum_d;
	175	pc->ref = &ref_d;
	176	pc->size = sizeof(ref_d);
	177	} else {
	178	TEST_error("type unknown at line %d", s->curr);
	179	return 0;
	180	}
	181	return 1;
	182	}
	183
	184	static int param_conversion_test(const PARAM_CONVERSION *pc, int line)
	185	{
	186	int32_t i32;
	187	int64_t i64;
	188	uint32_t u32;
	189	uint64_t u64;
	190	double d;
	191
	192	if (!pc->valid_i32) {
291c5b3e P	193	if (!TEST_false(OSSL_PARAM_get_int32(pc->param, &i32))
291c5b3e P	194	\|\| !TEST_ulong_ne(ERR_get_error(), 0)) {
9830e7ea P	195	TEST_note("unexpected valid conversion to int32 on line %d", line);
	196	return 0;
	197	}
	198	} else {
	199	if (!TEST_true(OSSL_PARAM_get_int32(pc->param, &i32))
	200	\|\| !TEST_true(i32 == pc->i32)) {
	201	TEST_note("unexpected conversion to int32 on line %d", line);
	202	return 0;
	203	}
	204	memset(pc->datum, 44, pc->size);
	205	if (!TEST_true(OSSL_PARAM_set_int32(pc->param, i32))
	206	\|\| !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
	207	TEST_note("unexpected valid conversion from int32 on line %d",
	208	line);
	209	return 0;
	210	}
	211	}
	212
	213	if (!pc->valid_i64) {
291c5b3e P	214	if (!TEST_false(OSSL_PARAM_get_int64(pc->param, &i64))
291c5b3e P	215	\|\| !TEST_ulong_ne(ERR_get_error(), 0)) {
9830e7ea P	216	TEST_note("unexpected valid conversion to int64 on line %d", line);
	217	return 0;
	218	}
	219	} else {
	220	if (!TEST_true(OSSL_PARAM_get_int64(pc->param, &i64))
	221	\|\| !TEST_true(i64 == pc->i64)) {
	222	TEST_note("unexpected conversion to int64 on line %d", line);
	223	return 0;
	224	}
	225	memset(pc->datum, 44, pc->size);
	226	if (!TEST_true(OSSL_PARAM_set_int64(pc->param, i64))
	227	\|\| !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
	228	TEST_note("unexpected valid conversion from int64 on line %d",
	229	line);
	230	return 0;
	231	}
	232	}
	233
	234	if (!pc->valid_u32) {
291c5b3e P	235	if (!TEST_false(OSSL_PARAM_get_uint32(pc->param, &u32))
291c5b3e P	236	\|\| !TEST_ulong_ne(ERR_get_error(), 0)) {
9830e7ea P	237	TEST_note("unexpected valid conversion to uint32 on line %d", line);
	238	return 0;
	239	}
	240	} else {
	241	if (!TEST_true(OSSL_PARAM_get_uint32(pc->param, &u32))
	242	\|\| !TEST_true(u32 == pc->u32)) {
	243	TEST_note("unexpected conversion to uint32 on line %d", line);
	244	return 0;
	245	}
	246	memset(pc->datum, 44, pc->size);
	247	if (!TEST_true(OSSL_PARAM_set_uint32(pc->param, u32))
	248	\|\| !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
	249	TEST_note("unexpected valid conversion from uint32 on line %d",
	250	line);
	251	return 0;
	252	}
	253	}
	254
	255	if (!pc->valid_u64) {
291c5b3e P	256	if (!TEST_false(OSSL_PARAM_get_uint64(pc->param, &u64))
291c5b3e P	257	\|\| !TEST_ulong_ne(ERR_get_error(), 0)) {
9830e7ea P	258	TEST_note("unexpected valid conversion to uint64 on line %d", line);
	259	return 0;
	260	}
	261	} else {
	262	if (!TEST_true(OSSL_PARAM_get_uint64(pc->param, &u64))
	263	\|\| !TEST_true(u64 == pc->u64)) {
	264	TEST_note("unexpected conversion to uint64 on line %d", line);
	265	return 0;
	266	}
	267	memset(pc->datum, 44, pc->size);
	268	if (!TEST_true(OSSL_PARAM_set_uint64(pc->param, u64))
	269	\|\| !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
	270	TEST_note("unexpected valid conversion from uint64 on line %d",
	271	line);
	272	return 0;
	273	}
	274	}
	275
	276	if (!pc->valid_d) {
291c5b3e P	277	if (!TEST_false(OSSL_PARAM_get_double(pc->param, &d))
291c5b3e P	278	\|\| !TEST_ulong_ne(ERR_get_error(), 0)) {
9830e7ea P	279	TEST_note("unexpected valid conversion to double on line %d", line);
	280	return 0;
	281	}
	282	} else {
09755337 P	283	if (!TEST_true(OSSL_PARAM_get_double(pc->param, &d))) {
	284	TEST_note("unable to convert to double on line %d", line);
	285	return 0;
	286	}
	287	/*
	288	* Check for not a number (NaN) without using the libm functions.
	289	* When d is a NaN, the standard requires d == d to be false.
	290	* It's less clear if d != d should be true even though it generally is.
	291	* Hence we use the equality test and a not.
	292	*/
	293	if (!(d == d)) {
	294	/*
	295	* We've encountered a NaN so check it's really meant to be a NaN.
	296	* We ignore the case where the two values are both different NaN,
	297	* that's not resolvable without knowing the underlying format
	298	* or using libm functions.
	299	*/
	300	if (!TEST_false(pc->d == pc->d)) {
	301	TEST_note("unexpected NaN on line %d", line);
	302	return 0;
	303	}
	304	} else if (!TEST_true(d == pc->d)) {
9830e7ea P	305	TEST_note("unexpected conversion to double on line %d", line);
	306	return 0;
	307	}
	308	memset(pc->datum, 44, pc->size);
	309	if (!TEST_true(OSSL_PARAM_set_double(pc->param, d))
	310	\|\| !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
	311	TEST_note("unexpected valid conversion from double on line %d",
	312	line);
	313	return 0;
	314	}
	315	}
	316
	317	return 1;
	318	}
	319
	320	static int run_param_file_tests(int i)
	321	{
	322	STANZA *s;
	323	PARAM_CONVERSION pc;
	324	const char *testfile = test_get_argument(i);
	325	int res = 1;
	326
	327	if (!TEST_ptr(s = OPENSSL_zalloc(sizeof(*s))))
	328	return 0;
	329	if (!test_start_file(s, testfile)) {
	330	OPENSSL_free(s);
	331	return 0;
	332	}
	333
	334	while (!BIO_eof(s->fp)) {
	335	if (!test_readstanza(s)) {
	336	res = 0;
	337	goto end;
	338	}
	339	if (s->numpairs != 0)
	340	if (!param_conversion_load_stanza(&pc, s)
	341	\|\| !param_conversion_test(&pc, s->curr))
	342	res = 0;
	343	test_clearstanza(s);
	344	}
	345	end:
	346	test_end_file(s);
	347	OPENSSL_free(s);
	348	return res;
	349	}
	350
a1f04782 SL	351	#endif /* OPENSSL_NO_INTTYPES_H */
a1f04782 SL	352
9830e7ea P	353	OPT_TEST_DECLARE_USAGE("file...\n")
	354
	355	int setup_tests(void)
	356	{
8d242823	357	size_t n;
9830e7ea	358
8d242823 MC	359	if (!test_skip_common_options()) {
	360	TEST_error("Error parsing test options\n");
	361	return 0;
	362	}
	363
	364	n = test_get_argument_count();
9830e7ea P	365	if (n == 0)
	366	return 0;
	367
a1f04782	368	#if !defined(OPENSSL_NO_INTTYPES_H)
9830e7ea	369	ADD_ALL_TESTS(run_param_file_tests, n);
a1f04782 SL	370	#endif /* OPENSSL_NO_INTTYPES_H */
a1f04782 SL	371
9830e7ea P	372	return 1;
9830e7ea P	373	}