1  #define TEST_COMMON_H
       2  #include <string.h>
       3  #include <stdlib.h>
       4  #include <stdio.h>
       5  #include <stddef.h>
       6  #include <stdarg.h>
       7  #if !defined DECODE_TEST_C && !defined ENCODE_TEST_C
       8  static unsigned int loglevel;
       9  #  define DWG_LOGLEVEL loglevel
      10  #  include "logging.h"
      11  #endif
      12  #include "common.h"
      13  #if defined(BITS_TEST_C) || defined(DECODE_TEST_C)
      14  #  include "bits.h"
      15  #endif
      16  
      17  static int num = 0;
      18  static int failed = 0;
      19  static int passed = 0;
      20  static char buffer[512];
      21  
      22  int numpassed (void);
      23  int numfailed (void);
      24  int is_make_silent (void);
      25  
      26  static inline void pass (void);
      27  static void fail (const char *fmt, ...) ATTRIBUTE_FORMAT (1, 2);
      28  static void ok (const char *fmt, ...) ATTRIBUTE_FORMAT (1, 2);
      29  
      30  int
      31  numpassed (void)
      32  {
      33    return passed;
      34  }
      35  int
      36  numfailed (void)
      37  {
      38    return failed;
      39  }
      40  
      41  static void ATTRIBUTE_FORMAT (1, 2) ok (const char *fmt, ...)
      42  {
      43    va_list ap;
      44  
      45    passed++;
      46    va_start (ap, fmt);
      47    vsnprintf (buffer, sizeof (buffer), fmt, ap);
      48    va_end (ap);
      49    if (loglevel >= 2)
      50      printf ("ok %d\t# %s\n", ++num, buffer);
      51  }
      52  
      53  static inline void
      54  pass (void)
      55  {
      56    passed++;
      57    num++;
      58  }
      59  
      60  static void ATTRIBUTE_FORMAT (1, 2) fail (const char *fmt, ...)
      61  {
      62    va_list ap;
      63  
      64    failed++;
      65    va_start (ap, fmt);
      66    vsnprintf (buffer, sizeof (buffer), fmt, ap);
      67    va_end (ap);
      68    if (loglevel >= 2)
      69      printf ("not ok %d\t# %s\n", ++num, buffer);
      70  }
      71  
      72  #if 0
      73  static void
      74  ATTRIBUTE_FORMAT (1, 2)
      75  todo (const char *fmt, ...)
      76  {
      77    va_list ap;
      78  
      79    va_start (ap, fmt);
      80    vsnprintf (buffer, sizeof (buffer), fmt, ap);
      81    va_end (ap);
      82    if (loglevel >= 2)
      83      printf ("not ok %d\t# TODO %s\n", ++num, buffer);
      84    passed++;
      85  }
      86  #endif
      87  
      88  #if defined(BITS_TEST_C) || defined(DECODE_TEST_C)
      89  
      90  void bitprepare (Bit_Chain *dat, size_t size);
      91  void bitfree (Bit_Chain *dat);
      92  Bit_Chain strtobt (const char *binarystring);
      93  
      94  /*
      95   * This functions initializes dat and allocates the given
      96   * size.
      97   * @param Bit_Chain* dat
      98   * @param size_t size
      99   */
     100  void
     101  bitprepare (Bit_Chain *dat, size_t size)
     102  {
     103    dat->bit = 0;
     104    dat->byte = 0;
     105    dat->from_version = dat->version = R_2000;
     106    dat->opts = 1;
     107    dat->size = size + 1;
     108    dat->fh = NULL;
     109    dat->chain = (unsigned char *)calloc (size + 1, 1);
     110    dat->codepage = 30; // ANSI_1252
     111  }
     112  
     113  /*
     114   * This functions resets and free's the dat chain.
     115   * @param Bit_Chain* dat
     116   */
     117  void
     118  bitfree (Bit_Chain *dat)
     119  {
     120    dat->bit = 0;
     121    dat->byte = 0;
     122    dat->size = 0;
     123    if (dat->chain)
     124      free (dat->chain);
     125  }
     126  
     127  /*
     128   * This function converts the given binary string to binary
     129   * value
     130   * for eg "010101" => 010101
     131   * and puts it in dat to be examined
     132   */
     133  Bit_Chain
     134  strtobt (const char *binarystring)
     135  {
     136    Bit_Chain dat;
     137    size_t i;
     138    const size_t length = strlen (binarystring);
     139    unsigned size_needed = (unsigned)(length / 8);
     140    if (length % 8)
     141      size_needed++;
     142  
     143    bitprepare (&dat, size_needed);
     144  
     145    for (i = 0; i < length; ++i)
     146      {
     147        if (binarystring[i] == '0')
     148          bit_write_B (&dat, 0);
     149        else
     150          bit_write_B (&dat, 1);
     151      }
     152  
     153    // LOG_TRACE(bit_print (&dat, size_need));
     154  
     155    // Reset the bit position
     156    dat.bit = 0;
     157    dat.byte = 0;
     158  
     159    return dat;
     160  }
     161  
     162  #endif
     163  
     164  // make -s makes it silent, but can be overridden by VERBOSE=1
     165  int
     166  is_make_silent (void)
     167  {
     168    const char *make = getenv ("MAKEFLAGS");
     169    if (!make)
     170      return 0;                                        // not from make: verbose
     171    if (strstr (make, "-s") || memBEGINc (make, "s ")) // make check with -s
     172      return getenv ("VERBOSE") ? 0 : 1;
     173    else
     174      return 0; // make check without -s
     175  }