/*
 * Copyright (c) 2026 Faraz Vahedi <kfv@kfv.io>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

/*
 * Tests for strfromd(3), strfromf(3), and strfroml(3).
 *
 * C23 §7.24.1.3 states that these functions are equivalent to snprintf(3),
 * albeit with some subtle exceptions, and therefore snprintf(3) is used as
 * the correctness oracle.  Hardcoded string checks guard against both
 * producing the same wrong answer.
 */

#include <errno.h>
#include <float.h>
#include <locale.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <atf-c.h>

/*
 * Buffer large enough for any finite value in %f form, including LDBL_MAX on
 * platforms with 80-bit or 128-bit long double.  Sizing for the full output
 * keeps the snprintf(3) oracle a full-length comparison rather than letting
 * both sides truncate alike.
 */
#define	FBUF	8192

static void
check_d(const char *fmt, double val)
{
	char got[FBUF], ref[FBUF];
	int rlen, glen;

	rlen = snprintf(ref, sizeof(ref), fmt, val);
	glen = strfromd(got, sizeof(got), fmt, val);
	ATF_CHECK_MSG(glen == rlen,
	    "strfromd(\"%s\", %g): return %d, want %d", fmt, val, glen, rlen);
	ATF_CHECK_STREQ_MSG(ref, got, "strfromd(\"%s\", %g)", fmt, val);
}

static void
check_f(const char *fmt, float val)
{
	char got[FBUF], ref[FBUF];
	int rlen, glen;

	rlen = snprintf(ref, sizeof(ref), fmt, (double)val);
	glen = strfromf(got, sizeof(got), fmt, val);
	ATF_CHECK_MSG(glen == rlen,
	    "strfromf(\"%s\", %g): return %d, want %d",
	    fmt, (double)val, glen, rlen);
	ATF_CHECK_STREQ_MSG(ref, got, "strfromf(\"%s\", %g)", fmt, (double)val);
}

static void
check_l(const char *fmt, long double val)
{
	char got[FBUF], ref[FBUF], lfmt[32];
	int rlen, glen;

	/*
	 * snprintf requires the 'L' length modifier for long double.
	 */
	snprintf(lfmt, sizeof(lfmt), "%.*sL%c",
	    (int)(strlen(fmt) - 1), fmt, fmt[strlen(fmt) - 1]);
	rlen = snprintf(ref, sizeof(ref), lfmt, val);
	glen = strfroml(got, sizeof(got), fmt, val);
	ATF_CHECK_MSG(glen == rlen,
	    "strfroml(\"%s\", %Lg): return %d, want %d", fmt, val, glen, rlen);
	ATF_CHECK_STREQ_MSG(ref, got, "strfroml(\"%s\", %Lg)", fmt, val);
}

ATF_TC_WITHOUT_HEAD(strfromd_f);
ATF_TC_BODY(strfromd_f, tc)
{
	char buf[FBUF];

	check_d("%f", 0.0);
	check_d("%f", 1.0);
	check_d("%f", -1.0);
	check_d("%f", 3.14159265358979);
	check_d("%f", 1.0 / 3.0);
	check_d("%f", 1e10);
	check_d("%f", 1e-10);
	check_d("%f", DBL_MAX);
	check_d("%f", DBL_MIN);
	check_d("%.0f", 3.14);
	check_d("%.0f", 3.5);
	check_d("%.0f", 4.5);
	check_d("%.2f", 3.14159);
	check_d("%.10f", 1.0 / 7.0);
	check_d("%.20f", 1.0);

	strfromd(buf, sizeof(buf), "%.6f", 0.0);
	ATF_CHECK_STREQ("0.000000", buf);
	strfromd(buf, sizeof(buf), "%.6f", -1.5);
	ATF_CHECK_STREQ("-1.500000", buf);
}

ATF_TC_WITHOUT_HEAD(strfromd_e);
ATF_TC_BODY(strfromd_e, tc)
{
	char buf[FBUF];

	check_d("%e", 0.0);
	check_d("%e", 1.0);
	check_d("%e", -1.0);
	check_d("%e", 3.14159265358979);
	check_d("%e", 1e100);
	check_d("%e", 1e-100);
	check_d("%E", 2.718281828);
	check_d("%.0e", 3.14);
	check_d("%.2e", 12345.6789);
	check_d("%.15e", 1.0 / 3.0);

	strfromd(buf, sizeof(buf), "%e", 1.0);
	ATF_CHECK_STREQ("1.000000e+00", buf);
	strfromd(buf, sizeof(buf), "%E", 1.0);
	ATF_CHECK_STREQ("1.000000E+00", buf);
}

