/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2019 John Baldwin <jhb@FreeBSD.org>
 * Copyright (c) 2025 Dag-Erling Smørgrav <des@FreeBSD.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <atf-c.h>
#include <errno.h>
#include <libutil.h>
#include <stdint.h>

static void
require_success(const char *str, int64_t exp_val)
{
	int64_t val;

	ATF_REQUIRE_MSG(expand_number(str, &val) == 0,
	    "Failed to parse '%s': %m", str);
	ATF_REQUIRE_MSG(val == exp_val,
	    "String '%s' parsed as %jd instead of expected %jd", str,
	    (intmax_t)val, (intmax_t)exp_val);
}

static void
require_error(const char *str, int exp_errno)
{
	int64_t val;

	ATF_REQUIRE_MSG(expand_number(str, &val) == -1,
	    "String '%s' parsed as %jd instead of error", str, (intmax_t)val);
	ATF_REQUIRE_MSG(errno == exp_errno,
	    "String '%s' failed with %d instead of expected %d", str, errno,
	    exp_errno);
}

ATF_TC_WITHOUT_HEAD(expand_number__ok);
ATF_TC_BODY(expand_number__ok, tp)
{
	/* Bare numbers. */
	require_success("-0", 0);
	require_success(" 0", 0);
	require_success("+0", 0);
	require_success("-1", -1);
	require_success(" 1", 1);
	require_success("+1", 1);
	require_success("-10", -10);
	require_success(" 10", 10);
	require_success("+10", 10);

	/* Uppercase suffixes. */
	require_success("1B", 1);
	require_success("1K", 1LL << 10);
	require_success("1M", 1LL << 20);
	require_success("1G", 1LL << 30);
	require_success("1T", 1LL << 40);
	require_success("1P", 1LL << 50);
	require_success("1E", 1LL << 60);

	/* Lowercase suffixes. */
	require_success("2b", 2);
	require_success("2k", 2LL << 10);
	require_success("2m", 2LL << 20);
	require_success("2g", 2LL << 30);
	require_success("2t", 2LL << 40);
	require_success("2p", 2LL << 50);
	require_success("2e", 2LL << 60);

	/* Suffixes with a trailing 'b'. */
	require_success("3KB", 3LL << 10);
	require_success("3MB", 3LL << 20);
	require_success("3GB", 3LL << 30);
	require_success("3TB", 3LL << 40);
	require_success("3PB", 3LL << 50);
	require_success("3EB", 3LL << 60);

	/* Negative numbers. */
	require_success("-1", -1);
	require_success("-10", -10);
	require_success("-1B", -1);
	require_success("-1K", -(1LL << 10));
	require_success("-1M", -(1LL << 20));
	require_success("-1G", -(1LL << 30));
	require_success("-1T", -(1LL << 40));
	require_success("-1P", -(1LL << 50));
	require_success("-1E", -(1LL << 60));
	require_success("-2b", -2);
	require_success("-2k", -(2LL << 10));
	require_success("-2m", -(2LL << 20));
	require_success("-2g", -(2LL << 30));
	require_success("-2t", -(2LL << 40));
	require_success("-2p", -(2LL << 50));
	require_success("-2e", -(2LL << 60));
	require_success("-3KB", -(3LL << 10));
	require_success("-3MB", -(3LL << 20));
	require_success("-3GB", -(3LL << 30));
	require_success("-3TB", -(3LL << 40));
	require_success("-3PB", -(3LL << 50));
	require_success("-3EB", -(3LL << 60));

	/* Maximum values. */
	require_success("7E", 7LL << 60);
	require_success("8191P", 8191LL << 50);
	require_success("8388607T", 8388607LL << 40);
	require_success("8589934591G", 8589934591LL << 30);
	require_success("8796093022207M", 8796093022207LL << 20);
	require_success("9007199254740991K", 9007199254740991LL << 10);
	require_success("9223372036854775807", INT64_MAX);

	/* Minimum values. */
	require_success("-7E", -(7LL << 60));
	require_success("-8191P", -(8191LL << 50));
	require_success("-8388607T", -(8388607LL << 40));
	require_success("-8589934591G", -(8589934591LL << 30));
	require_success("-8796093022207M", -(8796093022207LL << 20));
	require_success("-9007199254740991K", -(9007199254740991LL << 10));
	require_success("-9223372036854775808", INT64_MIN);
}

