// SPDX-License-Identifier: LGPL-2.1+

/*

 * Copyright (C) 2018 Red Hat, Inc.

 */

#define NM_TEST_UTILS_NO_LIBNM 1

#include "nm-default.h"

#include "nm-std-aux/unaligned.h"

#include "nm-glib-aux/nm-random-utils.h"

#include "nm-glib-aux/nm-str-buf.h"

#include "nm-glib-aux/nm-time-utils.h"

#include "nm-glib-aux/nm-ref-string.h"

#include "nm-utils/nm-test-utils.h"

/*****************************************************************************/

static void

test_gpid (void)

{

	const int *int_ptr;

	GPid pid = 42;

	/* We redefine G_PID_FORMAT, because it's only available since glib 2.53.5.

	 *

	 * Also, this is the format for GPid, which for glib is always a typedef

	 * for "int". Add a check for that here.

	 *

	 * G_PID_FORMAT is not about pid_t, which might be a smaller int, and which we would

	 * check with SIZEOF_PID_T. */

	G_STATIC_ASSERT (sizeof (GPid) == sizeof (int));

	g_assert_cmpstr (""G_PID_FORMAT, ==, "i");

	/* check that it's really "int". We will get a compiler warning, if that's not

	 * the case. */

	int_ptr = &pid;

	g_assert_cmpint (*int_ptr, ==, 42);

}

/*****************************************************************************/

static void

test_monotonic_timestamp (void)

{

	g_assert (nm_utils_get_monotonic_timestamp_sec () > 0);

}

/*****************************************************************************/

static void

test_nmhash (void)

{

	int rnd;

	nm_utils_random_bytes (&rnd, sizeof (rnd));

	g_assert (nm_hash_val (555, 4) != 0);

}

/*****************************************************************************/

static const char *

_make_strv_foo (void)

{

	return "foo";

}

static const char *const*const _tst_make_strv_1 = NM_MAKE_STRV ("1", "2");

static void

test_make_strv (void)

{

	const char *const*v1a = NM_MAKE_STRV ("a");

	const char *const*v1b = NM_MAKE_STRV ("a", );

	const char *const*v2a = NM_MAKE_STRV ("a", "b");

	const char *const*v2b = NM_MAKE_STRV ("a", "b", );

	const char *const v3[] = { "a", "b", };

	const char *const*v4b = NM_MAKE_STRV ("a", _make_strv_foo (), );

	g_assert (NM_PTRARRAY_LEN (v1a) == 1);

	g_assert (NM_PTRARRAY_LEN (v1b) == 1);

	g_assert (NM_PTRARRAY_LEN (v2a) == 2);

	g_assert (NM_PTRARRAY_LEN (v2b) == 2);

	g_assert (NM_PTRARRAY_LEN (_tst_make_strv_1) == 2);

	g_assert_cmpstr (_tst_make_strv_1[0], ==, "1");

	g_assert_cmpstr (_tst_make_strv_1[1], ==, "2");

	/* writing the static read-only variable leads to crash .*/

	//((char **) _tst_make_strv_1)[0] = NULL;

	//((char **) _tst_make_strv_1)[2] = "c";

	G_STATIC_ASSERT_EXPR (G_N_ELEMENTS (v3) == 2);

	g_assert (NM_PTRARRAY_LEN (v4b) == 2);

	G_STATIC_ASSERT_EXPR (G_N_ELEMENTS (NM_MAKE_STRV ("a", "b"  )) == 3);

	G_STATIC_ASSERT_EXPR (G_N_ELEMENTS (NM_MAKE_STRV ("a", "b", )) == 3);

	nm_strquote_a (300, "");

}

/*****************************************************************************/

typedef enum {

	TEST_NM_STRDUP_ENUM_m1 = -1,

	TEST_NM_STRDUP_ENUM_3  = 3,

} TestNMStrdupIntEnum;

static void

test_nm_strdup_int (void)

