FxLibcTest/src/stdlib/intconv.c

#include <stdlib.h>
#include <limits.h>
#include <errno.h>

#include <ft/test.h>
#include <ft/all-tests.h>

/* All these macros have free variables "func" and "format". */

/* Assert that converting (string) gives (result) with (errno == 0). */
#define assert_conv(string, result) { \
	errno = 0; \
	ft_assert_eval(t, func(string, NULL, 0), result, format); \
	ft_assert(t, errno == 0); \
}
/* Same with a custom base. */
#define assert_conv_base(string, base, result) { \
	errno = 0; \
	ft_assert_eval(t, func(string, NULL, base), result, format); \
	ft_assert(t, errno == 0); \
}
/* Assert that converting (string) gives (errno == error). */
#define assert_errno(string, error) { \
	errno = 0; \
	ft_log(t, string " should be errno " #error "\n"); \
	func(string, NULL, 0); \
	ft_assert(t, errno == error); \
}
/* Assert that converting (string) sets (endptr == string + distance). */
#define assert_end(string, base, distance) { \
	char const *_str = string; \
	char *_end; \
	ft_log(t, string " (base " #base ") should read " #distance "\n"); \
	func(_str, &_end, base); \
	ft_assert(t, _end - _str == distance); \
}

static void _ft_stdlib_llconv(ft_test *t)
{
	#define func strtoull
	#define format "%llu"

	ft_log(t, "--- strtoull ---\n");

	ft_log(t, "\nSimple unsigned decimal:\n");
	assert_conv("73", 73ull);
	assert_conv("0", 0ull);
	assert_conv("  1729", 1729ull);
	assert_conv("18446744073709551615", 18446744073709551615ull);

	ft_log(t, "\nOverflow situations:\n");
	assert_errno("18446744073709551616", ERANGE);
	assert_errno("-0", 0);
	assert_errno("-1", ERANGE);
	assert_errno("-73", ERANGE);
	assert_errno("-18446744073709551616", ERANGE);
	assert_errno("0xffffffffffffffff", 0);
	assert_errno("0x10000000000000001", ERANGE);

	ft_log(t, "\nBase detection:\n");
	assert_conv_base("0101", 0, 65ull);
	assert_conv_base("0x101", 0, 257ull);
	assert_conv_base("0X101", 0, 257ull);
	assert_conv_base("0101", 8, 65ull);
	assert_conv_base("0x101", 16, 257ull);
	assert_conv_base("0X101", 16, 257ull);

	ft_log(t, "\nGeneral bases:\n");
	assert_conv_base("01001001", 2, 73ull);
	assert_conv_base("257", 16, 599ull);
	assert_conv_base("fxlibc", 33, 15ull);
	assert_conv_base("fxlibc", 34, 726477026ull);
	assert_conv_base("fxlibc", 35, 838271572ull);
	assert_conv_base("fxlibc", 36, 963423480ull);

	ft_log(t, "\nEnd pointer for valid cases:\n");
	assert_end("    987", 0, 7);
	assert_end("73_test", 0, 2);
	assert_end("0xdeadbeef404te3", 16, 13);
	assert_end("-0109637", 0, 4);
	assert_end("-109637", 0, 7);
	assert_end("73dec", 0, 2);
	assert_end("7891", 8, 1);

	ft_log(t, "\nEnd pointer for invalid cases:\n");
	assert_end("-!!", 0, 0);
	assert_end("-0xk", 0, 0);
	assert_end("", 16, 0);
	assert_end("891", 8, 0);
	assert_end("-891", 8, 0);
	assert_end("fxlibc", 0, 0);
	assert_end("  ++", 0, 0);

	#undef func
	#undef format
	#define func strtoll
	#define format "%lld"

	ft_log(t, "\n--- strtoll ---\n");

	ft_log(t, "\nSimple signed decimal:\n");
	assert_conv("73", 73ll);
	assert_conv("-73", -73ll);
	assert_conv("0", 0ll);
	assert_conv("-0", 0ll);
	assert_conv("-1729", -1729ll);
	assert_conv("9223372036854775807", 9223372036854775807ll);
	assert_conv("-9223372036854775808", -9223372036854775807ll-1);

	ft_log(t, "\nOverflow situations:\n");
	assert_errno("9223372036854775807", 0);
	assert_errno("9223372036854775808", ERANGE);
	assert_errno("-9223372036854775807", 0);
	assert_errno("-9223372036854775808", 0);
	assert_errno("-9223372036854775809", ERANGE);

	ft_log(t, "\nGeneral base for negative values:\n");
	assert_conv_base(" -0x37", 16, -55ll);
	assert_conv_base(" -0x37", 0, -55ll);
	assert_conv_base("-00080", 8, 0ll);
	assert_conv_base("-00080", 0, 0ll);
	assert_conv_base("-fxlibc", 34, -726477026ll);
}

ft_test ft_stdlib_llconv = {
	.name = "long long conversion",
	.function = _ft_stdlib_llconv,
};

static void _ft_stdlib_lconv(ft_test *t)
{
	ft_log(t, "See also: long long conversion\n");

	#undef func
	#undef format
	#define func strtoul
	#define format "%lu"

	ft_log(t, "\n--- strtoul ---\n");

	ft_log(t, "\nSimple unsigned decimal:\n");
	assert_conv("73", 73ul);
	assert_conv("0", 0ul);
	assert_conv("  1729", 1729ul);
	assert_conv("4294967295", 4294967295ul);

	ft_log(t, "\nOverflow situations:\n");
	assert_errno("4294967296", ERANGE);
	assert_errno("-0", 0);
	assert_errno("-1", ERANGE);
	assert_errno("-73", ERANGE);
	assert_errno("-4294967296", ERANGE);
	assert_errno("0xffffffff", 0);
	assert_errno("0x100000001", ERANGE);

	#undef func
	#undef format
	#define func strtol
	#define format "%ld"

	ft_log(t, "\n--- strtol ---\n");

	ft_log(t, "\nSimple signed decimal:\n");
	assert_conv("73", 73l);
	assert_conv("-73", -73l);
	assert_conv("0", 0l);
	assert_conv("-0", 0l);
	assert_conv("-1729", -1729l);
	assert_conv("2147483647", 2147483647l);
	assert_conv("-2147483648", -2147483647l-1);

	ft_log(t, "\nOverflow situations:\n");
	assert_errno("2147483647", 0);
	assert_errno("2147483648", ERANGE);
	assert_errno("-2147483647", 0);
	assert_errno("-2147483648", 0);
	assert_errno("-2147483649", ERANGE);
}

ft_test ft_stdlib_lconv = {
	.name = "long conversion",
	.function = _ft_stdlib_lconv,
};