share/examples/tests/tests/tap/printf_test.c

   1 /* $FreeBSD$
   2  *
   3  * Copyright 2013 Google Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met:
   9  *
  10  * * Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  * * Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in the
  14  *   documentation and/or other materials provided with the distribution.
  15  * * Neither the name of Google Inc. nor the names of its contributors
  16  *   may be used to endorse or promote products derived from this software
  17  *   without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
  30
  31 /*
  32  * INTRODUCTION
  33  *
  34  * This plain test program mimics the structure and contents of its
  35  * ATF-based counterpart.  It attempts to represent various test cases
  36  * in different separate functions and just calls them all from main().
  37  *
  38  * In reality, plain test programs can be much simpler.  All they have
  39  * to do is return 0 on success and non-0 otherwise.
  40  */
  41
  42 #include <err.h>
  43 #include <stdarg.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47
  48 static  int failed;
  49 static  int test_num = 1;
  50
  51 #define TEST_COUNT      7
  52
  53 static void
  54 fail(const char *fmt, ...)
  55 {
  56         char *msg;
  57         va_list ap;
  58
  59         failed = 1;
  60
  61         va_start(ap, fmt);
  62         if (vasprintf(&msg, fmt, ap) == -1)
  63                 err(1, NULL);
  64         va_end(ap);
  65         printf("not ok %d - %s\n", test_num, msg);
  66         free(msg);
  67
  68         test_num++;
  69 }
  70
  71 static void
  72 pass(void)
  73 {
  74
  75         printf("ok %d\n", test_num);
  76         test_num++;
  77 }
  78
  79 static void
  80 skip(int skip_num)
  81 {
  82         int i;
  83
  84         for (i = 0; i < skip_num; i++) {
  85                 printf("not ok %d # SKIP\n", test_num);
  86                 test_num++;
  87         }
  88 }
  89
  90 static void
  91 snprintf__two_formatters(void)
  92 {
  93         char buffer[128];
  94
  95         if (snprintf(buffer, sizeof(buffer), "%s, %s!", "Hello",
  96             "tests") <= 0) {
  97                 fail("snprintf with two formatters failed");
  98                 skip(1);
  99         } else {
 100                 pass();
 101                 if (strcmp(buffer, "Hello, tests!") != 0)
 102                         fail("Bad formatting: got %s", buffer);
 103                 else
 104                         pass();
 105         }
 106 }
 107
 108 static void
 109 snprintf__overflow(void)
 110 {
 111         char buffer[10];
 112
 113         if (snprintf(buffer, sizeof(buffer), "0123456789abcdef") != 16) {
 114                 fail("snprintf did not return the expected "
 115                     "number of characters");
 116                 skip(1);
 117                 return;
 118         }
 119         pass();
 120
 121         if (strcmp(buffer, "012345678") != 0)
 122                 fail("Bad formatting: got %s", buffer);
 123         else
 124                 pass();
 125 }
 126
 127 static void
 128 fprintf__simple_string(void)
 129 {
 130         FILE *file;
 131         char buffer[128];
 132         size_t length;
 133         const char *contents = "This is a message\n";
 134
 135         file = fopen("test.txt", "w+");
 136         if (fprintf(file, "%s", contents) <= 0) {
 137                 fail("fprintf failed to write to file");
 138                 skip(2);
 139                 return;
 140         }
 141         pass();
 142         rewind(file);
 143         length = fread(buffer, 1, sizeof(buffer) - 1, file);
 144         if (length != strlen(contents)) {
 145                 fail("fread failed");
 146                 skip(1);
 147                 return;
 148         }
 149         pass();
 150         buffer[length] = '\0';
 151         fclose(file);
 152
 153         if (strcmp(buffer, contents) != 0)
 154                 fail("Written and read data differ");
 155         else
 156                 pass();
 157
 158         /* Of special note here is that we are NOT deleting the temporary
 159          * files we created in this test.  Kyua takes care of this cleanup
 160          * automatically and tests can (and should) rely on this behavior. */
 161 }
 162
 163 int
 164 main(void)
 165 {
 166         /* If you have read the printf_test.c counterpart in the atf/
 167          * directory, you may think that the sequencing of tests below and
 168          * the exposed behavior to the user is very similar.  But you'd be
 169          * wrong.
 170          *
 171          * There are two major differences with this and the ATF version.
 172          * The first is that the code below has no provisions to detect
 173          * failures in one test and continue running the other tests: the
 174          * first failure causes the whole test program to exit.  The second
 175          * is that this particular main() has no arguments: without ATF,
 176          * all test programs may expose a different command-line interface,
 177          * and this is an issue for consistency purposes. */
 178         printf("1..%d\n", TEST_COUNT);
 179
 180         snprintf__two_formatters();
 181         snprintf__overflow();
 182         fprintf__simple_string();
 183
 184         return (failed);
 185 }