LCOV - code coverage report
Current view: top level - src/interfaces/ecpg/test/compat_informix - dec_test.pgc (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 109 122 89.3 %
Date: 2019-11-21 12:06:29 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : #include <stdio.h>
       2             : #include <stdlib.h>
       3             : #include <pgtypes_numeric.h>
       4             : #include <pgtypes_error.h>
       5             : #include <decimal.h>
       6             : #include <sqltypes.h>
       7             : 
       8             : exec sql include ../regression;
       9             : 
      10             : exec sql include ../printf_hack;
      11             : 
      12             : 
      13             : /*
      14             : TODO:
      15             :     deccmp => DECUNKNOWN
      16             :     decimal point: , and/or . ?
      17             :     ECPG_INFORMIX_BAD_EXPONENT ?
      18             : */
      19             : 
      20             : char* decs[] = { "2E394", "-2", ".794", "3.44", "592.49E21", "-32.84e4",
      21             :                  "2E-394", ".1E-2", "+.0", "-592.49E-07", "+32.84e-4",
      22             :                  ".500001", "-.5000001",
      23             :                  "1234567890123456789012345678.91", /* 30 digits should fit
      24             :                                                        into decimal */
      25             :                  "1234567890123456789012345678.921", /* 31 digits should NOT
      26             :                                                         fit into decimal */
      27             :                  "not a number",
      28             :                  NULL};
      29             : 
      30             : 
      31             : static void
      32             : check_errno(void);
      33             : 
      34             : #define BUFSIZE 200
      35             : 
      36             : int
      37           4 : main(void)
      38             : {
      39             :     decimal *dec, *din;
      40             :     char buf[BUFSIZE];
      41             :     long l;
      42           4 :     int i, j, k, q, r, count = 0;
      43             :     double dbl;
      44           4 :     decimal **decarr = (decimal **) calloc(1, sizeof(decimal));
      45             : 
      46           4 :     ECPGdebug(1, stderr);
      47             : 
      48          68 :     for (i = 0; decs[i]; i++)
      49             :     {
      50          64 :         dec = PGTYPESdecimal_new();
      51          64 :         r = deccvasc(decs[i], strlen(decs[i]), dec);
      52          64 :         if (r)
      53             :         {
      54           8 :             check_errno();
      55           8 :             printf("dec[%d,0]: r: %d\n", i, r);
      56           8 :             PGTYPESdecimal_free(dec);
      57           8 :             continue;
      58             :         }
      59          56 :         decarr = realloc(decarr, sizeof(decimal *) * (count + 1));
      60          56 :         decarr[count++] = dec;
      61             : 
      62          56 :         r = dectoasc(dec, buf, BUFSIZE-1, -1);
      63          56 :         if (r < 0) check_errno();
      64          56 :         printf("dec[%d,1]: r: %d, %s\n", i, r, buf);
      65             : 
      66          56 :         r = dectoasc(dec, buf, BUFSIZE-1, 0);
      67          56 :         if (r < 0) check_errno();
      68          56 :         printf("dec[%d,2]: r: %d, %s\n", i, r, buf);
      69          56 :         r = dectoasc(dec, buf, BUFSIZE-1, 1);
      70          56 :         if (r < 0) check_errno();
      71          56 :         printf("dec[%d,3]: r: %d, %s\n", i, r, buf);
      72          56 :         r = dectoasc(dec, buf, BUFSIZE-1, 2);
      73          56 :         if (r < 0) check_errno();
      74          56 :         printf("dec[%d,4]: r: %d, %s\n", i, r, buf);
      75             : 
      76          56 :         din = PGTYPESdecimal_new();
      77          56 :         r = dectoasc(din, buf, BUFSIZE-1, 2);
      78          56 :         if (r < 0) check_errno();
      79          56 :         printf("dec[%d,5]: r: %d, %s\n", i, r, buf);
      80             : 
      81          56 :         r = dectolong(dec, &l);
      82          56 :         if (r) check_errno();
      83          56 :         printf("dec[%d,6]: %ld (r: %d)\n", i, r?0L:l, r);
      84          56 :         if (r == 0)
      85             :         {
      86          44 :             r = deccvlong(l, din);
      87          44 :             if (r) check_errno();
      88          44 :             dectoasc(din, buf, BUFSIZE-1, 2);
      89          44 :             q = deccmp(dec, din);
      90          44 :             printf("dec[%d,7]: %s (r: %d - cmp: %d)\n", i, buf, r, q);
      91             :         }
      92             : 
      93          56 :         r = dectoint(dec, &k);
      94          56 :         if (r) check_errno();
      95          56 :         printf("dec[%d,8]: %d (r: %d)\n", i, r?0:k, r);
      96          56 :         if (r == 0)
      97             :         {
      98          44 :             r = deccvint(k, din);
      99          44 :             if (r) check_errno();
     100          44 :             dectoasc(din, buf, BUFSIZE-1, 2);
     101          44 :             q = deccmp(dec, din);
     102          44 :             printf("dec[%d,9]: %s (r: %d - cmp: %d)\n", i, buf, r, q);
     103             :         }
     104             : 
     105          56 :         if (i != 6)
     106             :         {
     107             :             /* underflow does not work reliable on several archs, so not testing it here */
     108             :             /* this is a libc problem since we only call strtod() */
     109          52 :             r = dectodbl(dec, &dbl);
     110          52 :             if (r) check_errno();
     111          52 :             printf("dec[%d,10]: ", i);
     112          52 :             print_double(r ? 0.0 : dbl);
     113          52 :             printf(" (r: %d)\n", r);
     114             :         }
     115             : 
     116          56 :         PGTYPESdecimal_free(din);
     117          56 :         printf("\n");
     118             :     }
     119             : 
     120             :     /* add a NULL value */
     121           4 :     dec = PGTYPESdecimal_new();
     122           4 :     decarr = realloc(decarr, sizeof(decimal *) * (count + 1));
     123           4 :     decarr[count++] = dec;
     124             : 
     125           4 :     rsetnull(CDECIMALTYPE, (char *) decarr[count-1]);
     126           4 :     printf("dec[%d]: %sNULL\n", count-1,
     127           4 :         risnull(CDECIMALTYPE, (char *) decarr[count-1]) ? "" : "NOT ");
     128           4 :     printf("dec[0]: %sNULL\n",
     129           4 :         risnull(CDECIMALTYPE, (char *) decarr[0]) ? "" : "NOT ");
     130             : 
     131           4 :     r = dectoasc(decarr[3], buf, -1, -1);
     132           4 :     check_errno(); printf("dectoasc with len == -1: r: %d\n", r);
     133           4 :     r = dectoasc(decarr[3], buf, 0, -1);
     134           4 :     check_errno(); printf("dectoasc with len == 0: r: %d\n", r);
     135             : 
     136          64 :     for (i = 0; i < count; i++)
     137             :     {
     138         960 :         for (j = 0; j < count; j++)
     139             :         {
     140             :             decimal a, s, m, d;
     141             :             int c;
     142         900 :             c = deccmp(decarr[i], decarr[j]);
     143         900 :             printf("dec[c,%d,%d]: %d\n", i, j, c);
     144             : 
     145         900 :             r = decadd(decarr[i], decarr[j], &a);
     146         900 :             if (r)
     147             :             {
     148         248 :                 check_errno();
     149         248 :                 printf("r: %d\n", r);
     150             :             }
     151             :             else
     152             :             {
     153         652 :                 dectoasc(&a, buf, BUFSIZE-1, -1);
     154         652 :                 printf("dec[a,%d,%d]: %s\n", i, j, buf);
     155             :             }
     156             : 
     157         900 :             r = decsub(decarr[i], decarr[j], &s);
     158         900 :             if (r)
     159             :             {
     160           0 :                 check_errno();
     161           0 :                 printf("r: %d\n", r);
     162             :             }
     163             :             else
     164             :             {
     165         900 :                 dectoasc(&s, buf, BUFSIZE-1, -1);
     166         900 :                 printf("dec[s,%d,%d]: %s\n", i, j, buf);
     167             :             }
     168             : 
     169         900 :             r = decmul(decarr[i], decarr[j], &m);
     170         900 :             if (r)
     171             :             {
     172           0 :                 check_errno();
     173           0 :                 printf("r: %d\n", r);
     174             :             }
     175             :             else
     176             :             {
     177         900 :                 dectoasc(&m, buf, BUFSIZE-1, -1);
     178         900 :                 printf("dec[m,%d,%d]: %s\n", i, j, buf);
     179             :             }
     180             : 
     181         900 :             r = decdiv(decarr[i], decarr[j], &d);
     182         900 :             if (r)
     183             :             {
     184          56 :                 check_errno();
     185          56 :                 printf("r: %d\n", r);
     186             :             }
     187             :             else
     188             :             {
     189         844 :                 dectoasc(&d, buf, BUFSIZE-1, -1);
     190         844 :                 printf("dec[d,%d,%d]: %s\n", i, j, buf);
     191             :             }
     192             :         }
     193             :     }
     194             : 
     195          64 :     for (i = 0; i < count; i++)
     196             :     {
     197          60 :         dectoasc(decarr[i], buf, BUFSIZE-1, -1);
     198          60 :         printf("%d: %s\n", i, buf);
     199             : 
     200          60 :         PGTYPESdecimal_free(decarr[i]);
     201             :     }
     202           4 :     free(decarr);
     203             : 
     204           4 :     return 0;
     205             : }
     206             : 
     207             : static void
     208         368 : check_errno(void)
     209             : {
     210         368 :     switch(errno)
     211             :     {
     212             :         case 0:
     213          20 :             printf("(no errno set) - ");
     214          20 :             break;
     215             :         case ECPG_INFORMIX_NUM_OVERFLOW:
     216           0 :             printf("(errno == ECPG_INFORMIX_NUM_OVERFLOW) - ");
     217           0 :             break;
     218             :         case ECPG_INFORMIX_NUM_UNDERFLOW:
     219           0 :             printf("(errno == ECPG_INFORMIX_NUM_UNDERFLOW) - ");
     220           0 :             break;
     221             :         case PGTYPES_NUM_OVERFLOW:
     222         280 :             printf("(errno == PGTYPES_NUM_OVERFLOW) - ");
     223         280 :             break;
     224             :         case PGTYPES_NUM_UNDERFLOW:
     225           0 :             printf("(errno == PGTYPES_NUM_UNDERFLOW) - ");
     226           0 :             break;
     227             :         case PGTYPES_NUM_BAD_NUMERIC:
     228          12 :             printf("(errno == PGTYPES_NUM_BAD_NUMERIC) - ");
     229          12 :             break;
     230             :         case PGTYPES_NUM_DIVIDE_ZERO:
     231          56 :             printf("(errno == PGTYPES_NUM_DIVIDE_ZERO) - ");
     232          56 :             break;
     233             :         default:
     234           0 :             printf("(unknown errno (%d))\n", errno);
     235           0 :             printf("(libc: (%s)) ", strerror(errno));
     236           0 :             break;
     237             :     }
     238         368 : }

Generated by: LCOV version 1.13