1 // Copyright 2012 Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above copyright 11 // notice, this list of conditions and the following disclaimer in the 12 // documentation and/or other materials provided with the distribution. 13 // * Neither the name of Google Inc. nor the names of its contributors 14 // may be used to endorse or promote products derived from this software 15 // without specific prior written permission. 16 // 17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 29 #include "error.h" 30 31 #include <errno.h> 32 #include <stdint.h> 33 #include <stdio.h> 34 #include <stdlib.h> 35 #include <string.h> 36 37 #include <atf-c.h> 38 39 40 ATF_TC_WITHOUT_HEAD(error_new__oom); 41 ATF_TC_BODY(error_new__oom, tc) 42 { 43 void* invalid = (void*)1; 44 kyua_error_t error = kyua_error_new("test_error", invalid, SIZE_MAX, NULL); 45 ATF_REQUIRE(kyua_error_is_type(error, kyua_oom_error_type)); 46 ATF_REQUIRE(kyua_error_data(error) == NULL); 47 kyua_error_free(error); 48 } 49 50 51 ATF_TC_WITHOUT_HEAD(error_subsume__none); 52 ATF_TC_BODY(error_subsume__none, tc) 53 { 54 kyua_error_t primary = kyua_error_ok(); 55 kyua_error_t secondary = kyua_error_ok(); 56 ATF_REQUIRE(!kyua_error_is_set(kyua_error_subsume(primary, secondary))); 57 } 58 59 60 ATF_TC_WITHOUT_HEAD(error_subsume__primary); 61 ATF_TC_BODY(error_subsume__primary, tc) 62 { 63 kyua_error_t primary = kyua_error_new("primary_error", NULL, 0, NULL); 64 kyua_error_t secondary = kyua_error_new("secondary_error", NULL, 0, NULL); 65 kyua_error_t error = kyua_error_subsume(primary, secondary); 66 ATF_REQUIRE(kyua_error_is_type(error, "primary_error")); 67 kyua_error_free(error); 68 } 69 70 71 ATF_TC_WITHOUT_HEAD(error_subsume__secondary); 72 ATF_TC_BODY(error_subsume__secondary, tc) 73 { 74 kyua_error_t primary = kyua_error_ok(); 75 kyua_error_t secondary = kyua_error_new("secondary_error", NULL, 0, NULL); 76 kyua_error_t error = kyua_error_subsume(primary, secondary); 77 ATF_REQUIRE(kyua_error_is_type(error, "secondary_error")); 78 kyua_error_free(error); 79 } 80 81 82 ATF_TC_WITHOUT_HEAD(error_is_type__match); 83 ATF_TC_BODY(error_is_type__match, tc) 84 { 85 kyua_error_t error = kyua_error_new("test_error", NULL, 0, NULL); 86 ATF_REQUIRE(kyua_error_is_type(error, "test_error")); 87 kyua_error_free(error); 88 } 89 90 91 ATF_TC_WITHOUT_HEAD(error_is_type__not_match); 92 ATF_TC_BODY(error_is_type__not_match, tc) 93 { 94 kyua_error_t error = kyua_error_new("test_error", NULL, 0, NULL); 95 ATF_REQUIRE(!kyua_error_is_type(error, "test_erro")); 96 ATF_REQUIRE(!kyua_error_is_type(error, "test_error2")); 97 ATF_REQUIRE(!kyua_error_is_type(error, "foo")); 98 kyua_error_free(error); 99 } 100 101 102 ATF_TC_WITHOUT_HEAD(error_data__none); 103 ATF_TC_BODY(error_data__none, tc) 104 { 105 kyua_error_t error = kyua_error_new("test_error", NULL, 0, NULL); 106 ATF_REQUIRE(kyua_error_data(error) == NULL); 107 kyua_error_free(error); 108 } 109 110 111 ATF_TC_WITHOUT_HEAD(error_data__some); 112 ATF_TC_BODY(error_data__some, tc) 113 { 114 int data = 5; 115 kyua_error_t error = kyua_error_new("test_data_error", &data, sizeof(data), 116 NULL); 117 ATF_REQUIRE(kyua_error_data(error) != NULL); 118 ATF_REQUIRE_EQ(*((const int*)kyua_error_data(error)), 5); 119 kyua_error_free(error); 120 } 121 122 123 ATF_TC_WITHOUT_HEAD(error_is_set__no); 124 ATF_TC_BODY(error_is_set__no, tc) 125 { 126 kyua_error_t error = kyua_error_ok(); 127 ATF_REQUIRE(!kyua_error_is_set(error)); 128 } 129 130 131 ATF_TC_WITHOUT_HEAD(error_is_set__yes); 132 ATF_TC_BODY(error_is_set__yes, tc) 133 { 134 kyua_error_t error = kyua_error_new("test_error", NULL, 0, NULL); 135 ATF_REQUIRE(kyua_error_is_set(error)); 136 kyua_error_free(error); 137 } 138 139 140 ATF_TC_WITHOUT_HEAD(error_format__default); 141 ATF_TC_BODY(error_format__default, tc) 142 { 143 kyua_error_t error = kyua_error_new("test_error", NULL, 0, NULL); 144 char buffer[1024]; 145 kyua_error_format(error, buffer, sizeof(buffer)); 146 ATF_REQUIRE_STREQ("Error 'test_error'", buffer); 147 kyua_error_free(error); 148 } 149 150 151 /// Error-specific formatting function for testing purposes. 152 static int 153 test_format(const kyua_error_t error, char* const output_buffer, 154 const size_t output_size) 155 { 156 ATF_REQUIRE(kyua_error_is_type(error, "test_error")); 157 return snprintf(output_buffer, output_size, "Test formatting function"); 158 } 159 160 161 ATF_TC_WITHOUT_HEAD(error_format__custom__ok); 162 ATF_TC_BODY(error_format__custom__ok, tc) 163 { 164 kyua_error_t error = kyua_error_new("test_error", NULL, 0, test_format); 165 const char* exp_message = "Test formatting function"; 166 char buffer[1024]; 167 ATF_REQUIRE_EQ((int)strlen(exp_message), 168 kyua_error_format(error, buffer, sizeof(buffer))); 169 ATF_REQUIRE_STREQ(exp_message, buffer); 170 kyua_error_free(error); 171 } 172 173 174 ATF_TC_WITHOUT_HEAD(error_format__custom__error); 175 ATF_TC_BODY(error_format__custom__error, tc) 176 { 177 kyua_error_t error = kyua_error_new("test_error", NULL, 0, test_format); 178 char buffer[5]; 179 ATF_REQUIRE(kyua_error_format(error, buffer, sizeof(buffer)) 180 >= (int)sizeof(buffer)); 181 kyua_error_free(error); 182 } 183 184 185 ATF_TC_WITHOUT_HEAD(err); 186 ATF_TC_BODY(err, tc) 187 { 188 const pid_t pid = atf_utils_fork(); 189 if (pid == 0) { 190 kyua_error_t error = kyua_usage_error_new("A usage error"); 191 kyua_error_err(15, error, "The %s message", "1st"); 192 } 193 atf_utils_wait(pid, 15, "", "error_test: The 1st message: A usage error\n"); 194 } 195 196 197 ATF_TC_WITHOUT_HEAD(fprintf); 198 ATF_TC_BODY(fprintf, tc) 199 { 200 FILE* output = fopen("output", "w"); 201 const kyua_error_t error = kyua_usage_error_new("A usage error"); 202 kyua_error_fprintf(output, error, "The %s message", "1st"); 203 kyua_error_free(error); 204 fclose(output); 205 206 ATF_REQUIRE(atf_utils_grep_file("The 1st message: A usage error", 207 "output")); 208 } 209 210 211 ATF_TC_WITHOUT_HEAD(warn); 212 ATF_TC_BODY(warn, tc) 213 { 214 const pid_t pid = atf_utils_fork(); 215 if (pid == 0) { 216 kyua_error_t error = kyua_usage_error_new("A usage error"); 217 kyua_error_warn(error, "The %s message", "1st"); 218 kyua_error_free(error); 219 exit(51); 220 } 221 atf_utils_wait(pid, 51, "", "error_test: The 1st message: A usage error\n"); 222 } 223 224 225 ATF_TC_WITHOUT_HEAD(generic_error_type); 226 ATF_TC_BODY(generic_error_type, tc) 227 { 228 kyua_error_t error = kyua_generic_error_new("Nothing"); 229 ATF_REQUIRE(kyua_error_is_type(error, kyua_generic_error_type)); 230 kyua_error_free(error); 231 } 232 233 234 ATF_TC_WITHOUT_HEAD(generic_error_format__plain); 235 ATF_TC_BODY(generic_error_format__plain, tc) 236 { 237 kyua_error_t error = kyua_generic_error_new("Test message"); 238 char buffer[1024]; 239 kyua_error_format(error, buffer, sizeof(buffer)); 240 ATF_REQUIRE_STREQ("Test message", buffer); 241 kyua_error_free(error); 242 } 243 244 245 ATF_TC_WITHOUT_HEAD(generic_error_format__args); 246 ATF_TC_BODY(generic_error_format__args, tc) 247 { 248 kyua_error_t error = kyua_generic_error_new("%s message %d", "A", 123); 249 char buffer[1024]; 250 kyua_error_format(error, buffer, sizeof(buffer)); 251 ATF_REQUIRE_STREQ("A message 123", buffer); 252 kyua_error_free(error); 253 } 254 255 256 ATF_TC_WITHOUT_HEAD(libc_error_type); 257 ATF_TC_BODY(libc_error_type, tc) 258 { 259 kyua_error_t error = kyua_libc_error_new(ENOMEM, "Nothing"); 260 ATF_REQUIRE(kyua_error_is_type(error, kyua_libc_error_type)); 261 kyua_error_free(error); 262 } 263 264 265 ATF_TC_WITHOUT_HEAD(libc_error_errno); 266 ATF_TC_BODY(libc_error_errno, tc) 267 { 268 kyua_error_t error = kyua_libc_error_new(EPERM, "Doesn't matter"); 269 ATF_REQUIRE_EQ(EPERM, kyua_libc_error_errno(error)); 270 kyua_error_free(error); 271 } 272 273 274 ATF_TC_WITHOUT_HEAD(libc_error_format__plain); 275 ATF_TC_BODY(libc_error_format__plain, tc) 276 { 277 kyua_error_t error = kyua_libc_error_new(ENOMEM, "Test message"); 278 char buffer[1024]; 279 kyua_error_format(error, buffer, sizeof(buffer)); 280 ATF_REQUIRE(strstr(buffer, strerror(ENOMEM)) != NULL); 281 ATF_REQUIRE(strstr(buffer, "Test message") != NULL); 282 kyua_error_free(error); 283 } 284 285 286 ATF_TC_WITHOUT_HEAD(libc_error_format__args); 287 ATF_TC_BODY(libc_error_format__args, tc) 288 { 289 kyua_error_t error = kyua_libc_error_new(EPERM, "%s message %d", "A", 123); 290 char buffer[1024]; 291 kyua_error_format(error, buffer, sizeof(buffer)); 292 ATF_REQUIRE(strstr(buffer, strerror(EPERM)) != NULL); 293 ATF_REQUIRE(strstr(buffer, "A message 123") != NULL); 294 kyua_error_free(error); 295 } 296 297 298 ATF_TC_WITHOUT_HEAD(oom_error_type); 299 ATF_TC_BODY(oom_error_type, tc) 300 { 301 kyua_error_t error = kyua_oom_error_new(); 302 ATF_REQUIRE(kyua_error_is_type(error, kyua_oom_error_type)); 303 kyua_error_free(error); 304 } 305 306 307 ATF_TC_WITHOUT_HEAD(oom_error_data); 308 ATF_TC_BODY(oom_error_data, tc) 309 { 310 kyua_error_t error = kyua_oom_error_new(); 311 ATF_REQUIRE(kyua_error_data(error) == NULL); 312 kyua_error_free(error); 313 } 314 315 316 ATF_TC_WITHOUT_HEAD(oom_error_format); 317 ATF_TC_BODY(oom_error_format, tc) 318 { 319 kyua_error_t error = kyua_oom_error_new(); 320 char buffer[1024]; 321 kyua_error_format(error, buffer, sizeof(buffer)); 322 ATF_REQUIRE_STREQ("Not enough memory", buffer); 323 kyua_error_free(error); 324 } 325 326 327 ATF_TC_WITHOUT_HEAD(oom_error_reuse); 328 ATF_TC_BODY(oom_error_reuse, tc) 329 { 330 { 331 kyua_error_t error = kyua_oom_error_new(); 332 ATF_REQUIRE(kyua_error_is_type(error, kyua_oom_error_type)); 333 ATF_REQUIRE(kyua_error_data(error) == NULL); 334 kyua_error_free(error); 335 } 336 337 { 338 kyua_error_t error = kyua_oom_error_new(); 339 ATF_REQUIRE(kyua_error_is_type(error, kyua_oom_error_type)); 340 ATF_REQUIRE(kyua_error_data(error) == NULL); 341 kyua_error_free(error); 342 } 343 } 344 345 346 ATF_TC_WITHOUT_HEAD(usage_error_type); 347 ATF_TC_BODY(usage_error_type, tc) 348 { 349 kyua_error_t error = kyua_usage_error_new("Nothing"); 350 ATF_REQUIRE(kyua_error_is_type(error, kyua_usage_error_type)); 351 kyua_error_free(error); 352 } 353 354 355 ATF_TC_WITHOUT_HEAD(usage_error_format__plain); 356 ATF_TC_BODY(usage_error_format__plain, tc) 357 { 358 kyua_error_t error = kyua_usage_error_new("Test message"); 359 char buffer[1024]; 360 kyua_error_format(error, buffer, sizeof(buffer)); 361 ATF_REQUIRE_STREQ("Test message", buffer); 362 kyua_error_free(error); 363 } 364 365 366 ATF_TC_WITHOUT_HEAD(usage_error_format__args); 367 ATF_TC_BODY(usage_error_format__args, tc) 368 { 369 kyua_error_t error = kyua_usage_error_new("%s message %d", "A", 123); 370 char buffer[1024]; 371 kyua_error_format(error, buffer, sizeof(buffer)); 372 ATF_REQUIRE_STREQ("A message 123", buffer); 373 kyua_error_free(error); 374 } 375 376 377 ATF_TP_ADD_TCS(tp) 378 { 379 ATF_TP_ADD_TC(tp, error_new__oom); 380 ATF_TP_ADD_TC(tp, error_subsume__none); 381 ATF_TP_ADD_TC(tp, error_subsume__primary); 382 ATF_TP_ADD_TC(tp, error_subsume__secondary); 383 ATF_TP_ADD_TC(tp, error_is_type__match); 384 ATF_TP_ADD_TC(tp, error_is_type__not_match); 385 ATF_TP_ADD_TC(tp, error_data__none); 386 ATF_TP_ADD_TC(tp, error_data__some); 387 ATF_TP_ADD_TC(tp, error_is_set__no); 388 ATF_TP_ADD_TC(tp, error_is_set__yes); 389 ATF_TP_ADD_TC(tp, error_format__default); 390 ATF_TP_ADD_TC(tp, error_format__custom__ok); 391 ATF_TP_ADD_TC(tp, error_format__custom__error); 392 393 ATF_TP_ADD_TC(tp, err); 394 ATF_TP_ADD_TC(tp, fprintf); 395 ATF_TP_ADD_TC(tp, warn); 396 397 ATF_TP_ADD_TC(tp, generic_error_type); 398 ATF_TP_ADD_TC(tp, generic_error_format__plain); 399 ATF_TP_ADD_TC(tp, generic_error_format__args); 400 401 ATF_TP_ADD_TC(tp, libc_error_type); 402 ATF_TP_ADD_TC(tp, libc_error_errno); 403 ATF_TP_ADD_TC(tp, libc_error_format__plain); 404 ATF_TP_ADD_TC(tp, libc_error_format__args); 405 406 ATF_TP_ADD_TC(tp, oom_error_type); 407 ATF_TP_ADD_TC(tp, oom_error_data); 408 ATF_TP_ADD_TC(tp, oom_error_format); 409 ATF_TP_ADD_TC(tp, oom_error_reuse); 410 411 ATF_TP_ADD_TC(tp, usage_error_type); 412 ATF_TP_ADD_TC(tp, usage_error_format__plain); 413 ATF_TP_ADD_TC(tp, usage_error_format__args); 414 415 return atf_no_error(); 416 } 417