[thirdparty/systemd.git] / src / test / test-util.c

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering
  Copyright 2013 Thomas H.P. Andersen

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <errno.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

#include "def.h"
#include "fileio.h"
#include "fs-util.h"
#include "parse-util.h"
#include "raw-clone.h"
#include "rm-rf.h"
#include "string-util.h"
#include "util.h"

static void test_align_power2(void) {
        unsigned long i, p2;

        assert_se(ALIGN_POWER2(0) == 0);
        assert_se(ALIGN_POWER2(1) == 1);
        assert_se(ALIGN_POWER2(2) == 2);
        assert_se(ALIGN_POWER2(3) == 4);
        assert_se(ALIGN_POWER2(12) == 16);

        assert_se(ALIGN_POWER2(ULONG_MAX) == 0);
        assert_se(ALIGN_POWER2(ULONG_MAX - 1) == 0);
        assert_se(ALIGN_POWER2(ULONG_MAX - 1024) == 0);
        assert_se(ALIGN_POWER2(ULONG_MAX / 2) == ULONG_MAX / 2 + 1);
        assert_se(ALIGN_POWER2(ULONG_MAX + 1) == 0);

        for (i = 1; i < 131071; ++i) {
                for (p2 = 1; p2 < i; p2 <<= 1)
                        /* empty */ ;

                assert_se(ALIGN_POWER2(i) == p2);
        }

        for (i = ULONG_MAX - 1024; i < ULONG_MAX; ++i) {
                for (p2 = 1; p2 && p2 < i; p2 <<= 1)
                        /* empty */ ;

                assert_se(ALIGN_POWER2(i) == p2);
        }
}

static void test_max(void) {
        static const struct {
                int a;
                int b[CONST_MAX(10, 100)];
        } val1 = {
                .a = CONST_MAX(10, 100),
        };
        int d = 0;

        assert_cc(sizeof(val1.b) == sizeof(int) * 100);

        /* CONST_MAX returns (void) instead of a value if the passed arguments
         * are not of the same type or not constant expressions. */
        assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
        assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));

        assert_se(val1.a == 100);
        assert_se(MAX(++d, 0) == 1);
        assert_se(d == 1);

        assert_cc(MAXSIZE(char[3], uint16_t) == 3);
        assert_cc(MAXSIZE(char[3], uint32_t) == 4);
        assert_cc(MAXSIZE(char, long) == sizeof(long));

        assert_se(MAX(-5, 5) == 5);
        assert_se(MAX(5, 5) == 5);
        assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
        assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
        assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
        assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
        assert_se(LESS_BY(8, 4) == 4);
        assert_se(LESS_BY(8, 8) == 0);
        assert_se(LESS_BY(4, 8) == 0);
        assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
        assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
        assert_se(CLAMP(-5, 0, 1) == 0);
        assert_se(CLAMP(5, 0, 1) == 1);
        assert_se(CLAMP(5, -10, 1) == 1);
        assert_se(CLAMP(5, -10, 10) == 5);
        assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
}

static void test_container_of(void) {
        struct mytype {
                uint8_t pad1[3];
                uint64_t v1;
                uint8_t pad2[2];
                uint32_t v2;
        } _packed_ myval = { };

        assert_cc(sizeof(myval) == 17);
        assert_se(container_of(&myval.v1, struct mytype, v1) == &myval);
        assert_se(container_of(&myval.v2, struct mytype, v2) == &myval);
        assert_se(container_of(&container_of(&myval.v2,
                                             struct mytype,
                                             v2)->v1,
                               struct mytype,
                               v1) == &myval);
}