{

#define _NM_STRDUP_INT_TEST(num, str) \

	G_STMT_START { \

		gs_free char *_s1 = NULL; \

		\

		_s1 = nm_strdup_int ((num)); \

		\

		g_assert (_s1); \

		g_assert_cmpstr (_s1, ==, str); \

	} G_STMT_END

#define _NM_STRDUP_INT_TEST_TYPED(type, num) \

	G_STMT_START { \

		type _num = ((type) num); \

		\

		_NM_STRDUP_INT_TEST (_num, G_STRINGIFY (num)); \

	} G_STMT_END

	_NM_STRDUP_INT_TEST_TYPED (char, 0);

	_NM_STRDUP_INT_TEST_TYPED (char, 1);

	_NM_STRDUP_INT_TEST_TYPED (guint8, 0);

	_NM_STRDUP_INT_TEST_TYPED (gint8, 25);

	_NM_STRDUP_INT_TEST_TYPED (char, 47);

	_NM_STRDUP_INT_TEST_TYPED (short, 47);

	_NM_STRDUP_INT_TEST_TYPED (int, 47);

	_NM_STRDUP_INT_TEST_TYPED (long, 47);

	_NM_STRDUP_INT_TEST_TYPED (unsigned char, 47);

	_NM_STRDUP_INT_TEST_TYPED (unsigned short, 47);

	_NM_STRDUP_INT_TEST_TYPED (unsigned, 47);

	_NM_STRDUP_INT_TEST_TYPED (unsigned long, 47);

	_NM_STRDUP_INT_TEST_TYPED (gint64, 9223372036854775807);

	_NM_STRDUP_INT_TEST_TYPED (gint64, -9223372036854775807);

	_NM_STRDUP_INT_TEST_TYPED (guint64, 0);

	_NM_STRDUP_INT_TEST_TYPED (guint64, 9223372036854775807);

	_NM_STRDUP_INT_TEST (TEST_NM_STRDUP_ENUM_m1, "-1");

	_NM_STRDUP_INT_TEST (TEST_NM_STRDUP_ENUM_3,  "3");

}

/*****************************************************************************/

static void

test_nm_strndup_a (void)

{

	int run;

	for (run = 0; run < 20; run++) {

		gs_free char *input = NULL;

		char ch;

		gsize i, l;

		input = g_strnfill (nmtst_get_rand_uint32 () % 20, 'x');

		for (i = 0; input[i]; i++) {

			while ((ch = ((char) nmtst_get_rand_uint32 ())) == '\0') {

				/* repeat. */

			}

			input[i] = ch;

		}

		{

			gs_free char *dup_free = NULL;

			const char *dup;

			l = strlen (input) + 1;

			dup = nm_strndup_a (10, input, l - 1, &dup_free);

			g_assert_cmpstr (dup, ==, input);

			if (strlen (dup) < 10)

				g_assert (!dup_free);

			else

				g_assert (dup == dup_free);

		}

		{

			gs_free char *dup_free = NULL;

			const char *dup;

			l = nmtst_get_rand_uint32 () % 23;

			dup = nm_strndup_a (10, input, l, &dup_free);

			g_assert (strncmp (dup, input, l) == 0);

			g_assert (strlen (dup) <= l);

			if (l < 10)

				g_assert (!dup_free);

			else

				g_assert (dup == dup_free);

			if (strlen (input) < l)

				g_assert (nm_utils_memeqzero (&dup[strlen (input)], l - strlen (input)));

		}

	}

}

/*****************************************************************************/

static void

test_nm_ip4_addr_is_localhost (void)

{

	g_assert ( nm_ip4_addr_is_localhost (nmtst_inet4_from_string ("127.0.0.0")));

	g_assert ( nm_ip4_addr_is_localhost (nmtst_inet4_from_string ("127.0.0.1")));

	g_assert ( nm_ip4_addr_is_localhost (nmtst_inet4_from_string ("127.5.0.1")));

	g_assert (!nm_ip4_addr_is_localhost (nmtst_inet4_from_string ("126.5.0.1")));

	g_assert (!nm_ip4_addr_is_localhost (nmtst_inet4_from_string ("128.5.0.1")));

	g_assert (!nm_ip4_addr_is_localhost (nmtst_inet4_from_string ("129.5.0.1")));

}

