src/test/test-util.c

   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
  21 #include <errno.h>
  22 #include <string.h>
  23 #include <sys/wait.h>
  24 #include <unistd.h>
  25
  26 #include "def.h"
  27 #include "fileio.h"
  28 #include "fs-util.h"
  29 #include "parse-util.h"
  30 #include "raw-clone.h"
  31 #include "rm-rf.h"
  32 #include "string-util.h"
  33 #include "util.h"
  34
  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
  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));
  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);
  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));
  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);
 105 }
 106
 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
 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
 158 static void test_u64log2(void) {
 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);
 166 }
 167
 168 static void test_protect_errno(void) {
 169         errno = 12;
 170         {
 171                 PROTECT_ERRNO;
 172                 errno = 11;
 173         }
 174         assert_se(errno == 12);
 175 }
 176
 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
 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
 198 static void test_execute_directory(void) {
 199         char template_lo[] = "/tmp/test-readlink_and_make_absolute-lo.XXXXXXX";
 200         char template_hi[] = "/tmp/test-readlink_and_make_absolute-hi.XXXXXXX";
 201         const char * dirs[] = {template_hi, template_lo, NULL};
 202         const char *name, *name2, *name3, *overridden, *override, *masked, *mask;
 203
 204         assert_se(mkdtemp(template_lo));
 205         assert_se(mkdtemp(template_hi));
 206
 207         name = strjoina(template_lo, "/script");
 208         name2 = strjoina(template_hi, "/script2");
 209         name3 = strjoina(template_lo, "/useless");
 210         overridden = strjoina(template_lo, "/overridden");
 211         override = strjoina(template_hi, "/overridden");
 212         masked = strjoina(template_lo, "/masked");
 213         mask = strjoina(template_hi, "/masked");
 214
 215         assert_se(write_string_file(name, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works", WRITE_STRING_FILE_CREATE) == 0);
 216         assert_se(write_string_file(name2, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2", WRITE_STRING_FILE_CREATE) == 0);
 217         assert_se(write_string_file(overridden, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
 218         assert_se(write_string_file(override, "#!/bin/sh\necho 'Executing '$0", WRITE_STRING_FILE_CREATE) == 0);
 219         assert_se(write_string_file(masked, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
 220         assert_se(symlink("/dev/null", mask) == 0);
 221         assert_se(chmod(name, 0755) == 0);
 222         assert_se(chmod(name2, 0755) == 0);
 223         assert_se(chmod(overridden, 0755) == 0);
 224         assert_se(chmod(override, 0755) == 0);
 225         assert_se(chmod(masked, 0755) == 0);
 226         assert_se(touch(name3) >= 0);
 227
 228         execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL);
 229
 230         assert_se(chdir(template_lo) == 0);
 231         assert_se(access("it_works", F_OK) >= 0);
 232         assert_se(access("failed", F_OK) < 0);
 233
 234         assert_se(chdir(template_hi) == 0);
 235         assert_se(access("it_works2", F_OK) >= 0);
 236         assert_se(access("failed", F_OK) < 0);
 237
 238         (void) rm_rf(template_lo, REMOVE_ROOT|REMOVE_PHYSICAL);
 239         (void) rm_rf(template_hi, REMOVE_ROOT|REMOVE_PHYSICAL);
 240 }
 241
 242 static void test_raw_clone(void) {
 243         pid_t parent, pid, pid2;
 244
 245         parent = getpid();
 246         log_info("before clone: getpid()→"PID_FMT, parent);
 247         assert_se(raw_getpid() == parent);
 248
 249         pid = raw_clone(0);
 250         assert_se(pid >= 0);
 251
 252         pid2 = raw_getpid();
 253         log_info("raw_clone: "PID_FMT" getpid()→"PID_FMT" raw_getpid()→"PID_FMT,
 254                  pid, getpid(), pid2);
 255         if (pid == 0) {
 256                 assert_se(pid2 != parent);
 257                 _exit(EXIT_SUCCESS);
 258         } else {
 259                 int status;
 260
 261                 assert_se(pid2 == parent);
 262                 waitpid(pid, &status, __WCLONE);
 263                 assert_se(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
 264         }
 265 }
 266
 267 static void test_physical_memory(void) {
 268         uint64_t p;
 269         char buf[FORMAT_BYTES_MAX];
 270
 271         p = physical_memory();
 272         assert_se(p > 0);
 273         assert_se(p < UINT64_MAX);
 274         assert_se(p % page_size() == 0);
 275
 276         log_info("Memory: %s (%" PRIu64 ")", format_bytes(buf, sizeof(buf), p), p);
 277 }
 278
 279 static void test_physical_memory_scale(void) {
 280         uint64_t p;
 281
 282         p = physical_memory();
 283
 284         assert_se(physical_memory_scale(0, 100) == 0);
 285         assert_se(physical_memory_scale(100, 100) == p);
 286
 287         log_info("Memory original: %" PRIu64, physical_memory());
 288         log_info("Memory scaled by 50%%: %" PRIu64, physical_memory_scale(50, 100));
 289         log_info("Memory divided by 2: %" PRIu64, physical_memory() / 2);
 290         log_info("Page size: %zu", page_size());
 291
 292         /* There might be an uneven number of pages, hence permit these calculations to be half a page off... */
 293         assert_se(page_size()/2 + physical_memory_scale(50, 100) - p/2 <= page_size());
 294         assert_se(physical_memory_scale(200, 100) == p*2);
 295
 296         assert_se(physical_memory_scale(0, 1) == 0);
 297         assert_se(physical_memory_scale(1, 1) == p);
 298         assert_se(physical_memory_scale(2, 1) == p*2);
 299
 300         assert_se(physical_memory_scale(0, 2) == 0);
 301
 302         assert_se(page_size()/2 + physical_memory_scale(1, 2) - p/2 <= page_size());
 303         assert_se(physical_memory_scale(2, 2) == p);
 304         assert_se(physical_memory_scale(4, 2) == p*2);
 305
 306         assert_se(physical_memory_scale(0, UINT32_MAX) == 0);
 307         assert_se(physical_memory_scale(UINT32_MAX, UINT32_MAX) == p);
 308
 309         /* overflow */
 310         assert_se(physical_memory_scale(UINT64_MAX/4, UINT64_MAX) == UINT64_MAX);
 311 }
 312
 313 static void test_system_tasks_max(void) {
 314         uint64_t t;
 315
 316         t = system_tasks_max();
 317         assert_se(t > 0);
 318         assert_se(t < UINT64_MAX);
 319
 320         log_info("Max tasks: %" PRIu64, t);
 321 }
 322
 323 static void test_system_tasks_max_scale(void) {
 324         uint64_t t;
 325
 326         t = system_tasks_max();
 327
 328         assert_se(system_tasks_max_scale(0, 100) == 0);
 329         assert_se(system_tasks_max_scale(100, 100) == t);
 330
 331         assert_se(system_tasks_max_scale(0, 1) == 0);
 332         assert_se(system_tasks_max_scale(1, 1) == t);
 333         assert_se(system_tasks_max_scale(2, 1) == 2*t);
 334
 335         assert_se(system_tasks_max_scale(0, 2) == 0);
 336         assert_se(system_tasks_max_scale(1, 2) == t/2);
 337         assert_se(system_tasks_max_scale(2, 2) == t);
 338         assert_se(system_tasks_max_scale(3, 2) == (3*t)/2);
 339         assert_se(system_tasks_max_scale(4, 2) == t*2);
 340
 341         assert_se(system_tasks_max_scale(0, UINT32_MAX) == 0);
 342         assert_se(system_tasks_max_scale((UINT32_MAX-1)/2, UINT32_MAX-1) == t/2);
 343         assert_se(system_tasks_max_scale(UINT32_MAX, UINT32_MAX) == t);
 344
 345         /* overflow */
 346
 347         assert_se(system_tasks_max_scale(UINT64_MAX/4, UINT64_MAX) == UINT64_MAX);
 348 }
 349
 350 int main(int argc, char *argv[]) {
 351         log_parse_environment();
 352         log_open();
 353
 354         test_align_power2();
 355         test_max();
 356         test_container_of();
 357         test_div_round_up();
 358         test_u64log2();
 359         test_protect_errno();
 360         test_in_set();
 361         test_log2i();
 362         test_execute_directory();
 363         test_raw_clone();
 364         test_physical_memory();
 365         test_physical_memory_scale();
 366         test_system_tasks_max();
 367         test_system_tasks_max_scale();
 368
 369         return 0;
 370 }