static void test_div_round_up(void) {
        int div;

        /* basic tests */
        assert_se(DIV_ROUND_UP(0, 8) == 0);
        assert_se(DIV_ROUND_UP(1, 8) == 1);
        assert_se(DIV_ROUND_UP(8, 8) == 1);
        assert_se(DIV_ROUND_UP(12, 8) == 2);
        assert_se(DIV_ROUND_UP(16, 8) == 2);

        /* test multiple evaluation */
        div = 0;
        assert_se(DIV_ROUND_UP(div++, 8) == 0 && div == 1);
        assert_se(DIV_ROUND_UP(++div, 8) == 1 && div == 2);
        assert_se(DIV_ROUND_UP(8, div++) == 4 && div == 3);
        assert_se(DIV_ROUND_UP(8, ++div) == 2 && div == 4);

        /* overflow test with exact division */
        assert_se(sizeof(0U) == 4);
        assert_se(0xfffffffaU % 10U == 0U);
        assert_se(0xfffffffaU / 10U == 429496729U);
        assert_se(DIV_ROUND_UP(0xfffffffaU, 10U) == 429496729U);
        assert_se((0xfffffffaU + 10U - 1U) / 10U == 0U);
        assert_se(0xfffffffaU / 10U + !!(0xfffffffaU % 10U) == 429496729U);

        /* overflow test with rounded division */
        assert_se(0xfffffffdU % 10U == 3U);
        assert_se(0xfffffffdU / 10U == 429496729U);
        assert_se(DIV_ROUND_UP(0xfffffffdU, 10U) == 429496730U);
        assert_se((0xfffffffdU + 10U - 1U) / 10U == 0U);
        assert_se(0xfffffffdU / 10U + !!(0xfffffffdU % 10U) == 429496730U);
}

static void test_u64log2(void) {
        assert_se(u64log2(0) == 0);
        assert_se(u64log2(8) == 3);
        assert_se(u64log2(9) == 3);
        assert_se(u64log2(15) == 3);
        assert_se(u64log2(16) == 4);
        assert_se(u64log2(1024*1024) == 20);
        assert_se(u64log2(1024*1024+5) == 20);
}

static void test_protect_errno(void) {
        errno = 12;
        {
                PROTECT_ERRNO;
                errno = 11;
        }
        assert_se(errno == 12);
}

static void test_in_set(void) {
        assert_se(IN_SET(1, 1));
        assert_se(IN_SET(1, 1, 2, 3, 4));
        assert_se(IN_SET(2, 1, 2, 3, 4));
        assert_se(IN_SET(3, 1, 2, 3, 4));
        assert_se(IN_SET(4, 1, 2, 3, 4));
        assert_se(!IN_SET(0, 1));
        assert_se(!IN_SET(0, 1, 2, 3, 4));
}

static void test_log2i(void) {
        assert_se(log2i(1) == 0);
        assert_se(log2i(2) == 1);
        assert_se(log2i(3) == 1);
        assert_se(log2i(4) == 2);
        assert_se(log2i(32) == 5);
        assert_se(log2i(33) == 5);
        assert_se(log2i(63) == 5);
        assert_se(log2i(INT_MAX) == sizeof(int)*8-2);
}