ATF_TC_WITHOUT_HEAD(strfromd_g);
ATF_TC_BODY(strfromd_g, tc)
{
	char buf[FBUF];

	check_d("%g", 0.0);
	check_d("%g", 1.0);
	check_d("%g", 100000.0);
	check_d("%g", 1000000.0);        /* exponent >= prec:   hence %e */
	check_d("%g", 0.0001);           /* exponent == -4:     hence %f */
	check_d("%g", 0.00001);          /* exponent < -4:      hence %e */
	check_d("%g", 3.14159265358979);
	check_d("%G", 1.23e10);
	check_d("%.2g", 3.14159);
	check_d("%.0g", 3.14159);
	check_d("%.10g", 1.0 / 7.0);
	check_d("%g", DBL_MIN);
	check_d("%g", DBL_MAX);

	strfromd(buf, sizeof(buf), "%g", 1.0);
	ATF_CHECK_STREQ("1", buf);
	strfromd(buf, sizeof(buf), "%g", 100.0);
	ATF_CHECK_STREQ("100", buf);
}

ATF_TC_WITHOUT_HEAD(strfromd_a);
ATF_TC_BODY(strfromd_a, tc)
{
	char buf[FBUF];

	check_d("%a", 0.0);
	check_d("%a", 1.0);
	check_d("%a", -1.0);
	check_d("%a", 0.5);
	check_d("%a", 1.5);
	check_d("%a", DBL_MIN);
	check_d("%a", DBL_MAX);
	check_d("%A", 1.0);
	check_d("%.4a", 1.0 / 3.0);
	check_d("%.0a", 1.5);

	strfromd(buf, sizeof(buf), "%a", 1.0);
	ATF_CHECK_STREQ("0x1p+0", buf);
	strfromd(buf, sizeof(buf), "%a", 0.5);
	ATF_CHECK_STREQ("0x1p-1", buf);
	strfromd(buf, sizeof(buf), "%A", 1.0);
	ATF_CHECK_STREQ("0X1P+0", buf);
}

ATF_TC_WITHOUT_HEAD(strfromd_special);
ATF_TC_BODY(strfromd_special, tc)
{
	char buf[FBUF];

	check_d("%f", INFINITY);
	check_d("%f", -INFINITY);
	check_d("%f", NAN);
	check_d("%e", INFINITY);
	check_d("%e", -INFINITY);
	check_d("%e", NAN);
	check_d("%g", INFINITY);
	check_d("%g", -INFINITY);
	check_d("%g", NAN);
	check_d("%a", INFINITY);
	check_d("%a", -INFINITY);
	check_d("%a", NAN);
	check_d("%F", INFINITY);
	check_d("%E", INFINITY);
	check_d("%G", INFINITY);
	check_d("%A", INFINITY);
	check_d("%f", -0.0);
	check_d("%g", -0.0);
	check_d("%e", -0.0);
	check_d("%a", -0.0);

	strfromd(buf, sizeof(buf), "%f", INFINITY);
	ATF_CHECK_STREQ("inf", buf);
	strfromd(buf, sizeof(buf), "%F", INFINITY);
	ATF_CHECK_STREQ("INF", buf);
	strfromd(buf, sizeof(buf), "%f", -INFINITY);
	ATF_CHECK_STREQ("-inf", buf);
	strfromd(buf, sizeof(buf), "%f", NAN);
	ATF_CHECK_STREQ("nan", buf);
	strfromd(buf, sizeof(buf), "%F", NAN);
	ATF_CHECK_STREQ("NAN", buf);
}

ATF_TC_WITHOUT_HEAD(strfromd_truncation);
ATF_TC_BODY(strfromd_truncation, tc)
{
	char buf[FBUF];
	int ret;

	/*
	 * When n == 0 the buffer must not be touched and the return value
	 * must still reflect the full output length.
	 */
	buf[0] = 'X';
	ret = strfromd(buf, 0, "%f", 1.0);
	ATF_CHECK(ret > 0);
	ATF_CHECK_MSG(buf[0] == 'X', "buffer modified with n==0");

	/*
	 * With a short buffer, a null terminated prefix is written and the
	 * return value is the length that would have been needed.
	 */
	ret = strfromd(buf, 5, "%.6f", 1.0);
	ATF_CHECK_MSG(ret == 8, "return %d, want 8", ret);
	ATF_CHECK_MSG(buf[4] == '\0', "not null terminated at buf[4]");
	ATF_CHECK_MSG(strncmp(buf, "1.00", 4) == 0,
	    "prefix mismatch: got \"%.*s\"", 4, buf);
}

