1 /* 2 * Copyright (C) 2012-2013 ProFUSION embedded systems 3 * Copyright (C) 2012 Pedro Pedruzzi 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU Lesser General Public 7 * License as published by the Free Software Foundation; either 8 * version 2.1 of the License, or (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public 16 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 17 */ 18 19 #include <fcntl.h> 20 #include <stdbool.h> 21 #include <stdio.h> 22 #include <stdlib.h> 23 #include <string.h> 24 #include <unistd.h> 25 #include <sys/stat.h> 26 #include <sys/types.h> 27 28 #include <shared/util.h> 29 30 #include "testsuite.h" 31 32 static int alias_1(const struct test *t) 33 { 34 static const char *input[] = { 35 "test1234", 36 "test[abcfoobar]2211", 37 "bar[aaa][bbbb]sss", 38 "kmod[p.b]lib", 39 "[az]1234[AZ]", 40 NULL, 41 }; 42 43 char buf[PATH_MAX]; 44 size_t len; 45 const char **alias; 46 47 for (alias = input; *alias != NULL; alias++) { 48 int ret; 49 50 ret = alias_normalize(*alias, buf, &len); 51 printf("input %s\n", *alias); 52 printf("return %d\n", ret); 53 54 if (ret == 0) { 55 printf("len %zu\n", len); 56 printf("output %s\n", buf); 57 } 58 59 printf("\n"); 60 } 61 62 return EXIT_SUCCESS; 63 } 64 DEFINE_TEST(alias_1, 65 .description = "check if alias_normalize does the right thing", 66 .config = { 67 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-util/", 68 }, 69 .need_spawn = true, 70 .output = { 71 .out = TESTSUITE_ROOTFS "test-util/alias-correct.txt", 72 }); 73 74 static int test_freadline_wrapped(const struct test *t) 75 { 76 FILE *fp = fopen("/freadline_wrapped-input.txt", "re"); 77 78 if (!fp) 79 return EXIT_FAILURE; 80 81 while (!feof(fp) && !ferror(fp)) { 82 unsigned int num = 0; 83 char *s = freadline_wrapped(fp, &num); 84 if (!s) 85 break; 86 puts(s); 87 free(s); 88 printf("%u\n", num); 89 } 90 91 fclose(fp); 92 return EXIT_SUCCESS; 93 } 94 DEFINE_TEST(test_freadline_wrapped, 95 .description = "check if freadline_wrapped() does the right thing", 96 .config = { 97 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-util/", 98 }, 99 .need_spawn = true, 100 .output = { 101 .out = TESTSUITE_ROOTFS "test-util/freadline_wrapped-correct.txt", 102 }); 103 104 static int test_strchr_replace(const struct test *t) 105 { 106 _cleanup_free_ char *s = strdup("this is a test string"); 107 const char *res = "thiC iC a teCt Ctring"; 108 109 strchr_replace(s, 's', 'C'); 110 assert_return(streq(s, res), EXIT_FAILURE); 111 112 return EXIT_SUCCESS; 113 } 114 DEFINE_TEST(test_strchr_replace, 115 .description = "check implementation of strchr_replace()", 116 .need_spawn = false, 117 ); 118 119 static int test_underscores(const struct test *t) 120 { 121 struct teststr { 122 char *val; 123 const char *res; 124 } teststr[] = { 125 { strdup("aa-bb-cc_"), "aa_bb_cc_" }, 126 { strdup("-aa-bb-cc-"), "_aa_bb_cc_" }, 127 { strdup("-aa[-bb-]cc-"), "_aa[-bb-]cc_" }, 128 { strdup("-aa-[bb]-cc-"), "_aa_[bb]_cc_" }, 129 { strdup("-aa-[b-b]-cc-"), "_aa_[b-b]_cc_" }, 130 { strdup("-aa-b[-]b-cc"), "_aa_b[-]b_cc" }, 131 { } 132 }, *iter; 133 134 for (iter = &teststr[0]; iter->val != NULL; iter++) { 135 _cleanup_free_ char *val = iter->val; 136 underscores(val); 137 assert_return(streq(val, iter->res), EXIT_FAILURE); 138 } 139 140 return EXIT_SUCCESS; 141 } 142 DEFINE_TEST(test_underscores, 143 .description = "check implementation of underscores()", 144 .need_spawn = false, 145 ); 146 147 static int test_path_ends_with_kmod_ext(const struct test *t) 148 { 149 struct teststr { 150 const char *val; 151 bool res; 152 } teststr[] = { 153 { "/bla.ko", true }, 154 #ifdef ENABLE_ZLIB 155 { "/bla.ko.gz", true }, 156 #endif 157 #ifdef ENABLE_XZ 158 { "/bla.ko.xz", true }, 159 #endif 160 { "/bla.ko.x", false }, 161 { "/bla.ko.", false }, 162 { "/bla.koz", false }, 163 { "/b", false }, 164 { } 165 }, *iter; 166 167 for (iter = &teststr[0]; iter->val != NULL; iter++) { 168 assert_return(path_ends_with_kmod_ext(iter->val, 169 strlen(iter->val)) == iter->res, 170 EXIT_FAILURE); 171 } 172 173 return EXIT_SUCCESS; 174 } 175 DEFINE_TEST(test_path_ends_with_kmod_ext, 176 .description = "check implementation of path_ends_with_kmod_ext()", 177 .need_spawn = false, 178 ); 179 180 #define TEST_WRITE_STR_SAFE_FILE "/write-str-safe" 181 #define TEST_WRITE_STR_SAFE_PATH TESTSUITE_ROOTFS "test-util2/" TEST_WRITE_STR_SAFE_FILE 182 static int test_write_str_safe(const struct test *t) 183 { 184 const char *s = "test"; 185 int fd; 186 187 fd = open(TEST_WRITE_STR_SAFE_FILE ".txt", O_CREAT|O_TRUNC|O_WRONLY, 0644); 188 assert_return(fd >= 0, EXIT_FAILURE); 189 190 write_str_safe(fd, s, strlen(s)); 191 close(fd); 192 193 return EXIT_SUCCESS; 194 } 195 DEFINE_TEST(test_write_str_safe, 196 .description = "check implementation of write_str_safe()", 197 .config = { 198 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-util2/", 199 }, 200 .need_spawn = true, 201 .output = { 202 .files = (const struct keyval[]) { 203 { TEST_WRITE_STR_SAFE_PATH ".txt", 204 TEST_WRITE_STR_SAFE_PATH "-correct.txt" }, 205 { } 206 }, 207 }); 208 209 static int test_addu64_overflow(const struct test *t) 210 { 211 uint64_t res; 212 bool overflow; 213 214 overflow = addu64_overflow(UINT64_MAX - 1, 1, &res); 215 assert_return(!overflow, EXIT_FAILURE); 216 assert_return(res == UINT64_MAX, EXIT_FAILURE); 217 218 overflow = addu64_overflow(UINT64_MAX, 1, &res); 219 assert_return(overflow, EXIT_FAILURE); 220 221 return EXIT_SUCCESS; 222 } 223 DEFINE_TEST(test_addu64_overflow, 224 .description = "check implementation of addu4_overflow()", 225 .need_spawn = false, 226 ); 227 228 229 TESTSUITE_MAIN(); 230