/*****************************************************************************/

static void

test_unaligned (void)

{

	int shift;

	for (shift = 0; shift <= 32; shift++) {

		guint8 buf[100] = { };

		guint8 val = 0;

		while (val == 0)

			val = nmtst_get_rand_uint32 () % 256;

		buf[shift] = val;

		g_assert_cmpint (unaligned_read_le64 (&buf[shift]), ==, (guint64) val);

		g_assert_cmpint (unaligned_read_be64 (&buf[shift]), ==, ((guint64) val) << 56);

		g_assert_cmpint (unaligned_read_ne64 (&buf[shift]), !=, 0);

		g_assert_cmpint (unaligned_read_le32 (&buf[shift]), ==, (guint32) val);

		g_assert_cmpint (unaligned_read_be32 (&buf[shift]), ==, ((guint32) val) << 24);

		g_assert_cmpint (unaligned_read_ne32 (&buf[shift]), !=, 0);

		g_assert_cmpint (unaligned_read_le16 (&buf[shift]), ==, (guint16) val);

		g_assert_cmpint (unaligned_read_be16 (&buf[shift]), ==, ((guint16) val) << 8);

		g_assert_cmpint (unaligned_read_ne16 (&buf[shift]), !=, 0);

	}

}

/*****************************************************************************/

static void

_strv_cmp_fuzz_input (const char *const*in,

                      gssize l,

                      const char ***out_strv_free_shallow,

                      char ***out_strv_free_deep,

                      const char *const* *out_s1,

                      const char *const* *out_s2)

{

	const char **strv;

	gsize i;

	/* Fuzz the input argument. It will return two output arrays that are semantically

	 * equal the input. */

	if (nmtst_get_rand_bool ()) {

		char **ss;

		if (l < 0)

			ss = g_strdupv ((char **) in);

		else if (l == 0) {

			ss =   nmtst_get_rand_bool ()

			     ? NULL

			     : g_new0 (char *, 1);

		} else {

			ss = nm_memdup (in, sizeof (const char *) * l);

			for (i = 0; i < (gsize) l; i++)

				ss[i] = g_strdup (ss[i]);

		}

		strv = (const char **) ss;

		*out_strv_free_deep = ss;

	} else {

		if (l < 0) {

			strv =   in

			       ? nm_memdup (in, sizeof (const char *) * (NM_PTRARRAY_LEN (in) + 1))

			       : NULL;

		} else if (l == 0) {

			strv =   nmtst_get_rand_bool ()

			       ? NULL

			       : g_new0 (const char *, 1);

		} else

			strv = nm_memdup (in, sizeof (const char *) * l);

		*out_strv_free_shallow = strv;

	}

	*out_s1 = in;

	*out_s2 = strv;

	if (nmtst_get_rand_bool ()) {

		/* randomly swap the original and the clone. That means, out_s1 is either

		 * the input argument (as-is) or the sementically equal clone. */

		NM_SWAP (*out_s1, *out_s2);

	}

	if (nmtst_get_rand_bool ()) {

		/* randomly make s1 and s2 the same. This is for testing that

		 * comparing two identical pointers yields the same result. */

		*out_s2 = *out_s1;

	}

}

static void

_strv_cmp_free_deep (char **strv,

                     gssize len)

{

	gssize i;

	if (strv) {

		if (len < 0)

			g_strfreev (strv);

		else {

			for (i = 0; i < len; i++)

				g_free (strv[i]);

			g_free (strv);

		}

	}

}

static void

test_strv_cmp (void)