ATF_TC_WITHOUT_HEAD(expand_number__bad);
ATF_TC_BODY(expand_number__bad, tp)
{
	/* No digits. */
	require_error("", EINVAL);
	require_error("b", EINVAL);
	require_error("k", EINVAL);
	require_error("m", EINVAL);
	require_error("g", EINVAL);
	require_error("t", EINVAL);
	require_error("p", EINVAL);
	require_error("e", EINVAL);
	require_error("-", EINVAL);
	require_error("-b", EINVAL);
	require_error("-k", EINVAL);
	require_error("-m", EINVAL);
	require_error("-g", EINVAL);
	require_error("-t", EINVAL);
	require_error("-p", EINVAL);
	require_error("-e", EINVAL);

	require_error("not_a_number", EINVAL);

	/* Invalid suffixes. */
	require_error("1a", EINVAL);
	require_error("1c", EINVAL);
	require_error("1d", EINVAL);
	require_error("1f", EINVAL);
	require_error("1h", EINVAL);
	require_error("1i", EINVAL);
	require_error("1j", EINVAL);
	require_error("1l", EINVAL);
	require_error("1n", EINVAL);
	require_error("1o", EINVAL);
	require_error("1q", EINVAL);
	require_error("1r", EINVAL);
	require_error("1s", EINVAL);
	require_error("1u", EINVAL);
	require_error("1v", EINVAL);
	require_error("1w", EINVAL);
	require_error("1x", EINVAL);
	require_error("1y", EINVAL);
	require_error("1z", EINVAL);

	/* Trailing garbage. */
	require_error("1K foo", EINVAL);
	require_error("1Mfoo", EINVAL);

	/* Overflow. */
	require_error("8E", ERANGE);
	require_error("8192P", ERANGE);
	require_error("8388608T", ERANGE);
	require_error("8589934592G", ERANGE);
	require_error("8796093022208M", ERANGE);
	require_error("9007199254740992K", ERANGE);
	require_error("9223372036854775808", ERANGE);

	/* Multiple signs */
	require_error("--1", EINVAL);
	require_error("-+1", EINVAL);
	require_error("+-1", EINVAL);
	require_error("++1", EINVAL);

	/* Whitespace after the sign */
	require_error(" - 1", EINVAL);
	require_error(" + 1", EINVAL);
}

ATF_TC_WITHOUT_HEAD(expand_unsigned);
ATF_TC_BODY(expand_unsigned, tp)
{
	static struct tc {
		const char *str;
		uint64_t num;
		int error;
	} tcs[] = {
		{ "0", 0, 0 },
		{ "+0", 0, 0 },
		{ "-0", 0, 0 },
		{ "1", 1, 0 },
		{ "+1", 1, 0 },
		{ "-1", 0, ERANGE },
		{ "18446744073709551615", UINT64_MAX, 0 },
		{ "+18446744073709551615", UINT64_MAX, 0 },
		{ "-18446744073709551615", 0, ERANGE },
		{ 0 },
	};
	struct tc *tc;
	uint64_t num;
	int error, ret;

	for (tc = tcs; tc->str != NULL; tc++) {
		ret = expand_number(tc->str, &num);
		error = errno;
		if (tc->error == 0) {
			ATF_REQUIRE_EQ_MSG(0, ret,
			    "%s ret = %d", tc->str, ret);
			ATF_REQUIRE_EQ_MSG(tc->num, num,
			    "%s num = %ju", tc->str, (uintmax_t)num);
		} else {
			ATF_REQUIRE_EQ_MSG(-1, ret,
			    "%s ret = %d", tc->str, ret);
			ATF_REQUIRE_EQ_MSG(tc->error, error,
			    "%s errno = %d", tc->str, error);
		}
	}
}

ATF_TC_WITHOUT_HEAD(expand_generic);
ATF_TC_BODY(expand_generic, tp)
{
	uint64_t uint64;
	int64_t int64;
#ifdef __LP64__
	size_t size;
#endif
	off_t off;

	ATF_REQUIRE_EQ(0, expand_number("18446744073709551615", &uint64));
	ATF_REQUIRE_EQ(UINT64_MAX, uint64);
	ATF_REQUIRE_EQ(-1, expand_number("-1", &uint64));
	ATF_REQUIRE_EQ(ERANGE, errno);

	ATF_REQUIRE_EQ(0, expand_number("9223372036854775807", &int64));
	ATF_REQUIRE_EQ(INT64_MAX, int64);
	ATF_REQUIRE_EQ(-1, expand_number("9223372036854775808", &int64));
	ATF_REQUIRE_EQ(ERANGE, errno);
	ATF_REQUIRE_EQ(0, expand_number("-9223372036854775808", &int64));
	ATF_REQUIRE_EQ(INT64_MIN, int64);

#ifdef __LP64__
	ATF_REQUIRE_EQ(0, expand_number("18446744073709551615", &size));
	ATF_REQUIRE_EQ(UINT64_MAX, size);
	ATF_REQUIRE_EQ(-1, expand_number("-1", &size));
	ATF_REQUIRE_EQ(ERANGE, errno);
#endif

	ATF_REQUIRE_EQ(0, expand_number("9223372036854775807", &off));
	ATF_REQUIRE_EQ(INT64_MAX, off);
	ATF_REQUIRE_EQ(-1, expand_number("9223372036854775808", &off));
	ATF_REQUIRE_EQ(ERANGE, errno);
	ATF_REQUIRE_EQ(0, expand_number("-9223372036854775808", &off));
	ATF_REQUIRE_EQ(INT64_MIN, off);
}

ATF_TP_ADD_TCS(tp)
{
	ATF_TP_ADD_TC(tp, expand_number__ok);
	ATF_TP_ADD_TC(tp, expand_number__bad);
	ATF_TP_ADD_TC(tp, expand_unsigned);
	ATF_TP_ADD_TC(tp, expand_generic);

	return (atf_no_error());
}