ATF_TC_WITHOUT_HEAD(strfromf_f);
ATF_TC_BODY(strfromf_f, tc)
{
	check_f("%f", 0.0f);
	check_f("%f", 1.0f);
	check_f("%f", -1.0f);
	check_f("%f", 3.14159f);
	check_f("%.0f", 3.5f);
	check_f("%.2f", 3.14159f);
	check_f("%.9f", 1.0f / 3.0f);
	check_f("%f", FLT_MAX);
	check_f("%f", FLT_MIN);
}

ATF_TC_WITHOUT_HEAD(strfromf_e);
ATF_TC_BODY(strfromf_e, tc)
{
	char buf[FBUF];

	check_f("%e", 0.0f);
	check_f("%e", 1.0f);
	check_f("%e", -1.0f);
	check_f("%e", 3.14159f);
	check_f("%E", 2.71828f);
	check_f("%.2e", 12345.6f);
	check_f("%.0e", 3.14f);

	strfromf(buf, sizeof(buf), "%e", 1.0f);
	ATF_CHECK_STREQ("1.000000e+00", buf);
}

ATF_TC_WITHOUT_HEAD(strfromf_g);
ATF_TC_BODY(strfromf_g, tc)
{
	char buf[FBUF];

	check_f("%g", 0.0f);
	check_f("%g", 1.0f);
	check_f("%g", 100000.0f);
	check_f("%g", 1000000.0f);
	check_f("%g", 0.0001f);
	check_f("%g", 0.00001f);
	check_f("%G", 1.23e10f);
	check_f("%.2g", 3.14159f);

	strfromf(buf, sizeof(buf), "%g", 1.0f);
	ATF_CHECK_STREQ("1", buf);
}

ATF_TC_WITHOUT_HEAD(strfromf_a);
ATF_TC_BODY(strfromf_a, tc)
{
	char buf[FBUF];

	check_f("%a", 0.0f);
	check_f("%a", 1.0f);
	check_f("%a", 0.5f);
	check_f("%a", -1.0f);
	check_f("%A", 1.0f);
	check_f("%.2a", 1.0f / 3.0f);

	strfromf(buf, sizeof(buf), "%a", 1.0f);
	ATF_CHECK_STREQ("0x1p+0", buf);
}

ATF_TC_WITHOUT_HEAD(strfromf_special);
ATF_TC_BODY(strfromf_special, tc)
{
	check_f("%f", INFINITY);
	check_f("%f", -INFINITY);
	check_f("%f", NAN);
	check_f("%e", INFINITY);
	check_f("%g", INFINITY);
	check_f("%a", INFINITY);
	check_f("%F", INFINITY);
	check_f("%f", -0.0f);
	check_f("%g", -0.0f);
}

ATF_TC_WITHOUT_HEAD(strfromf_truncation);
ATF_TC_BODY(strfromf_truncation, tc)
{
	char buf[FBUF];
	int ret;

	buf[0] = 'X';
	ret = strfromf(buf, 0, "%f", 1.0f);
	ATF_CHECK(ret > 0);
	ATF_CHECK_MSG(buf[0] == 'X', "buffer modified with n==0");

	ret = strfromf(buf, 5, "%.6f", 1.0f);
	ATF_CHECK_MSG(ret == 8, "return %d, want 8", ret);
	ATF_CHECK_MSG(buf[4] == '\0', "not null terminated at buf[4]");
}

ATF_TC_WITHOUT_HEAD(strfroml_f);
ATF_TC_BODY(strfroml_f, tc)
{
	check_l("%f", 0.0L);
	check_l("%f", 1.0L);
	check_l("%f", -1.0L);
	check_l("%f", 3.14159265358979323846L);
	check_l("%.0f", 3.5L);
	check_l("%.2f", 3.14159L);
	check_l("%.15f", 1.0L / 3.0L);
	check_l("%f", LDBL_MAX);
	check_l("%f", LDBL_MIN);
}

ATF_TC_WITHOUT_HEAD(strfroml_e);
ATF_TC_BODY(strfroml_e, tc)
{
	char buf[FBUF];

	check_l("%e", 0.0L);
	check_l("%e", 1.0L);
	check_l("%e", -1.0L);
	check_l("%e", 3.14159265358979323846L);
	check_l("%E", 2.71828182845904523536L);
	check_l("%.2e", 12345.6789L);
	check_l("%.0e", 3.14L);
	check_l("%e", LDBL_MAX);
	check_l("%e", LDBL_MIN);

	strfroml(buf, sizeof(buf), "%e", 1.0L);
	ATF_CHECK_STREQ("1.000000e+00", buf);
}