{

	const char *const strv0[1] = { };

	const char *const strv1[2] = { "", };

#define _STRV_CMP(a1, l1, a2, l2, equal) \

	G_STMT_START { \

		gssize _l1 = (l1); \

		gssize _l2 = (l2); \

		const char *const*_a1; \

		const char *const*_a2; \

		const char *const*_a1x; \

		const char *const*_a2x; \

		char **_a1_free_deep = NULL; \

		char **_a2_free_deep = NULL; \

		gs_free const char **_a1_free_shallow = NULL; \

		gs_free const char **_a2_free_shallow = NULL; \

		int _c1, _c2; \

		\

		_strv_cmp_fuzz_input ((a1), _l1, &_a1_free_shallow, &_a1_free_deep, &_a1, &_a1x); \

		_strv_cmp_fuzz_input ((a2), _l2, &_a2_free_shallow, &_a2_free_deep, &_a2, &_a2x); \

		\

		_c1 = _nm_utils_strv_cmp_n (_a1, _l1, _a2, _l2); \

		_c2 = _nm_utils_strv_cmp_n (_a2, _l2, _a1, _l1); \

		if (equal) { \

			g_assert_cmpint (_c1, ==, 0); \

			g_assert_cmpint (_c2, ==, 0); \

		} else { \

			g_assert_cmpint (_c1, ==, -1); \

			g_assert_cmpint (_c2, ==, 1); \

		} \

		\

		/* Compare with self. _strv_cmp_fuzz_input() randomly swapped the arguments (_a1 and _a1x).

		 * Either way, the arrays must compare equal to their semantically equal alternative. */ \

		g_assert_cmpint (_nm_utils_strv_cmp_n (_a1, _l1, _a1x, _l1), ==, 0); \

		g_assert_cmpint (_nm_utils_strv_cmp_n (_a2, _l2, _a2x, _l2), ==, 0); \

		\

		_strv_cmp_free_deep (_a1_free_deep, _l1); \

		_strv_cmp_free_deep (_a2_free_deep, _l2); \

	} G_STMT_END

	_STRV_CMP (NULL,  -1, NULL,  -1, TRUE);

	_STRV_CMP (NULL,  -1, NULL,   0, FALSE);

	_STRV_CMP (NULL,  -1, strv0,  0, FALSE);

	_STRV_CMP (NULL,  -1, strv0, -1, FALSE);

	_STRV_CMP (NULL,   0, NULL,   0, TRUE);

	_STRV_CMP (NULL,   0, strv0,  0, TRUE);

	_STRV_CMP (NULL,   0, strv0, -1, TRUE);

	_STRV_CMP (strv0,  0, strv0,  0, TRUE);

	_STRV_CMP (strv0,  0, strv0, -1, TRUE);

	_STRV_CMP (strv0, -1, strv0, -1, TRUE);

	_STRV_CMP (NULL,   0, strv1, -1, FALSE);

	_STRV_CMP (NULL,   0, strv1,  1, FALSE);

	_STRV_CMP (strv0,  0, strv1, -1, FALSE);

	_STRV_CMP (strv0,  0, strv1,  1, FALSE);

	_STRV_CMP (strv0, -1, strv1, -1, FALSE);

	_STRV_CMP (strv0, -1, strv1,  1, FALSE);

	_STRV_CMP (strv1, -1, strv1,  1, TRUE);

	_STRV_CMP (strv1,  1, strv1,  1, TRUE);

}

/*****************************************************************************/

static void

_do_strstrip_avoid_copy (const char *str)

