external/bsd/bind/dist/unit/atf-src/atf-c/error_test.c

   1 /*      $NetBSD: error_test.c,v 1.3 2014/12/10 04:38:03 christos Exp $  */
   2
   3 /*
   4  * Automated Testing Framework (atf)
   5  *
   6  * Copyright (c) 2008 The NetBSD Foundation, Inc.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  19  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  25  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  27  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  28  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  29  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <errno.h>
  33 #include <stdint.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36
  37 #include <atf-c.h>
  38
  39 #include "atf-c/defs.h"
  40 #include "atf-c/error.h"
  41
  42 #include "detail/test_helpers.h"
  43
  44 /* ---------------------------------------------------------------------
  45  * Auxiliary functions.
  46  * --------------------------------------------------------------------- */
  47
  48 static
  49 void
  50 test_format(const atf_error_t err ATF_DEFS_ATTRIBUTE_UNUSED,
  51             char *buf, size_t buflen)
  52 {
  53     snprintf(buf, buflen, "Test formatting function");
  54 }
  55
  56 /* ---------------------------------------------------------------------
  57  * Tests for the "atf_error" type.
  58  * --------------------------------------------------------------------- */
  59
  60 ATF_TC(error_new);
  61 ATF_TC_HEAD(error_new, tc)
  62 {
  63     atf_tc_set_md_var(tc, "descr", "Checks the construction of an error "
  64                       "object");
  65 }
  66 ATF_TC_BODY(error_new, tc)
  67 {
  68     atf_error_t err;
  69     int data;
  70
  71     err = atf_error_new("test_error", NULL, 0, NULL);
  72     ATF_REQUIRE(atf_error_is(err, "test_error"));
  73     ATF_REQUIRE(!atf_error_is(err, "unknown_error"));
  74     ATF_REQUIRE(atf_error_data(err) == NULL);
  75     atf_error_free(err);
  76
  77     data = 5;
  78     err = atf_error_new("test_data_error", &data, sizeof(data), NULL);
  79     ATF_REQUIRE(atf_error_is(err, "test_data_error"));
  80     ATF_REQUIRE(!atf_error_is(err, "unknown_error"));
  81     ATF_REQUIRE(atf_error_data(err) != NULL);
  82     ATF_REQUIRE_EQ(*((const int *)atf_error_data(err)), 5);
  83     atf_error_free(err);
  84 }
  85
  86 ATF_TC(error_new_wo_memory);
  87 ATF_TC_HEAD(error_new_wo_memory, tc)
  88 {
  89     atf_tc_set_md_var(tc, "descr", "Checks that an unavailable memory error "
  90                       "raised when constructing an error object "
  91                             "is properly converted to the no_memory "
  92                             "static error type");
  93 }
  94 ATF_TC_BODY(error_new_wo_memory, tc)
  95 {
  96     atf_error_t err;
  97     void *invalid;
  98
  99     invalid = (void *)1;
 100
 101     err = atf_error_new("test_error", invalid, SIZE_MAX, NULL);
 102     ATF_REQUIRE(atf_error_is(err, "no_memory"));
 103     ATF_REQUIRE(atf_error_data(err) == NULL);
 104     atf_error_free(err);
 105 }
 106
 107 ATF_TC(no_error);
 108 ATF_TC_HEAD(no_error, tc)
 109 {
 110     atf_tc_set_md_var(tc, "descr", "Checks that constructing a non-error "
 111                       "object works");
 112 }
 113 ATF_TC_BODY(no_error, tc)
 114 {
 115     atf_error_t err;
 116
 117     err = atf_no_error();
 118     ATF_REQUIRE(!atf_is_error(err));
 119 }
 120
 121 ATF_TC(is_error);
 122 ATF_TC_HEAD(is_error, tc)
 123 {
 124     atf_tc_set_md_var(tc, "descr", "Checks the is_error method to determine "
 125                       "if an error object holds success or an error");
 126 }
 127 ATF_TC_BODY(is_error, tc)
 128 {
 129     atf_error_t err;
 130
 131     err = atf_no_error();
 132     ATF_REQUIRE(!atf_is_error(err));
 133
 134     err = atf_error_new("test_error", NULL, 0, NULL);
 135     ATF_REQUIRE(atf_is_error(err));
 136     atf_error_free(err);
 137 }
 138
 139 ATF_TC(format);
 140 ATF_TC_HEAD(format, tc)
 141 {
 142     atf_tc_set_md_var(tc, "descr", "Checks the default formatting function "
 143                       "and the ability to change it");
 144 }
 145 ATF_TC_BODY(format, tc)
 146 {
 147     atf_error_t err;
 148     char buf[1024];
 149
 150     printf("Testing default formatting function\n");
 151     err = atf_error_new("test_error", NULL, 0, NULL);
 152     atf_error_format(err, buf, sizeof(buf));
 153     printf("Error string is: %s\n", buf);
 154     ATF_REQUIRE(strcmp(buf, "Error 'test_error'") == 0);
 155     atf_error_free(err);
 156
 157     printf("Testing custom formatting function\n");
 158     err = atf_error_new("test_error", NULL, 0, test_format);
 159     atf_error_format(err, buf, sizeof(buf));
 160     printf("Error string is: %s\n", buf);
 161     ATF_REQUIRE(strcmp(buf, "Test formatting function") == 0);
 162     atf_error_free(err);
 163 }
 164
 165 /* ---------------------------------------------------------------------
 166  * Tests for the "libc" error.
 167  * --------------------------------------------------------------------- */
 168
 169 ATF_TC(libc_new);
 170 ATF_TC_HEAD(libc_new, tc)
 171 {
 172     atf_tc_set_md_var(tc, "descr", "Checks the construction of libc errors");
 173 }
 174 ATF_TC_BODY(libc_new, tc)
 175 {
 176     atf_error_t err;
 177
 178     err = atf_libc_error(ENOMEM, "Test message 1");
 179     ATF_REQUIRE(atf_error_is(err, "libc"));
 180     ATF_REQUIRE_EQ(atf_libc_error_code(err), ENOMEM);
 181     ATF_REQUIRE(strcmp(atf_libc_error_msg(err), "Test message 1") == 0);
 182     atf_error_free(err);
 183
 184     err = atf_libc_error(EPERM, "%s message %d", "Test", 2);
 185     ATF_REQUIRE(atf_error_is(err, "libc"));
 186     ATF_REQUIRE_EQ(atf_libc_error_code(err), EPERM);
 187     ATF_REQUIRE(strcmp(atf_libc_error_msg(err), "Test message 2") == 0);
 188     atf_error_free(err);
 189 }
 190
 191 ATF_TC(libc_format);
 192 ATF_TC_HEAD(libc_format, tc)
 193 {
 194     atf_tc_set_md_var(tc, "descr", "Checks the formatting of libc errors");
 195 }
 196 ATF_TC_BODY(libc_format, tc)
 197 {
 198     atf_error_t err;
 199     char buf[1024];
 200
 201     err = atf_libc_error(ENOMEM, "Test message 1");
 202     atf_error_format(err, buf, sizeof(buf));
 203     ATF_REQUIRE(strstr(buf, strerror(ENOMEM)) != NULL);
 204     ATF_REQUIRE(strstr(buf, "Test message 1") != NULL);
 205     atf_error_free(err);
 206
 207     err = atf_libc_error(EPERM, "Test message 2");
 208     atf_error_format(err, buf, sizeof(buf));
 209     ATF_REQUIRE(strstr(buf, strerror(EPERM)) != NULL);
 210     ATF_REQUIRE(strstr(buf, "Test message 2") != NULL);
 211     atf_error_free(err);
 212
 213     err = atf_libc_error(EPERM, "%s message %d", "Test", 3);
 214     atf_error_format(err, buf, sizeof(buf));
 215     ATF_REQUIRE(strstr(buf, strerror(EPERM)) != NULL);
 216     ATF_REQUIRE(strstr(buf, "Test message 3") != NULL);
 217     atf_error_free(err);
 218 }
 219
 220 /* ---------------------------------------------------------------------
 221  * Tests for the "no_memory" error.
 222  * --------------------------------------------------------------------- */
 223
 224 ATF_TC(no_memory_new);
 225 ATF_TC_HEAD(no_memory_new, tc)
 226 {
 227     atf_tc_set_md_var(tc, "descr", "Checks the construction of no_memory "
 228                       "errors");
 229 }
 230 ATF_TC_BODY(no_memory_new, tc)
 231 {
 232     atf_error_t err;
 233
 234     err = atf_no_memory_error();
 235     ATF_REQUIRE(atf_error_is(err, "no_memory"));
 236     ATF_REQUIRE(atf_error_data(err) == NULL);
 237     atf_error_free(err);
 238 }
 239
 240 ATF_TC(no_memory_format);
 241 ATF_TC_HEAD(no_memory_format, tc)
 242 {
 243     atf_tc_set_md_var(tc, "descr", "Checks the formatting of no_memory "
 244                       "errors");
 245 }
 246 ATF_TC_BODY(no_memory_format, tc)
 247 {
 248     atf_error_t err;
 249     char buf[1024];
 250
 251     err = atf_no_memory_error();
 252     atf_error_format(err, buf, sizeof(buf));
 253     ATF_REQUIRE(strcmp(buf, "Not enough memory") == 0);
 254     atf_error_free(err);
 255 }
 256
 257 ATF_TC(no_memory_twice);
 258 ATF_TC_HEAD(no_memory_twice, tc)
 259 {
 260     atf_tc_set_md_var(tc, "descr", "Checks the construction of no_memory "
 261                       "errors multiple times, as this error is initialized "
 262                       "statically");
 263 }
 264 ATF_TC_BODY(no_memory_twice, tc)
 265 {
 266     {
 267         atf_error_t err = atf_no_memory_error();
 268         ATF_REQUIRE(atf_error_is(err, "no_memory"));
 269         ATF_REQUIRE(atf_error_data(err) == NULL);
 270         atf_error_free(err);
 271     }
 272
 273     {
 274         atf_error_t err = atf_no_memory_error();
 275         ATF_REQUIRE(atf_error_is(err, "no_memory"));
 276         ATF_REQUIRE(atf_error_data(err) == NULL);
 277         atf_error_free(err);
 278     }
 279 }
 280
 281 /* ---------------------------------------------------------------------
 282  * Tests cases for the header file.
 283  * --------------------------------------------------------------------- */
 284
 285 HEADER_TC(include, "atf-c/error.h");
 286 HEADER_TC(include_fwd, "atf-c/error_fwd.h");
 287
 288 /* ---------------------------------------------------------------------
 289  * Main.
 290  * --------------------------------------------------------------------- */
 291
 292 ATF_TP_ADD_TCS(tp)
 293 {
 294     /* Add the tests for the "atf_error" type. */
 295     ATF_TP_ADD_TC(tp, error_new);
 296     ATF_TP_ADD_TC(tp, error_new_wo_memory);
 297     ATF_TP_ADD_TC(tp, no_error);
 298     ATF_TP_ADD_TC(tp, is_error);
 299     ATF_TP_ADD_TC(tp, format);
 300
 301     /* Add the tests for the "libc" error. */
 302     ATF_TP_ADD_TC(tp, libc_new);
 303     ATF_TP_ADD_TC(tp, libc_format);
 304
 305     /* Add the tests for the "no_memory" error. */
 306     ATF_TP_ADD_TC(tp, no_memory_new);
 307     ATF_TP_ADD_TC(tp, no_memory_format);
 308     ATF_TP_ADD_TC(tp, no_memory_twice);
 309
 310     /* Add the test cases for the header file. */
 311     ATF_TP_ADD_TC(tp, include);
 312     ATF_TP_ADD_TC(tp, include_fwd);
 313
 314     return atf_no_error();
 315 }