ATF_TC_WITHOUT_HEAD(strfroml_g);
ATF_TC_BODY(strfroml_g, tc)
{
	char buf[FBUF];

	check_l("%g", 0.0L);
	check_l("%g", 1.0L);
	check_l("%g", 100000.0L);
	check_l("%g", 1000000.0L);
	check_l("%g", 0.0001L);
	check_l("%g", 0.00001L);
	check_l("%G", 1.23e10L);
	check_l("%.2g", 3.14159L);
	check_l("%.0g", 3.14159L);

	strfroml(buf, sizeof(buf), "%g", 1.0L);
	ATF_CHECK_STREQ("1", buf);
}

ATF_TC_WITHOUT_HEAD(strfroml_a);
ATF_TC_BODY(strfroml_a, tc)
{
	char buf[FBUF];

	check_l("%a", 0.0L);
	check_l("%a", 1.0L);
	check_l("%a", 0.5L);
	check_l("%a", -1.0L);
	check_l("%A", 1.0L);
	check_l("%.4a", 1.0L / 3.0L);
	check_l("%.0a", 1.5L);
	check_l("%a", LDBL_MAX);
	check_l("%a", LDBL_MIN);

	strfroml(buf, sizeof(buf), "%a", 1.0L);
	ATF_CHECK_STREQ("0x1p+0", buf);
}

ATF_TC_WITHOUT_HEAD(strfroml_special);
ATF_TC_BODY(strfroml_special, tc)
{
	check_l("%f", INFINITY);
	check_l("%f", -INFINITY);
	check_l("%f", NAN);
	check_l("%e", INFINITY);
	check_l("%g", INFINITY);
	check_l("%a", INFINITY);
	check_l("%F", INFINITY);
	check_l("%f", -0.0L);
	check_l("%g", -0.0L);
#ifdef __HAVE_LONG_DOUBLE
	check_l("%.20f", 1.0L / 3.0L);
	check_l("%.20e", 1.0L / 7.0L);
#endif
}

ATF_TC_WITHOUT_HEAD(strfroml_truncation);
ATF_TC_BODY(strfroml_truncation, tc)
{
	char buf[FBUF];
	int ret;

	buf[0] = 'X';
	ret = strfroml(buf, 0, "%f", 1.0L);
	ATF_CHECK(ret > 0);
	ATF_CHECK_MSG(buf[0] == 'X', "buffer modified with n==0");

	ret = strfroml(buf, 5, "%.6f", 1.0L);
	ATF_CHECK_MSG(ret == 8, "return %d, want 8", ret);
	ATF_CHECK_MSG(buf[4] == '\0', "not null terminated at buf[4]");
}

ATF_TC_WITHOUT_HEAD(strfrom_locale);
ATF_TC_BODY(strfrom_locale, tc)
{
	char buf[FBUF];

	/*
	 * strfrom* is equivalent to snprintf(3) and so honours LC_NUMERIC:
	 * In a locale whose radix is not '.', the output must use that radix.
	 * The check_* helpers already compare against snprintf in this locale;
	 * the literal checks confirm the radix actually changed for both the
	 * decimal and hexadecimal paths.  Skip if the locale is unavailable.
	 */
	if (setlocale(LC_NUMERIC, "de_DE.UTF-8") == NULL)
		atf_tc_skip("de_DE.UTF-8 locale not available");

	check_d("%f", 1.5);
	check_d("%e", 1.5);
	check_d("%g", 1.5);
	check_d("%a", 1.5);
	check_f("%f", 1.5f);
	check_l("%f", 1.5L);

	strfromd(buf, sizeof(buf), "%.1f", 1.5);
	ATF_CHECK_STREQ("1,5", buf);
	strfromd(buf, sizeof(buf), "%a", 1.5);
	ATF_CHECK_STREQ("0x1,8p+0", buf);
}

/*
 * Per C23 §7.24.1.3p2, format string outside the restricted grammar is
 * undefined behaviour.  FreeBSD reports it as the programming error it
 * is; the conversion yields "EDOOFUS" and sets errno accordingly.
 */
static void
check_edoofus(const char *fmt, int ret, const char *buf)
{
	ATF_CHECK_MSG(ret == 7, "%s: return %d, want 7", fmt, ret);
	ATF_CHECK_STREQ_MSG("EDOOFUS", buf, "%s: got \"%s\"", fmt, buf);
	ATF_CHECK_MSG(errno == EDOOFUS, "%s: errno %d, want %d", fmt, errno,
	    EDOOFUS);
}