static void test_raw_clone(void) {
        pid_t parent, pid, pid2;

        parent = getpid();
        log_info("before clone: getpid()→"PID_FMT, parent);
        assert_se(raw_getpid() == parent);

        pid = raw_clone(0);
        assert_se(pid >= 0);

        pid2 = raw_getpid();
        log_info("raw_clone: "PID_FMT" getpid()→"PID_FMT" raw_getpid()→"PID_FMT,
                 pid, getpid(), pid2);
        if (pid == 0) {
                assert_se(pid2 != parent);
                _exit(EXIT_SUCCESS);
        } else {
                int status;

                assert_se(pid2 == parent);
                waitpid(pid, &status, __WCLONE);
                assert_se(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
        }
}

static void test_physical_memory(void) {
        uint64_t p;
        char buf[FORMAT_BYTES_MAX];

        p = physical_memory();
        assert_se(p > 0);
        assert_se(p < UINT64_MAX);
        assert_se(p % page_size() == 0);

        log_info("Memory: %s (%" PRIu64 ")", format_bytes(buf, sizeof(buf), p), p);
}

static void test_physical_memory_scale(void) {
        uint64_t p;

        p = physical_memory();

        assert_se(physical_memory_scale(0, 100) == 0);
        assert_se(physical_memory_scale(100, 100) == p);

        log_info("Memory original: %" PRIu64, physical_memory());
        log_info("Memory scaled by 50%%: %" PRIu64, physical_memory_scale(50, 100));
        log_info("Memory divided by 2: %" PRIu64, physical_memory() / 2);
        log_info("Page size: %zu", page_size());

        /* There might be an uneven number of pages, hence permit these calculations to be half a page off... */
        assert_se(page_size()/2 + physical_memory_scale(50, 100) - p/2 <= page_size());
        assert_se(physical_memory_scale(200, 100) == p*2);

        assert_se(physical_memory_scale(0, 1) == 0);
        assert_se(physical_memory_scale(1, 1) == p);
        assert_se(physical_memory_scale(2, 1) == p*2);

        assert_se(physical_memory_scale(0, 2) == 0);

        assert_se(page_size()/2 + physical_memory_scale(1, 2) - p/2 <= page_size());
        assert_se(physical_memory_scale(2, 2) == p);
        assert_se(physical_memory_scale(4, 2) == p*2);

        assert_se(physical_memory_scale(0, UINT32_MAX) == 0);
        assert_se(physical_memory_scale(UINT32_MAX, UINT32_MAX) == p);

        /* overflow */
        assert_se(physical_memory_scale(UINT64_MAX/4, UINT64_MAX) == UINT64_MAX);
}

static void test_system_tasks_max(void) {
        uint64_t t;

        t = system_tasks_max();
        assert_se(t > 0);
        assert_se(t < UINT64_MAX);

        log_info("Max tasks: %" PRIu64, t);
}

static void test_system_tasks_max_scale(void) {
        uint64_t t;

        t = system_tasks_max();

        assert_se(system_tasks_max_scale(0, 100) == 0);
        assert_se(system_tasks_max_scale(100, 100) == t);

        assert_se(system_tasks_max_scale(0, 1) == 0);
        assert_se(system_tasks_max_scale(1, 1) == t);
        assert_se(system_tasks_max_scale(2, 1) == 2*t);

        assert_se(system_tasks_max_scale(0, 2) == 0);
        assert_se(system_tasks_max_scale(1, 2) == t/2);
        assert_se(system_tasks_max_scale(2, 2) == t);
        assert_se(system_tasks_max_scale(3, 2) == (3*t)/2);
        assert_se(system_tasks_max_scale(4, 2) == t*2);

        assert_se(system_tasks_max_scale(0, UINT32_MAX) == 0);
        assert_se(system_tasks_max_scale((UINT32_MAX-1)/2, UINT32_MAX-1) == t/2);
        assert_se(system_tasks_max_scale(UINT32_MAX, UINT32_MAX) == t);

        /* overflow */

        assert_se(system_tasks_max_scale(UINT64_MAX/4, UINT64_MAX) == UINT64_MAX);
}

int main(int argc, char *argv[]) {
        log_parse_environment();
        log_open();

        test_align_power2();
        test_max();
        test_container_of();
        test_div_round_up();
        test_u64log2();
        test_protect_errno();
        test_in_set();
        test_log2i();
        test_raw_clone();
        test_physical_memory();
        test_physical_memory_scale();
        test_system_tasks_max();
        test_system_tasks_max_scale();

        return 0;
}
Commit	Line	Data
539ad707 TA	1	/***
	2	This file is part of systemd.
	3
	4	Copyright 2010 Lennart Poettering
	5	Copyright 2013 Thomas H.P. Andersen
	6
	7	systemd is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU Lesser General Public License as published by
	9	the Free Software Foundation; either version 2.1 of the License, or
	10	(at your option) any later version.
	11
	12	systemd is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	Lesser General Public License for more details.
	16
	17	You should have received a copy of the GNU Lesser General Public License
	18	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	19	***/
	20
618234a5	21	#include <errno.h>
618234a5	22	#include <string.h>
8852362b	23	#include <sys/wait.h>
618234a5	24	#include <unistd.h>
539ad707	25
65b3903f ZJS	26	#include "def.h"
65b3903f ZJS	27	#include "fileio.h"
f4f15635	28	#include "fs-util.h"
d9ab2bcf	29	#include "parse-util.h"
8869a0b4	30	#include "raw-clone.h"
618234a5	31	#include "rm-rf.h"
07630cea	32	#include "string-util.h"
618234a5	33	#include "util.h"
539ad707	34
625e870b DH	35	static void test_align_power2(void) {
	36	unsigned long i, p2;
	37
	38	assert_se(ALIGN_POWER2(0) == 0);
	39	assert_se(ALIGN_POWER2(1) == 1);
	40	assert_se(ALIGN_POWER2(2) == 2);
	41	assert_se(ALIGN_POWER2(3) == 4);
	42	assert_se(ALIGN_POWER2(12) == 16);
	43
	44	assert_se(ALIGN_POWER2(ULONG_MAX) == 0);
	45	assert_se(ALIGN_POWER2(ULONG_MAX - 1) == 0);
	46	assert_se(ALIGN_POWER2(ULONG_MAX - 1024) == 0);
	47	assert_se(ALIGN_POWER2(ULONG_MAX / 2) == ULONG_MAX / 2 + 1);
	48	assert_se(ALIGN_POWER2(ULONG_MAX + 1) == 0);
	49
	50	for (i = 1; i < 131071; ++i) {
	51	for (p2 = 1; p2 < i; p2 <<= 1)
	52	/* empty */ ;
	53
	54	assert_se(ALIGN_POWER2(i) == p2);
	55	}
	56
	57	for (i = ULONG_MAX - 1024; i < ULONG_MAX; ++i) {
	58	for (p2 = 1; p2 && p2 < i; p2 <<= 1)
	59	/* empty */ ;
	60
	61	assert_se(ALIGN_POWER2(i) == p2);
	62	}
	63	}
	64
7242d742 DH	65	static void test_max(void) {
	66	static const struct {
	67	int a;
	68	int b[CONST_MAX(10, 100)];
	69	} val1 = {
	70	.a = CONST_MAX(10, 100),
	71	};
	72	int d = 0;
	73
	74	assert_cc(sizeof(val1.b) == sizeof(int) * 100);
	75
	76	/* CONST_MAX returns (void) instead of a value if the passed arguments
	77	* are not of the same type or not constant expressions. */
	78	assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
7242d742 DH	79	assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
	80
	81	assert_se(val1.a == 100);
	82	assert_se(MAX(++d, 0) == 1);
	83	assert_se(d == 1);
40a1eebd DH	84
	85	assert_cc(MAXSIZE(char[3], uint16_t) == 3);
	86	assert_cc(MAXSIZE(char[3], uint32_t) == 4);
	87	assert_cc(MAXSIZE(char, long) == sizeof(long));
667a0377 DH	88
	89	assert_se(MAX(-5, 5) == 5);
	90	assert_se(MAX(5, 5) == 5);
	91	assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
	92	assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
	93	assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
	94	assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
	95	assert_se(LESS_BY(8, 4) == 4);
	96	assert_se(LESS_BY(8, 8) == 0);
	97	assert_se(LESS_BY(4, 8) == 0);
	98	assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
	99	assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
	100	assert_se(CLAMP(-5, 0, 1) == 0);
	101	assert_se(CLAMP(5, 0, 1) == 1);
	102	assert_se(CLAMP(5, -10, 1) == 1);
	103	assert_se(CLAMP(5, -10, 10) == 5);
	104	assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
7242d742 DH	105	}
7242d742 DH	106
fb835651 DH	107	static void test_container_of(void) {
	108	struct mytype {
	109	uint8_t pad1[3];
	110	uint64_t v1;
	111	uint8_t pad2[2];
	112	uint32_t v2;
	113	} _packed_ myval = { };
	114
	115	assert_cc(sizeof(myval) == 17);
	116	assert_se(container_of(&myval.v1, struct mytype, v1) == &myval);
	117	assert_se(container_of(&myval.v2, struct mytype, v2) == &myval);
	118	assert_se(container_of(&container_of(&myval.v2,
	119	struct mytype,
	120	v2)->v1,
	121	struct mytype,
	122	v1) == &myval);
	123	}
	124
180a60bc DH	125	static void test_div_round_up(void) {
	126	int div;
	127
	128	/* basic tests */
	129	assert_se(DIV_ROUND_UP(0, 8) == 0);
	130	assert_se(DIV_ROUND_UP(1, 8) == 1);
	131	assert_se(DIV_ROUND_UP(8, 8) == 1);
	132	assert_se(DIV_ROUND_UP(12, 8) == 2);
	133	assert_se(DIV_ROUND_UP(16, 8) == 2);
	134
	135	/* test multiple evaluation */
	136	div = 0;
	137	assert_se(DIV_ROUND_UP(div++, 8) == 0 && div == 1);
	138	assert_se(DIV_ROUND_UP(++div, 8) == 1 && div == 2);
	139	assert_se(DIV_ROUND_UP(8, div++) == 4 && div == 3);
	140	assert_se(DIV_ROUND_UP(8, ++div) == 2 && div == 4);
	141
	142	/* overflow test with exact division */
	143	assert_se(sizeof(0U) == 4);
	144	assert_se(0xfffffffaU % 10U == 0U);
	145	assert_se(0xfffffffaU / 10U == 429496729U);
	146	assert_se(DIV_ROUND_UP(0xfffffffaU, 10U) == 429496729U);
	147	assert_se((0xfffffffaU + 10U - 1U) / 10U == 0U);
	148	assert_se(0xfffffffaU / 10U + !!(0xfffffffaU % 10U) == 429496729U);
	149
	150	/* overflow test with rounded division */
	151	assert_se(0xfffffffdU % 10U == 3U);
	152	assert_se(0xfffffffdU / 10U == 429496729U);
	153	assert_se(DIV_ROUND_UP(0xfffffffdU, 10U) == 429496730U);
	154	assert_se((0xfffffffdU + 10U - 1U) / 10U == 0U);
	155	assert_se(0xfffffffdU / 10U + !!(0xfffffffdU % 10U) == 429496730U);
	156	}
	157
144e51ec	158	static void test_u64log2(void) {
bdf7026e TA	159	assert_se(u64log2(0) == 0);
	160	assert_se(u64log2(8) == 3);
	161	assert_se(u64log2(9) == 3);
	162	assert_se(u64log2(15) == 3);
	163	assert_se(u64log2(16) == 4);
	164	assert_se(u64log2(1024*1024) == 20);
	165	assert_se(u64log2(1024*1024+5) == 20);
144e51ec CR	166	}
144e51ec CR	167
2a371001 ZJS	168	static void test_protect_errno(void) {
	169	errno = 12;
	170	{
	171	PROTECT_ERRNO;
	172	errno = 11;
	173	}
bdf7026e	174	assert_se(errno == 12);
2a371001 ZJS	175	}
2a371001 ZJS	176
cabb7806 LP	177	static void test_in_set(void) {
	178	assert_se(IN_SET(1, 1));
	179	assert_se(IN_SET(1, 1, 2, 3, 4));
	180	assert_se(IN_SET(2, 1, 2, 3, 4));
	181	assert_se(IN_SET(3, 1, 2, 3, 4));
	182	assert_se(IN_SET(4, 1, 2, 3, 4));
	183	assert_se(!IN_SET(0, 1));
	184	assert_se(!IN_SET(0, 1, 2, 3, 4));
	185	}
	186
8fe90522 ZJS	187	static void test_log2i(void) {
	188	assert_se(log2i(1) == 0);
	189	assert_se(log2i(2) == 1);
	190	assert_se(log2i(3) == 1);
	191	assert_se(log2i(4) == 2);
	192	assert_se(log2i(32) == 5);
	193	assert_se(log2i(33) == 5);
	194	assert_se(log2i(63) == 5);
	195	assert_se(log2i(INT_MAX) == sizeof(int)*8-2);
	196	}
	197
ee05e779 ZJS	198	static void test_raw_clone(void) {
	199	pid_t parent, pid, pid2;
	200
	201	parent = getpid();
	202	log_info("before clone: getpid()→"PID_FMT, parent);
	203	assert_se(raw_getpid() == parent);
	204
8869a0b4	205	pid = raw_clone(0);
e50221bf	206	assert_se(pid >= 0);
ee05e779 ZJS	207
	208	pid2 = raw_getpid();
	209	log_info("raw_clone: "PID_FMT" getpid()→"PID_FMT" raw_getpid()→"PID_FMT,
	210	pid, getpid(), pid2);
0289a5bc	211	if (pid == 0) {
e50221bf	212	assert_se(pid2 != parent);
0289a5bc FB	213	_exit(EXIT_SUCCESS);
	214	} else {
	215	int status;
	216
e50221bf	217	assert_se(pid2 == parent);
0289a5bc FB	218	waitpid(pid, &status, __WCLONE);
	219	assert_se(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
	220	}
ee05e779 ZJS	221	}
ee05e779 ZJS	222
d9ab2bcf LP	223	static void test_physical_memory(void) {
	224	uint64_t p;
	225	char buf[FORMAT_BYTES_MAX];
	226
	227	p = physical_memory();
	228	assert_se(p > 0);
	229	assert_se(p < UINT64_MAX);
	230	assert_se(p % page_size() == 0);
	231
d8cf2ac7 LP	232	log_info("Memory: %s (%" PRIu64 ")", format_bytes(buf, sizeof(buf), p), p);
	233	}
	234
	235	static void test_physical_memory_scale(void) {
	236	uint64_t p;
	237
	238	p = physical_memory();
	239
	240	assert_se(physical_memory_scale(0, 100) == 0);
	241	assert_se(physical_memory_scale(100, 100) == p);
	242
	243	log_info("Memory original: %" PRIu64, physical_memory());
	244	log_info("Memory scaled by 50%%: %" PRIu64, physical_memory_scale(50, 100));
	245	log_info("Memory divided by 2: %" PRIu64, physical_memory() / 2);
	246	log_info("Page size: %zu", page_size());
	247
	248	/* There might be an uneven number of pages, hence permit these calculations to be half a page off... */
	249	assert_se(page_size()/2 + physical_memory_scale(50, 100) - p/2 <= page_size());
	250	assert_se(physical_memory_scale(200, 100) == p*2);
	251
	252	assert_se(physical_memory_scale(0, 1) == 0);
	253	assert_se(physical_memory_scale(1, 1) == p);
	254	assert_se(physical_memory_scale(2, 1) == p*2);
	255
	256	assert_se(physical_memory_scale(0, 2) == 0);
	257
	258	assert_se(page_size()/2 + physical_memory_scale(1, 2) - p/2 <= page_size());
	259	assert_se(physical_memory_scale(2, 2) == p);
	260	assert_se(physical_memory_scale(4, 2) == p*2);
	261
	262	assert_se(physical_memory_scale(0, UINT32_MAX) == 0);
	263	assert_se(physical_memory_scale(UINT32_MAX, UINT32_MAX) == p);
	264
	265	/* overflow */
	266	assert_se(physical_memory_scale(UINT64_MAX/4, UINT64_MAX) == UINT64_MAX);
83f8e808 LP	267	}
	268
	269	static void test_system_tasks_max(void) {
	270	uint64_t t;
	271
	272	t = system_tasks_max();
	273	assert_se(t > 0);
	274	assert_se(t < UINT64_MAX);
	275
	276	log_info("Max tasks: %" PRIu64, t);
	277	}
	278
	279	static void test_system_tasks_max_scale(void) {
	280	uint64_t t;
	281
	282	t = system_tasks_max();
	283
	284	assert_se(system_tasks_max_scale(0, 100) == 0);
	285	assert_se(system_tasks_max_scale(100, 100) == t);
	286
	287	assert_se(system_tasks_max_scale(0, 1) == 0);
	288	assert_se(system_tasks_max_scale(1, 1) == t);
	289	assert_se(system_tasks_max_scale(2, 1) == 2*t);
	290
	291	assert_se(system_tasks_max_scale(0, 2) == 0);
	292	assert_se(system_tasks_max_scale(1, 2) == t/2);
	293	assert_se(system_tasks_max_scale(2, 2) == t);
	294	assert_se(system_tasks_max_scale(3, 2) == (3*t)/2);
	295	assert_se(system_tasks_max_scale(4, 2) == t*2);
	296
	297	assert_se(system_tasks_max_scale(0, UINT32_MAX) == 0);
	298	assert_se(system_tasks_max_scale((UINT32_MAX-1)/2, UINT32_MAX-1) == t/2);
	299	assert_se(system_tasks_max_scale(UINT32_MAX, UINT32_MAX) == t);
	300
	301	/* overflow */
d8cf2ac7	302
83f8e808	303	assert_se(system_tasks_max_scale(UINT64_MAX/4, UINT64_MAX) == UINT64_MAX);
d9ab2bcf LP	304	}
d9ab2bcf LP	305
539ad707	306	int main(int argc, char *argv[]) {
9480794b ZJS	307	log_parse_environment();
	308	log_open();
	309
625e870b	310	test_align_power2();
7242d742	311	test_max();
fb835651	312	test_container_of();
180a60bc	313	test_div_round_up();
144e51ec	314	test_u64log2();
2a371001	315	test_protect_errno();
cabb7806	316	test_in_set();
8fe90522	317	test_log2i();
ee05e779	318	test_raw_clone();
d9ab2bcf	319	test_physical_memory();
d8cf2ac7	320	test_physical_memory_scale();
83f8e808 LP	321	test_system_tasks_max();
83f8e808 LP	322	test_system_tasks_max_scale();
539ad707 TA	323
	324	return 0;
	325	}