dejagnu.h

   1 /* DejaGnu unit testing header.
   2    Copyright (C) 2000-2016 Free Software Foundation, Inc.
   3
   4 This file is part of DejaGnu.
   5
   6 DejaGnu is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3 of the License, or
   9 (at your option) any later version.
  10
  11 DejaGnu is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with DejaGnu; if not, write to the Free Software Foundation,
  18 Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 #ifndef __DEJAGNU_H__
  21 #define __DEJAGNU_H__
  22
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25 #include <string.h>
  26
  27 /* If you have problems with DejaGnu dropping failed, untested, or
  28  * unresolved messages generated by a unit testcase, then:  */
  29
  30 /* #define _DEJAGNU_WAIT_  */
  31
  32 #ifdef _DEJAGNU_WAIT_
  33 #include <sys/time.h>
  34 #include <sys/types.h>
  35 #include <unistd.h>
  36 #endif
  37
  38 static int passed;
  39 static int failed;
  40 static int untest;
  41 static int unresolve;
  42 static int xfailed;
  43 static int xpassed;
  44
  45 static char buffer[512];
  46
  47 void
  48 wait (void)
  49 {
  50 #ifdef _DEJAGNU_WAIT_
  51   fd_set rfds;
  52   struct timeval tv;
  53
  54   FD_ZERO (&rfds);
  55   tv.tv_sec = 0;
  56   tv.tv_usec = 1;
  57
  58   select (0, &rfds, NULL, NULL, &tv);
  59 #endif
  60 }
  61
  62 static inline void
  63 pass (const char* fmt, ...)
  64 {
  65   va_list ap;
  66
  67   passed++;
  68   va_start (ap, fmt);
  69   vsnprintf (buffer, sizeof (buffer), fmt, ap);
  70   va_end (ap);
  71   printf ("\tPASSED: %s\n", buffer);
  72   wait ();
  73 }
  74
  75 static inline void
  76 xpass (const char* fmt, ...)
  77 {
  78   va_list ap;
  79
  80   xpassed++;
  81   va_start (ap, fmt);
  82   vsnprintf (buffer, sizeof (buffer), fmt, ap);
  83   va_end (ap);
  84   printf ("\tXPASSED: %s\n", buffer);
  85   wait ();
  86 }
  87
  88 static inline void
  89 fail (const char* fmt, ...)
  90 {
  91   va_list ap;
  92
  93   failed++;
  94   va_start (ap, fmt);
  95   vsnprintf (buffer, sizeof (buffer), fmt, ap);
  96   va_end (ap);
  97   printf ("\tFAILED: %s\n", buffer);
  98   wait ();
  99 }
 100
 101 static inline void
 102 xfail (const char* fmt, ...)
 103 {
 104   va_list ap;
 105
 106   xfailed++;
 107   va_start (ap, fmt);
 108   vsnprintf (buffer, sizeof (buffer), fmt, ap);
 109   va_end (ap);
 110   printf ("\tXFAILED: %s\n", buffer);
 111   wait ();
 112 }
 113
 114 static inline void
 115 untested (const char* fmt, ...)
 116 {
 117   va_list ap;
 118
 119   untest++;
 120   va_start (ap, fmt);
 121   vsnprintf (buffer, sizeof (buffer), fmt, ap);
 122   va_end (ap);
 123   printf ("\tUNTESTED: %s\n", buffer);
 124   wait ();
 125 }
 126
 127 static inline void
 128 unresolved (const char* fmt, ...)
 129 {
 130   va_list ap;
 131
 132   unresolve++;
 133   va_start (ap, fmt);
 134   vsnprintf (buffer, sizeof (buffer), fmt, ap);
 135   va_end (ap);
 136   printf ("\tUNRESOLVED: %s\n", buffer);
 137   wait ();
 138 }
 139
 140 static inline void
 141 note (const char* fmt, ...)
 142 {
 143   va_list ap;
 144
 145   va_start (ap, fmt);
 146   vsnprintf (buffer, sizeof (buffer), fmt, ap);
 147   va_end (ap);
 148   printf ("\tNOTE: %s\n", buffer);
 149   wait ();
 150 }
 151
 152 static inline void
 153 totals (void)
 154 {
 155   printf ("\nTotals:\n");
 156   printf ("\t#passed:\t\t%d\n", passed);
 157   printf ("\t#real failed:\t\t%d\n", failed);
 158   if (xfailed)
 159     printf ("\t#expected failures:\t\t%d\n", xfailed);
 160   if (xpassed)
 161     printf ("\t#unexpected passes:\t\t%d\n", xpassed);
 162   if (untest)
 163     printf ("\t#untested:\t\t%d\n", untest);
 164   if (unresolve)
 165     printf ("\t#unresolved:\t\t%d\n", unresolve);
 166   printf ("\tEND: done\n");
 167 }
 168
 169 #ifdef __cplusplus
 170
 171 #include <iostream>
 172 #include <iomanip>
 173 #include <fstream>
 174 #include <string>
 175
 176 const char *outstate_list[] = {
 177   "FAILED: ", "PASSED: ", "UNTESTED: ", "UNRESOLVED: ", "XFAILED: ", "XPASSED: "
 178 };
 179
 180 const char ** outstate = outstate_list;
 181
 182 enum teststate { FAILED, PASSED, UNTESTED, UNRESOLVED, XFAILED, XPASSED} laststate;
 183
 184 class TestState {
 185  private:
 186   teststate laststate;
 187   std::string lastmsg;
 188  public:
 189   TestState (void)
 190     {
 191       passed = 0;
 192       failed = 0;
 193       untest = 0;
 194       xpassed = 0;
 195       xfailed = 0;
 196       unresolve = 0;
 197     }
 198
 199   ~TestState (void) { totals(); }
 200
 201   void testrun (bool b, std::string s)
 202     {
 203       if (b)
 204         pass (s);
 205       else
 206         fail (s);
 207     }
 208
 209     void pass (std::string s)
 210       {
 211         passed++;
 212         laststate = PASSED;
 213         lastmsg = s;
 214         std::cout << "\t" << outstate[PASSED] << s << std::endl;
 215       }
 216
 217     void xpass (std::string s)
 218       {
 219         xpassed++;
 220         laststate = PASSED;
 221         lastmsg = s;
 222         std::cout << "\t" << outstate[XPASSED] << s << std::endl;
 223       }
 224
 225     void fail (std::string s)
 226       {
 227         failed++;
 228         laststate = FAILED;
 229         lastmsg = s;
 230         std::cout << "\t" << outstate[FAILED] << s << std::endl;
 231       }
 232
 233     void xfail (std::string s)
 234       {
 235         xfailed++;
 236         laststate = XFAILED;
 237         lastmsg = s;
 238         std::cout << "\t" << outstate[XFAILED] << s << std::endl;
 239       }
 240
 241     void untested (std::string s)
 242       {
 243         untest++;
 244         laststate = UNTESTED;
 245         lastmsg = s;
 246         std::cout << "\t" << outstate[UNTESTED] << s << std::endl;
 247       }
 248
 249     void unresolved (std::string s)
 250       {
 251         unresolve++;
 252         laststate = UNRESOLVED;
 253         lastmsg = s;
 254         std::cout << "\t" << outstate[UNRESOLVED] << s << std::endl;
 255       }
 256
 257     void totals (void)
 258       {
 259         std::cout << "\t#passed:\t\t" << passed << std::endl;
 260         std::cout << "\t#real failed:\t\t" << failed << std::endl;
 261         if (xfailed)
 262           std::cout << "\t#expected failures:\t\t" << xfailed << std::endl;
 263         if (xpassed)
 264           std::cout << "\t#unexpected passes:\t\t" << xpassed << std::endl;
 265         if (untest)
 266           std::cout << "\t#untested:\t\t" << untest << std::endl;
 267         if (unresolve)
 268           std::cout << "\t#unresolved:\t\t" << unresolve << std::endl;
 269         std::cout << "\tEND: done" << std::endl;
 270       }
 271
 272     // This is so this class can be printed in an ostream.
 273     friend std::ostream & operator << (std::ostream &os, TestState& t)
 274       {
 275         return os << "\t" << outstate[t.laststate] << t.lastmsg ;
 276       }
 277
 278     int GetState (void) { return laststate; }
 279     std::string GetMsg (void) { return lastmsg; }
 280 };
 281
 282 #endif /* __cplusplus */
 283 #endif /* _DEJAGNU_H_ */