/***
This file is part of systemd.
Copyright 2010 Lennart Poettering
Copyright 2013 Thomas H.P. Andersen
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 <fcntl.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "cpu-set-util.h"
#include "def.h"
#include "escape.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "fstab-util.h"
#include "glob-util.h"
#include "hexdecoct.h"
#include "io-util.h"
#include "mkdir.h"
#include "parse-util.h"
#include "path-util.h"
#include "proc-cmdline.h"
#include "process-util.h"
#include "rm-rf.h"
#include "signal-util.h"
#include "special.h"
#include "stat-util.h"
#include "string-util.h"
#include "strv.h"
#include "user-util.h"
#include "util.h"
#include "virt.h"
#include "web-util.h"
#include "xattr-util.h"
static void test_streq_ptr(void) {
}
static void test_align_power2(void) {
unsigned long i, p2;
assert_se(ALIGN_POWER2(0) == 0);
for (i = 1; i < 131071; ++i) {
/* empty */ ;
}
/* empty */ ;
}
}
static void test_max(void) {
static const struct {
int a;
} val1 = {
};
int d = 0;
/* CONST_MAX returns (void) instead of a value if the passed arguments
* are not of the same type or not constant expressions. */
assert_se(d == 1);
}
static void test_container_of(void) {
struct mytype {
struct mytype,
struct mytype,
}
static void test_alloca(void) {
char *t;
memzero(t, 17);
}
static void test_div_round_up(void) {
int div;
/* basic tests */
/* test multiple evaluation */
div = 0;
/* overflow test with exact division */
assert_se(sizeof(0U) == 4);
/* overflow test with rounded division */
}
static void test_first_word(void) {
}
static void test_close_many(void) {
}
static void test_parse_uid(void) {
int r;
assert_se(r == 0);
}
static void test_strappend(void) {
}
static void test_strstrip(void) {
char *r;
}
static void test_delete_chars(void) {
char *r;
}
static void test_in_charset(void) {
}
static void test_hexchar(void) {
}
static void test_unhexchar(void) {
}
static void test_base32hexchar(void) {
}
static void test_unbase32hexchar(void) {
}
static void test_base64char(void) {
}
static void test_unbase64char(void) {
}
static void test_octchar(void) {
}
static void test_unoctchar(void) {
}
static void test_decchar(void) {
}
static void test_undecchar(void) {
}
static void test_unhexmem(void) {
}
/* https://tools.ietf.org/html/rfc4648#section-10 */
static void test_base32hexmem(void) {
char *b32;
}
static void test_unbase32hexmem(void) {
void *mem;
assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), false, &mem, &len) == -EINVAL);
}
/* https://tools.ietf.org/html/rfc4648#section-10 */
static void test_base64mem(void) {
char *b64;
}
static void test_unbase64mem(void) {
void *mem;
}
static void test_cescape(void) {
}
static void test_cunescape(void) {
assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", 0, &unescaped) < 0);
assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", UNESCAPE_RELAX, &unescaped) >= 0);
/* incomplete sequences */
}
static void test_foreach_word(void) {
size_t l;
int i = 0;
const char * const expected[] = {
"test",
"abc",
"d",
"e",
"f",
"",
};
}
size_t l;
int i = 0;
_cleanup_free_ char *t = NULL;
printf("<%s>\n", t);
}
}
static void test_foreach_word_quoted(void) {
check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",
STRV_MAKE("test",
"a",
"b",
"c",
"d",
"e",
"",
"",
"hhh",
"",
"",
"a b c"),
false);
check("test \"xxx",
STRV_MAKE("test"),
true);
check("test\\",
true);
}
static void test_memdup_multiply(void) {
int *dup;
}
static void test_u64log2(void) {
}
static void test_protect_errno(void) {
errno = 12;
{
errno = 11;
}
}
static void test_parse_cpu_set(void) {
int ncpus;
int cpu;
/* Simple range (from CPUAffinity example) */
c = mfree(c);
/* A more interesting range */
c = mfree(c);
/* Quoted strings */
c = mfree(c);
/* Use commas as separators */
c = mfree(c);
/* Commas with spaces (and trailing comma, space) */
c = mfree(c);
/* Ranges */
c = mfree(c);
/* Ranges with trailing comma, space */
c = mfree(c);
/* Negative range (returns empty cpu_set) */
c = mfree(c);
/* Overlapping ranges */
c = mfree(c);
/* Mix ranges and individual CPUs */
c = mfree(c);
/* Garbage */
assert_se(!c);
/* Range with garbage */
assert_se(!c);
/* Empty string */
c = NULL;
assert_se(!c);
/* Runnaway quoted string */
assert_se(!c);
}
static void test_config_parse_iec_uint64(void) {
assert_se(config_parse_iec_uint64(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset, NULL) == 0);
assert_se(config_parse_iec_uint64(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset, NULL) == 0);
}
static void test_strextend(void) {
}
static void test_strrep(void) {
}
static void test_split_pair(void) {
free(a);
free(b);
free(a);
free(b);
}
static void test_fstab_node_to_udev_node(void) {
char *n;
n = fstab_node_to_udev_node("LABEL=applé/jack");
puts(n);
free(n);
n = fstab_node_to_udev_node("PARTLABEL=pinkié pie");
puts(n);
free(n);
n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
puts(n);
free(n);
n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
puts(n);
free(n);
n = fstab_node_to_udev_node("PONIES=awesome");
puts(n);
free(n);
n = fstab_node_to_udev_node("/dev/xda1");
puts(n);
free(n);
}
static void test_get_files_in_directory(void) {
}
static void test_in_set(void) {
}
static void test_writing_tmpfile(void) {
int fd, r;
assert_se(r >= 0);
assert_se(r == 0);
}
static void test_hexdump(void) {
unsigned i;
for (i = 0; i < ELEMENTSOF(data); i++)
data[i] = i*2;
}
static void test_log2i(void) {
}
static void test_foreach_string(void) {
const char * const t[] = {
"foo",
"bar",
"waldo",
};
const char *x;
unsigned i = 0;
assert_se(i == 3);
FOREACH_STRING(x, "zzz")
}
static void test_filename_is_valid(void) {
int i;
for (i=0; i<FILENAME_MAX+1; i++)
foo[i] = 'a';
}
static void test_string_has_cc(void) {
}
static void test_ascii_strlower(void) {
char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
}
static void test_files_same(void) {
}
static void test_is_valid_documentation_url(void) {
}
static void test_file_in_same_dir(void) {
char *t;
free(t);
free(t);
free(t);
free(t);
free(t);
}
static void test_endswith(void) {
}
static void test_endswith_no_case(void) {
}
static void test_close_nointr(void) {
int fd;
}
static void test_unlink_noerrno(void) {
int fd;
{
errno = -42;
}
}
static void test_readlink_and_make_absolute(void) {
char *r = NULL;
free(r);
free(r);
}
static void test_ignore_signals(void) {
}
static void test_strshorten(void) {
char s[] = "foobar";
}
static void test_strjoina(void) {
char *actual;
}
static void test_is_symlink(void) {
}
static void test_search_and_fopen(void) {
int r;
FILE *f;
assert_se(r >= 0);
fclose(f);
assert_se(r >= 0);
fclose(f);
assert_se(r >= 0);
fclose(f);
assert_se(r < 0);
assert_se(r < 0);
assert_se(r == 0);
assert_se(r < 0);
}
static void test_search_and_fopen_nulstr(void) {
int r;
FILE *f;
assert_se(r >= 0);
fclose(f);
assert_se(r >= 0);
fclose(f);
assert_se(r < 0);
assert_se(r < 0);
assert_se(r == 0);
assert_se(r < 0);
}
static void test_glob_exists(void) {
int r;
r = glob_exists("/tmp/test-glob_exists*");
assert_se(r == 1);
assert_se(r == 0);
r = glob_exists("/tmp/test-glob_exists*");
assert_se(r == 0);
}
static void test_execute_directory(void) {
assert_se(write_string_file(name, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works", WRITE_STRING_FILE_CREATE) == 0);
assert_se(write_string_file(name2, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2", WRITE_STRING_FILE_CREATE) == 0);
assert_se(write_string_file(overridden, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
assert_se(write_string_file(override, "#!/bin/sh\necho 'Executing '$0", WRITE_STRING_FILE_CREATE) == 0);
assert_se(write_string_file(masked, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
}
return 0;
}
static void test_parse_proc_cmdline(void) {
}
static void test_raw_clone(void) {
pid2 = raw_getpid();
if (pid == 0) {
} else {
int status;
}
}
static void test_same_fd(void) {
}
static void test_uid_ptr(void) {
}
char check[n];
}
static void test_sparse_write(void) {
const char test_d[] = "\0\0test\0\0\0test\0\0\0\0test\0\0\0\0\0test\0\0\0test\0\0\0\0test\0\0\0\0\0\0\0\0";
}
_cleanup_free_ char *r;
}
static void test_shell_escape(void) {
}
_cleanup_free_ char *r;
assert_se(r = shell_maybe_quote(s));
}
static void test_shell_maybe_quote(void) {
}
static void test_tempfn(void) {
}
static void test_strcmp_ptr(void) {
}
static void test_fgetxattrat_fake(void) {
char t[] = "/var/tmp/xattrtestXXXXXX";
const char *x;
char v[3] = {};
int r;
x = strjoina(t, "/test");
goto cleanup;
assert_se(r >= 0);
safe_close(fd);
}
static void test_runlevel_to_target(void) {
}
log_open();
test_max();
test_alloca();
test_hexchar();
test_octchar();
test_decchar();
test_cescape();
test_u64log2();
test_strrep();
test_in_set();
test_hexdump();
test_log2i();
test_same_fd();
test_uid_ptr();
test_tempfn();
return 0;
}