ATF_TC_WITHOUT_HEAD(strfrom_empty_format);
ATF_TC_BODY(strfrom_empty_format, tc)
{
	char buf[FBUF];
	int ret;

	errno = 0;
	ret = strfromd(buf, sizeof(buf), "", 1.0);
	check_edoofus("", ret, buf);
}

ATF_TC_WITHOUT_HEAD(strfrom_bad_specifier);
ATF_TC_BODY(strfrom_bad_specifier, tc)
{
	char buf[FBUF];
	int ret;

	errno = 0;
	ret = strfromd(buf, sizeof(buf), "%q", 1.0);
	check_edoofus("%q", ret, buf);

	errno = 0;
	ret = strfromf(buf, sizeof(buf), "%.2q", 1.0f);
	check_edoofus("%.2q", ret, buf);

	errno = 0;
	ret = strfroml(buf, sizeof(buf), "%", 1.0L);
	check_edoofus("%", ret, buf);

	errno = 0;
	ret = strfromd(buf, sizeof(buf), "f", 1.0);
	check_edoofus("f", ret, buf);

	errno = 0;
	ret = strfromd(buf, sizeof(buf), "%*f", 1.0);
	check_edoofus("%*f", ret, buf);

	errno = 0;
	ret = strfromd(buf, sizeof(buf), "%f ", 1.0);
	check_edoofus("%f ", ret, buf);
}

ATF_TC_WITHOUT_HEAD(strfrom_bad_format_truncation);
ATF_TC_BODY(strfrom_bad_format_truncation, tc)
{
	char buf[FBUF];
	int ret;

	/* The error string obeys the snprintf(3) truncation rules. */
	buf[0] = 'X';
	errno = 0;
	ret = strfromd(buf, 0, "%q", 1.0);
	ATF_CHECK_MSG(ret == 7, "return %d, want 7", ret);
	ATF_CHECK_MSG(buf[0] == 'X', "buffer modified with n==0");
	ATF_CHECK_EQ(EDOOFUS, errno);

	errno = 0;
	ret = strfromd(buf, 4, "%q", 1.0);
	ATF_CHECK_MSG(ret == 7, "return %d, want 7", ret);
	ATF_CHECK_STREQ("EDO", buf);
	ATF_CHECK_EQ(EDOOFUS, errno);
}

ATF_TC_WITHOUT_HEAD(strfrom_errno_preserved);
ATF_TC_BODY(strfrom_errno_preserved, tc)
{
	char buf[FBUF];

	errno = 0;
	strfromd(buf, sizeof(buf), "%f", 1.0);
	ATF_CHECK_EQ(0, errno);
	strfromf(buf, sizeof(buf), "%a", 1.0f);
	ATF_CHECK_EQ(0, errno);
	strfroml(buf, sizeof(buf), "%.3g", 1.0L);
	ATF_CHECK_EQ(0, errno);
}

ATF_TP_ADD_TCS(tp)
{
	ATF_TP_ADD_TC(tp, strfromd_f);
	ATF_TP_ADD_TC(tp, strfromd_e);
	ATF_TP_ADD_TC(tp, strfromd_g);
	ATF_TP_ADD_TC(tp, strfromd_a);
	ATF_TP_ADD_TC(tp, strfromd_special);
	ATF_TP_ADD_TC(tp, strfromd_truncation);

	ATF_TP_ADD_TC(tp, strfromf_f);
	ATF_TP_ADD_TC(tp, strfromf_e);
	ATF_TP_ADD_TC(tp, strfromf_g);
	ATF_TP_ADD_TC(tp, strfromf_a);
	ATF_TP_ADD_TC(tp, strfromf_special);
	ATF_TP_ADD_TC(tp, strfromf_truncation);

	ATF_TP_ADD_TC(tp, strfroml_f);
	ATF_TP_ADD_TC(tp, strfroml_e);
	ATF_TP_ADD_TC(tp, strfroml_g);
	ATF_TP_ADD_TC(tp, strfroml_a);
	ATF_TP_ADD_TC(tp, strfroml_special);
	ATF_TP_ADD_TC(tp, strfroml_truncation);

	ATF_TP_ADD_TC(tp, strfrom_locale);
	ATF_TP_ADD_TC(tp, strfrom_empty_format);
	ATF_TP_ADD_TC(tp, strfrom_bad_specifier);
	ATF_TP_ADD_TC(tp, strfrom_bad_format_truncation);
	ATF_TP_ADD_TC(tp, strfrom_errno_preserved);

	return (atf_no_error());
}