{

	gs_free char *str1 = g_strdup (str);

	gs_free char *str2 = g_strdup (str);

	gs_free char *str3 = NULL;

	gs_free char *str4 = NULL;

	const char *s3;

	const char *s4;

	if (str1)

		g_strstrip (str1);

	nm_strstrip (str2);

	g_assert_cmpstr (str1, ==, str2);

	s3 = nm_strstrip_avoid_copy (str, &str3;;

	g_assert_cmpstr (str1, ==, s3);

	s4 = nm_strstrip_avoid_copy_a (10, str, &str4;;

	g_assert_cmpstr (str1, ==, s4);

	g_assert (!str == !s4);

	g_assert (!s4 || strlen (s4) <= strlen (str));

	if (s4 && s4 == &str[strlen (str) - strlen (s4)]) {

		g_assert (!str4);

		g_assert (s3 == s4);

	} else if (s4 && strlen (s4) >= 10) {

		g_assert (str4);

		g_assert (s4 == str4);

	} else

		g_assert (!str4);

	if (!nm_streq0 (str1, str))

		_do_strstrip_avoid_copy (str1);

}

static void

test_strstrip_avoid_copy (void)

{

	_do_strstrip_avoid_copy (NULL);

	_do_strstrip_avoid_copy ("");

	_do_strstrip_avoid_copy (" ");

	_do_strstrip_avoid_copy (" a ");

	_do_strstrip_avoid_copy (" 012345678 ");

	_do_strstrip_avoid_copy (" 0123456789 ");

	_do_strstrip_avoid_copy (" 01234567890 ");

	_do_strstrip_avoid_copy (" 012345678901 ");

}

/*****************************************************************************/

static void

test_nm_utils_bin2hexstr (void)

{

	int n_run;

	for (n_run = 0; n_run < 100; n_run++) {

		guint8 buf[100];

		guint8 buf2[G_N_ELEMENTS (buf) + 1];

		gsize len = nmtst_get_rand_uint32 () % (G_N_ELEMENTS (buf) + 1);

		char strbuf1[G_N_ELEMENTS (buf) * 3];

		gboolean allocate = nmtst_get_rand_bool ();

		char delimiter = nmtst_get_rand_bool () ? ':' : '\0';

		gboolean upper_case = nmtst_get_rand_bool ();

		gsize expected_strlen;

		char *str_hex;

		gsize required_len;

		gboolean outlen_set;

		gsize outlen;

		guint8 *bin2;

		nmtst_rand_buf (NULL, buf, len);

		if (len == 0)

			expected_strlen = 0;

		else if (delimiter != '\0')

			expected_strlen = (len * 3u) - 1;

		else

			expected_strlen = len * 2u;

		g_assert_cmpint (expected_strlen, <, G_N_ELEMENTS (strbuf1));

		str_hex = nm_utils_bin2hexstr_full (buf, len, delimiter, upper_case, !allocate ? strbuf1 : NULL);

		g_assert (str_hex);

		if (!allocate)

			g_assert (str_hex == strbuf1);

		g_assert_cmpint (strlen (str_hex), ==, expected_strlen);

		g_assert (NM_STRCHAR_ALL (str_hex, ch,    (ch >= '0' && ch <= '9')

		                                       || ch == delimiter

		                                       || (  upper_case

		                                           ? (ch >= 'A' && ch <= 'F')

		                                           : (ch >= 'a' && ch <= 'f'))));

		required_len = nmtst_get_rand_bool () ? len : 0u;

		outlen_set = required_len == 0 || nmtst_get_rand_bool ();

		memset (buf2, 0, sizeof (buf2));

		bin2 = nm_utils_hexstr2bin_full (str_hex,

		                                 nmtst_get_rand_bool (),

		                                 delimiter != '\0' && nmtst_get_rand_bool (),

		                                   delimiter != '\0'

		                                 ? nmtst_rand_select ((const char *) ":", ":-")

		                                 : nmtst_rand_select ((const char *) ":", ":-", "", NULL),

		                                 required_len,

		                                 buf2,

		                                 len,

		                                 outlen_set ? &outlen : NULL);

		if (len > 0) {

			g_assert (bin2);

			g_assert (bin2 == buf2);

		} else

			g_assert (!bin2);

		if (outlen_set)

			g_assert_cmpint (outlen, ==, len);

		g_assert_cmpmem (buf, len, buf2, len);

		g_assert (buf2[len] == '\0');

		if (allocate)

			g_free (str_hex);

	}

}

/*****************************************************************************/

static void

test_nm_ref_string (void)

{

	nm_auto_ref_string NMRefString *s1 = NULL;

	NMRefString *s2;

	s1 = nm_ref_string_new ("hallo");

	g_assert (s1);

	g_assert_cmpstr (s1->str, ==, "hallo");

	g_assert_cmpint (s1->len, ==, strlen ("hallo"));

	s2 = nm_ref_string_new ("hallo");

	g_assert (s2 == s1);

	nm_ref_string_unref (s2);

	s2 = nm_ref_string_new (NULL);

	g_assert (!s2);

	nm_ref_string_unref (s2);

#define STR_WITH_NUL "hallo\0test\0"

	s2 = nm_ref_string_new_len (STR_WITH_NUL, NM_STRLEN (STR_WITH_NUL));

	g_assert (s2);

	g_assert_cmpstr (s2->str, ==, "hallo");

	g_assert_cmpint (s2->len, ==, NM_STRLEN (STR_WITH_NUL));

	g_assert_cmpint (s2->len, >, strlen (s2->str));

	g_assert_cmpmem (s2->str, s2->len, STR_WITH_NUL, NM_STRLEN (STR_WITH_NUL));

	g_assert (s2->str[s2->len] == '\0');

	nm_ref_string_unref (s2);

}

/*****************************************************************************/

static

NM_UTILS_STRING_TABLE_LOOKUP_DEFINE (

	_do_string_table_lookup,

	int,

	{ ; },

	{ return -1; },

	{ "0", 0 },

	{ "1", 1 },

	{ "2", 2 },

	{ "3", 3 },

)

static void

test_string_table_lookup (void)

{

	const char *const args[] = { NULL, "0", "1", "2", "3", "x", };

	int i;

	for (i = 0; i < G_N_ELEMENTS (args); i++) {

		const char *needle = args[i];

		const int val2 = _nm_utils_ascii_str_to_int64 (needle, 10, 0, 100, -1);

		int val;

		val = _do_string_table_lookup (needle);

		g_assert_cmpint (val, ==, val2);

	}

}

/*****************************************************************************/

static void

test_nm_utils_get_next_realloc_size (void)

{

	static const struct {

		gsize requested;

		gsize reserved_true;

		gsize reserved_false;

	} test_data[] = {

		{      0,     8,     8 },

		{      1,     8,     8 },

		{      8,     8,     8 },

		{      9,    16,    16 },

		{     16,    16,    16 },

		{     17,    32,    32 },

		{     32,    32,    32 },

		{     33,    40,    40 },

		{     40,    40,    40 },

		{     41,   104,   104 },

		{    104,   104,   104 },

		{    105,   232,   232 },

		{    232,   232,   232 },

		{    233,   488,   488 },

		{    488,   488,   488 },

		{    489,  1000,  1000 },

		{   1000,  1000,  1000 },

		{   1001,  2024,  2024 },

		{   2024,  2024,  2024 },

		{   2025,  4072,  4072 },

		{   4072,  4072,  4072 },

		{   4073,  8168,  8168 },

		{   8168,  8168,  8168 },

		{   8169, 12264, 16360 },

		{  12263, 12264, 16360 },

		{  12264, 12264, 16360 },

		{  12265, 16360, 16360 },

		{  16360, 16360, 16360 },

		{  16361, 20456, 32744 },

		{  20456, 20456, 32744 },

		{  20457, 24552, 32744 },

		{  24552, 24552, 32744 },

		{  24553, 28648, 32744 },

		{  28648, 28648, 32744 },

		{  28649, 32744, 32744 },

		{  32744, 32744, 32744 },

		{  32745, 36840, 65512 },

		{  36840, 36840, 65512 },

		{  G_MAXSIZE - 0x1000u,  G_MAXSIZE, G_MAXSIZE },

		{  G_MAXSIZE - 25u,      G_MAXSIZE, G_MAXSIZE },

		{  G_MAXSIZE - 24u,      G_MAXSIZE, G_MAXSIZE },

		{  G_MAXSIZE - 1u,       G_MAXSIZE, G_MAXSIZE },

		{  G_MAXSIZE,            G_MAXSIZE, G_MAXSIZE },

		{  NM_UTILS_GET_NEXT_REALLOC_SIZE_104,  NM_UTILS_GET_NEXT_REALLOC_SIZE_104,  NM_UTILS_GET_NEXT_REALLOC_SIZE_104 },

		{  NM_UTILS_GET_NEXT_REALLOC_SIZE_1000, NM_UTILS_GET_NEXT_REALLOC_SIZE_1000, NM_UTILS_GET_NEXT_REALLOC_SIZE_1000 },

	};

	guint i;

	G_STATIC_ASSERT_EXPR (NM_UTILS_GET_NEXT_REALLOC_SIZE_104  == 104u);

	G_STATIC_ASSERT_EXPR (NM_UTILS_GET_NEXT_REALLOC_SIZE_1000 == 1000u);

	for (i = 0; i < G_N_ELEMENTS (test_data) + 5000u; i++) {

		gsize requested0;

		if (i < G_N_ELEMENTS (test_data))

			requested0 = test_data[i].requested;

		else {

			/* find some interesting random values for testing. */

			switch (nmtst_get_rand_uint32 () % 5) {

			case 0:

				requested0 = nmtst_get_rand_size ();

				break;

			case 1:

				/* values close to G_MAXSIZE. */

				requested0 = G_MAXSIZE - (nmtst_get_rand_uint32 () % 12000u);

				break;

			case 2:

				/* values around G_MAXSIZE/2. */

				requested0 = (G_MAXSIZE / 2u) + 6000u - (nmtst_get_rand_uint32 () % 12000u);

				break;

			case 3:

				/* values around powers of 2. */

				requested0 = (((gsize) 1) << (nmtst_get_rand_uint32 () % (sizeof (gsize) * 8u))) + 6000u - (nmtst_get_rand_uint32 () % 12000u);

				break;

			case 4:

				/* values around 4k borders. */

				requested0 = (nmtst_get_rand_size () & ~((gsize) 0xFFFu)) + 30u - (nmtst_get_rand_uint32 () % 60u);

				break;

			default: g_assert_not_reached ();

			}

		}

		{

			const gsize requested = requested0;

			const gsize reserved_true = nm_utils_get_next_realloc_size (TRUE, requested);

			const gsize reserved_false = nm_utils_get_next_realloc_size (FALSE, requested);

			g_assert_cmpuint (reserved_true, >, 0);

			g_assert_cmpuint (reserved_false, >, 0);

			g_assert_cmpuint (reserved_true, >=, requested);

			g_assert_cmpuint (reserved_false, >=, requested);

			g_assert_cmpuint (reserved_false, >=, reserved_true);

			if (i < G_N_ELEMENTS (test_data)) {

				g_assert_cmpuint (reserved_true, ==, test_data[i].reserved_true);

				g_assert_cmpuint (reserved_false, ==, test_data[i].reserved_false);

			}

			/* reserved_false is generally the next power of two - 24. */

			if (reserved_false == G_MAXSIZE)

				g_assert_cmpuint (requested, >, G_MAXSIZE / 2u - 24u);

			else {

				g_assert_cmpuint (reserved_false, <=, G_MAXSIZE - 24u);

				if (reserved_false >= 40) {

					const gsize _pow2 = reserved_false + 24u;

					/* reserved_false must always be a power of two minus 24. */

					g_assert_cmpuint (_pow2, >=, 64u);

					g_assert_cmpuint (_pow2, >, requested);

					g_assert (nm_utils_is_power_of_two (_pow2));

					/* but _pow2/2 must also be smaller than what we requested. */

					g_assert_cmpuint (_pow2 / 2u - 24u, <, requested);

				} else {

					/* smaller values are hard-coded. */

				}

			}

			/* reserved_true is generally the next 4k border - 24. */

			if (reserved_true == G_MAXSIZE)

				g_assert_cmpuint (requested, >, G_MAXSIZE - 0x1000u - 24u);

			else {

				g_assert_cmpuint (reserved_true, <=, G_MAXSIZE - 24u);

				if (reserved_true > 8168u) {

					const gsize page_border = reserved_true + 24u;

					/* reserved_true must always be aligned to 4k (minus 24). */

					g_assert_cmpuint (page_border % 0x1000u, ==, 0);

					if (requested > 0x1000u - 24u) {

						/* page_border not be more than 4k above requested. */

						g_assert_cmpuint (page_border, >=, 0x1000u - 24u);

						g_assert_cmpuint (page_border - 0x1000u - 24u, <, requested);

					}

				} else {

					/* for smaller sizes, reserved_true and reserved_false are the same. */

					g_assert_cmpuint (reserved_true, ==, reserved_false);

				}

			}

		}

	}

}

/*****************************************************************************/

static void

test_nm_str_buf (void)

{

	guint i_run;

	for (i_run = 0; TRUE; i_run++) {

		nm_auto_str_buf NMStrBuf strbuf = { };

		nm_auto_free_gstring GString *gstr = NULL;

		int i, j, k;

		int c;

		nm_str_buf_init (&strbuf,

		                 nmtst_get_rand_uint32 () % 200u + 1u,

		                 nmtst_get_rand_bool ());

		if (i_run < 1000) {

			c = nmtst_get_rand_word_length (NULL);

			for (i = 0; i < c; i++)

				nm_str_buf_append_c (&strbuf, '0' + (i % 10));

			gstr = g_string_new (nm_str_buf_get_str (&strbuf));

			j = nmtst_get_rand_uint32 () % (strbuf.len + 1);

			k = nmtst_get_rand_uint32 () % (strbuf.len - j + 2) - 1;

			nm_str_buf_erase (&strbuf, j, k, nmtst_get_rand_bool ());

			g_string_erase (gstr, j, k);

			g_assert_cmpstr (gstr->str, ==, nm_str_buf_get_str (&strbuf));

		} else

			return;

	}

}

/*****************************************************************************/

NMTST_DEFINE ();

int main (int argc, char **argv)

{

	nmtst_init (&argc, &argv, TRUE);

	g_test_add_func ("/general/test_gpid", test_gpid);

	g_test_add_func ("/general/test_monotonic_timestamp", test_monotonic_timestamp);

	g_test_add_func ("/general/test_nmhash", test_nmhash);

	g_test_add_func ("/general/test_nm_make_strv", test_make_strv);

	g_test_add_func ("/general/test_nm_strdup_int", test_nm_strdup_int);

	g_test_add_func ("/general/test_nm_strndup_a", test_nm_strndup_a);

	g_test_add_func ("/general/test_nm_ip4_addr_is_localhost", test_nm_ip4_addr_is_localhost);

	g_test_add_func ("/general/test_unaligned", test_unaligned);

	g_test_add_func ("/general/test_strv_cmp", test_strv_cmp);

	g_test_add_func ("/general/test_strstrip_avoid_copy", test_strstrip_avoid_copy);

	g_test_add_func ("/general/test_nm_utils_bin2hexstr", test_nm_utils_bin2hexstr);

	g_test_add_func ("/general/test_nm_ref_string", test_nm_ref_string);

	g_test_add_func ("/general/test_string_table_lookup", test_string_table_lookup);

	g_test_add_func ("/general/test_nm_utils_get_next_realloc_size", test_nm_utils_get_next_realloc_size);

	g_test_add_func ("/general/test_nm_str_buf", test_nm_str_buf);

	return g_test_run ();

}