LCOV - code coverage report
Current view: top level - src/tds/unittests - t0007.c (source / functions) Hit Total Coverage
Test: FreeTDS coverage Lines: 252 266 94.7 %
Date: 2024-03-23 08:24:27 Functions: 2 2 100.0 %

          Line data    Source code
       1             : /* FreeTDS - Library of routines accessing Sybase and Microsoft databases
       2             :  * Copyright (C) 1998-1999  Brian Bruns
       3             :  * Copyright (C) 2015  Frediano Ziglio
       4             :  *
       5             :  * This library is free software; you can redistribute it and/or
       6             :  * modify it under the terms of the GNU Library General Public
       7             :  * License as published by the Free Software Foundation; either
       8             :  * version 2 of the License, or (at your option) any later version.
       9             :  *
      10             :  * This library is distributed in the hope that it will be useful,
      11             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      12             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      13             :  * Library General Public License for more details.
      14             :  *
      15             :  * You should have received a copy of the GNU Library General Public
      16             :  * License along with this library; if not, write to the
      17             :  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      18             :  * Boston, MA 02111-1307, USA.
      19             :  */
      20             : 
      21             : /**
      22             :  * This test exercise manually conversions from types.
      23             :  * Does not require any connection.
      24             :  */
      25             : 
      26             : #include "common.h"
      27             : #include <freetds/convert.h>
      28             : 
      29             : static TDSCONTEXT ctx;
      30             : 
      31             : static void
      32        1120 : test0(const char *src, int len, int midtype, int dsttype, const char *result, int line)
      33             : {
      34             :         int i, res;
      35             :         char buf[256];
      36             :         CONV_RESULT cr, cr_mid, cr_out;
      37        1120 :         int srctype = SYBVARCHAR;
      38             :         char *copy;
      39             : 
      40        1120 :         copy = tds_new(char, len);
      41        1120 :         memcpy(copy, src, len);
      42        1120 :         src = copy;
      43             : 
      44        1120 :         if (midtype) {
      45         144 :                 if (midtype == SYBNUMERIC || midtype == SYBDECIMAL) {
      46           0 :                         cr_mid.n.precision = 20;
      47           0 :                         cr_mid.n.scale = 8;
      48             :                 }
      49         144 :                 res = tds_convert(&ctx, SYBVARCHAR, src, len, midtype, &cr_mid);
      50         144 :                 if (res < 0) {
      51           0 :                         fprintf(stderr, "Unexpected failure converting %*.*s\n", len, len, src);
      52           0 :                         exit(1);
      53             :                 }
      54             :                 src = (const char *) &cr_mid;
      55             :                 len = res;
      56             :                 srctype = midtype;
      57             :         }
      58        1120 :         if (dsttype == SYBNUMERIC || dsttype == SYBDECIMAL) {
      59           8 :                 cr.n.precision = 20;
      60           8 :                 cr.n.scale = 8;
      61             :         }
      62        1120 :         res = tds_convert(&ctx, srctype, src, len, dsttype, &cr);
      63        1120 :         if (res < 0)
      64         424 :                 strcpy(buf, "error");
      65             :         else {
      66         696 :                 buf[0] = 0;
      67         696 :                 switch (dsttype) {
      68          48 :                 case SYBINT1:
      69             :                 case SYBUINT1:
      70          48 :                         sprintf(buf, "%d", cr.ti);
      71          48 :                         break;
      72          24 :                 case SYBINT2:
      73          24 :                         sprintf(buf, "%d", cr.si);
      74          24 :                         break;
      75          16 :                 case SYBUINT2:
      76          16 :                         sprintf(buf, "%u", cr.usi);
      77          16 :                         break;
      78          72 :                 case SYBINT4:
      79          72 :                         sprintf(buf, "%d", cr.i);
      80          72 :                         break;
      81          40 :                 case SYBUINT4:
      82          40 :                         sprintf(buf, "%u", cr.ui);
      83          40 :                         break;
      84          64 :                 case SYBINT8:
      85          64 :                         sprintf(buf, "0x%08x%08x", (unsigned int) ((cr.bi >> 32) & 0xfffffffflu), (unsigned int) (cr.bi & 0xfffffffflu));
      86          64 :                         break;
      87         120 :                 case SYB5BIGTIME:
      88             :                 case SYB5BIGDATETIME:
      89             :                 case SYBUINT8:
      90         120 :                         sprintf(buf, "0x%08x%08x", (unsigned int) ((cr.ubi >> 32) & 0xfffffffflu), (unsigned int) (cr.ubi & 0xfffffffflu));
      91         120 :                         break;
      92          24 :                 case SYBUNIQUE:
      93         240 :                         sprintf(buf, "%08X-%04X-%04X-%02X%02X%02X%02X"
      94             :                                 "%02X%02X%02X%02X",
      95             :                                 cr.u.Data1,
      96          48 :                                 cr.u.Data2, cr.u.Data3,
      97          48 :                                 cr.u.Data4[0], cr.u.Data4[1],
      98         144 :                                 cr.u.Data4[2], cr.u.Data4[3], cr.u.Data4[4], cr.u.Data4[5], cr.u.Data4[6], cr.u.Data4[7]);
      99          24 :                         break;
     100         104 :                 case SYBBINARY:
     101         104 :                         sprintf(buf, "len=%d", res);
     102         448 :                         for (i = 0; i < res; ++i)
     103         344 :                                 sprintf(strchr(buf, 0), " %02X", (TDS_UCHAR) cr.ib[i]);
     104         104 :                         free(cr.ib);
     105         104 :                         break;
     106          40 :                 case SYBCHAR:
     107          40 :                         sprintf(buf, "len=%d %s", res, cr.c);
     108          40 :                         free(cr.c);
     109          40 :                         break;
     110          72 :                 case SYBDATETIME:
     111          72 :                         sprintf(buf, "%ld %ld", (long int) cr.dt.dtdays, (long int) cr.dt.dttime);
     112          72 :                         break;
     113          32 :                 case SYBDATE:
     114          32 :                         sprintf(buf, "%ld", (long int) cr.date);
     115          32 :                         break;
     116          32 :                 case SYBTIME:
     117          32 :                         sprintf(buf, "%ld", (long int) cr.time);
     118          32 :                         break;
     119           8 :                 case SYBNUMERIC:
     120             :                 case SYBDECIMAL:
     121           8 :                         cr_out.cc.c = buf;
     122           8 :                         cr_out.cc.len = sizeof(buf) - 1;
     123           8 :                         res = tds_convert(&ctx, dsttype, &cr.n, sizeof(cr.n), TDS_CONVERT_CHAR, &cr_out);
     124           8 :                         if (res < 0) {
     125           0 :                                 fprintf(stderr, "Unexpected failure converting %*.*s\n", len, len, src);
     126           0 :                                 exit(1);
     127             :                         }
     128           8 :                         buf[res] = 0;
     129             :                 }
     130             :         }
     131        1120 :         printf("%s\n", buf);
     132        1120 :         if (strcmp(buf, result) != 0) {
     133           0 :                 fprintf(stderr, "Expected '%s' got '%s' at line %d\n", result, buf, line);
     134           0 :                 exit(1);
     135             :         }
     136        1120 :         free(copy);
     137        1120 : }
     138             : 
     139             : #define test(s,d,r)    test0(s,(int)strlen(s),0,d,r,__LINE__)
     140             : #define test2(s,m,d,r) test0(s,(int)strlen(s),m,d,r,__LINE__)
     141             : 
     142             : static int
     143             : int_types[] = {
     144             :         SYBINT1, SYBUINT1, SYBINT2, SYBUINT2,
     145             :         SYBINT4, SYBUINT4, SYBINT8, SYBUINT8,
     146             :         SYBMONEY4, SYBMONEY,
     147             :         SYBNUMERIC,
     148             :         -1
     149             : };
     150             : 
     151             : static const char *
     152             : int_values[] = {
     153             :         "0",
     154             :         "127", "255",
     155             :         "128", "256",
     156             :         "32767", "65535",
     157             :         "32768", "65536",
     158             :         "214748",
     159             :         "214749",
     160             :         "2147483647", "4294967295",
     161             :         "2147483648", "4294967296",
     162             :         "922337203685477",
     163             :         "922337203685478",
     164             :         "9223372036854775807", "18446744073709551615",
     165             :         "9223372036854775808", "18446744073709551616",
     166             :         "-128",
     167             :         "-129",
     168             :         "-32768",
     169             :         "-32769",
     170             :         "-214748",
     171             :         "-214749",
     172             :         "-2147483648",
     173             :         "-2147483649",
     174             :         "-922337203685477",
     175             :         "-922337203685478",
     176             :         "-9223372036854775808",
     177             :         "-9223372036854775809",
     178             :         NULL
     179             : };
     180             : 
     181             : int
     182           8 : main(void)
     183             : {
     184             :         int *type1, *type2;
     185             :         const char **value;
     186           8 :         int big_endian = 1;
     187             :         if (((char *) &big_endian)[0] == 1)
     188           8 :                 big_endian = 0;
     189             : 
     190           8 :         memset(&ctx, 0, sizeof(ctx));
     191             : 
     192           8 :         if ((ctx.locale = tds_get_locale()) == NULL)
     193             :                 return 1;
     194             : 
     195             :         /* date */
     196           8 :         free(ctx.locale->datetime_fmt);
     197           8 :         ctx.locale->datetime_fmt = strdup("%Y-%m-%d %H:%M:%S.%z");
     198           8 :         free(ctx.locale->date_fmt);
     199           8 :         ctx.locale->date_fmt = strdup("%Y-%m-%d");
     200           8 :         free(ctx.locale->time_fmt);
     201           8 :         ctx.locale->time_fmt = strdup("%H:%M:%S.%z");
     202             : 
     203             :         /* test some conversion */
     204           8 :         printf("some checks...\n");
     205           8 :         test("1234", SYBINT4, "1234");
     206           8 :         test("1234", SYBUINT4, "1234");
     207           8 :         test("123", SYBINT1, "123");
     208           8 :         test("123", SYBUINT1, "123");
     209           8 :         test("  -    1234   ", SYBINT2, "-1234");
     210           8 :         test("  -    1234   a", SYBINT2, "error");
     211           8 :         test("", SYBINT4, "0");
     212           8 :         test("    ", SYBINT4, "0");
     213           8 :         test("    123", SYBINT4, "123");
     214           8 :         test("    123    ", SYBINT4, "123");
     215           8 :         test("  +  123  ", SYBINT4, "123");
     216           8 :         test("  +  123  ", SYBUINT4, "123");
     217           8 :         test("  - 0  ", SYBINT4, "0");
     218           8 :         test("  -  0  ", SYBUINT4, "0");
     219           8 :         test("+", SYBINT4, "error");
     220           8 :         test("   +", SYBINT4, "error");
     221           8 :         test("+   ", SYBINT4, "error");
     222           8 :         test("   +   ", SYBINT4, "error");
     223           8 :         test("-", SYBINT4, "error");
     224           8 :         test("   -", SYBINT4, "error");
     225           8 :         test("-   ", SYBINT4, "error");
     226           8 :         test("   -   ", SYBINT4, "error");
     227             : 
     228           8 :         test("  -    1234   ", SYBINT8, "0xfffffffffffffb2e");
     229           8 :         test("1234x", SYBINT8, "error");
     230           8 :         test("  -    1234   a", SYBINT8, "error");
     231           8 :         test("", SYBINT8, "0x0000000000000000");
     232           8 :         test("    ", SYBINT8, "0x0000000000000000");
     233           8 :         test("    123", SYBINT8, "0x000000000000007b");
     234           8 :         test("    123    ", SYBINT8, "0x000000000000007b");
     235           8 :         test("  +  123  ", SYBINT8, "0x000000000000007b");
     236           8 :         test("    123", SYBUINT8, "0x000000000000007b");
     237           8 :         test("    123    ", SYBUINT8, "0x000000000000007b");
     238           8 :         test("  +  123  ", SYBUINT8, "0x000000000000007b");
     239           8 :         test("+", SYBINT8, "error");
     240           8 :         test("   +", SYBINT8, "error");
     241           8 :         test("+   ", SYBINT8, "error");
     242           8 :         test("   +   ", SYBINT8, "error");
     243           8 :         test("-", SYBINT8, "error");
     244           8 :         test("   -", SYBINT8, "error");
     245           8 :         test("-   ", SYBINT8, "error");
     246           8 :         test("   -   ", SYBINT8, "error");
     247             : 
     248             :         /* test for overflow */
     249             :         /* for SYBUINT8 a test with all different digit near limit is required */
     250           8 :         printf("overflow checks...\n");
     251           8 :         test("9223372036854775807", SYBINT8, "0x7fffffffffffffff");
     252           8 :         test("9223372036854775807", SYBUINT8, "0x7fffffffffffffff");
     253           8 :         test("9223372036854775808", SYBINT8, "error");
     254           8 :         test("-9223372036854775808", SYBINT8, "0x8000000000000000");
     255           8 :         test("9223372036854775808", SYBUINT8, "0x8000000000000000");
     256           8 :         test("18446744073709551610", SYBUINT8, "0xfffffffffffffffa");
     257           8 :         test("18446744073709551611", SYBUINT8, "0xfffffffffffffffb");
     258           8 :         test("18446744073709551612", SYBUINT8, "0xfffffffffffffffc");
     259           8 :         test("18446744073709551613", SYBUINT8, "0xfffffffffffffffd");
     260           8 :         test("18446744073709551614", SYBUINT8, "0xfffffffffffffffe");
     261           8 :         test("18446744073709551615", SYBUINT8, "0xffffffffffffffff");
     262           8 :         test("18446744073709551616", SYBUINT8, "error");
     263           8 :         test("18446744073709551617", SYBUINT8, "error");
     264           8 :         test("18446744073709551618", SYBUINT8, "error");
     265           8 :         test("18446744073709551619", SYBUINT8, "error");
     266           8 :         test("18446744073709551620", SYBUINT8, "error");
     267           8 :         test("20496382304121724025", SYBUINT8, "error");
     268           8 :         test("20496382308118429681", SYBUINT8, "error");
     269           8 :         test("-1", SYBUINT8, "error");
     270           8 :         test("-9223372036854775809", SYBINT8, "error");
     271           8 :         test("2147483647", SYBINT4, "2147483647");
     272           8 :         test("2147483648", SYBINT4, "error");
     273           8 :         test("2147483647", SYBUINT4, "2147483647");
     274           8 :         test("4294967295", SYBUINT4, "4294967295");
     275           8 :         test("4294967296", SYBUINT4, "error");
     276           8 :         test("-2147483648", SYBINT4, "-2147483648");
     277           8 :         test("-2147483648", SYBUINT4, "error");
     278           8 :         test("-2147483649", SYBINT4, "error");
     279           8 :         test("32767", SYBINT2, "32767");
     280           8 :         test("32767", SYBUINT2, "32767");
     281           8 :         test("65535", SYBUINT2, "65535");
     282           8 :         test("65536", SYBUINT2, "error");
     283           8 :         test("32768", SYBINT2, "error");
     284           8 :         test("-32768", SYBINT2, "-32768");
     285           8 :         test("-32769", SYBINT2, "error");
     286           8 :         test("255", SYBINT1, "255");
     287           8 :         test("256", SYBINT1, "error");
     288           8 :         test("255", SYBUINT1, "255");
     289           8 :         test("256", SYBUINT1, "error");
     290           8 :         test("0", SYBINT1, "0");
     291           8 :         test("-1", SYBINT1, "error");
     292           8 :         test("0", SYBUINT1, "0");
     293           8 :         test("-1", SYBUINT1, "error");
     294             : 
     295             :         /*
     296             :          * test overflow on very big numbers 
     297             :          * I use increment of 10^9 to be sure lower 32bit be correct
     298             :          * in a case
     299             :          */
     300           8 :         printf("overflow on big number checks...\n");
     301           8 :         test("62147483647", SYBINT4, "error");
     302           8 :         test("63147483647", SYBINT4, "error");
     303           8 :         test("64147483647", SYBINT4, "error");
     304           8 :         test("65147483647", SYBINT4, "error");
     305           8 :         test("53248632876323876761", SYBINT8, "error");
     306           8 :         test("56248632876323876761", SYBINT8, "error");
     307           8 :         test("59248632876323876761", SYBINT8, "error");
     308           8 :         test("12248632876323876761", SYBINT8, "error");
     309             : 
     310             :         /* money */
     311           8 :         test2("1234.11111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
     312             :                 SYBMONEY, SYBCHAR, "len=9 1234.1111");
     313             : 
     314             :         /* some test for unique */
     315           8 :         printf("unique type...\n");
     316           8 :         test("12345678-1234-1234-9876543298765432", SYBUNIQUE, "12345678-1234-1234-9876543298765432");
     317           8 :         test("{12345678-1234-1E34-9876ab3298765432}", SYBUNIQUE, "12345678-1234-1E34-9876AB3298765432");
     318           8 :         test(" 12345678-1234-1234-9876543298765432", SYBUNIQUE, "error");
     319           8 :         test(" {12345678-1234-1234-9876543298765432}", SYBUNIQUE, "error");
     320           8 :         test("12345678-1234-G234-9876543298765432", SYBUNIQUE, "error");
     321           8 :         test("12345678-1234-a234-9876543298765432", SYBUNIQUE, "12345678-1234-A234-9876543298765432");
     322           8 :         test("123a5678-1234-a234-98765-43298765432", SYBUNIQUE, "error");
     323           8 :         test("123-5678-1234-a234-9876543298765432", SYBUNIQUE, "error");
     324             : 
     325           8 :         printf("binary test...\n");
     326           8 :         test("0x1234", SYBBINARY, "len=2 12 34");
     327           8 :         test("0xaBFd  ", SYBBINARY, "len=2 AB FD");
     328           8 :         test("AbfD  ", SYBBINARY, "len=2 AB FD");
     329           8 :         test("0x000", SYBBINARY, "len=2 00 00");
     330           8 :         test("0x0", SYBBINARY, "len=1 00");
     331           8 :         test("0x100", SYBBINARY, "len=2 01 00");
     332           8 :         test("0x1", SYBBINARY, "len=1 01");
     333             : 
     334           8 :         test("Jan 01 2006", SYBDATETIME, "38716 0");
     335           8 :         test("January 01 2006", SYBDATETIME, "38716 0");
     336           8 :         test("March 05 2005", SYBDATETIME, "38414 0");
     337           8 :         test("may 13 2001", SYBDATETIME, "37022 0");
     338             : 
     339           8 :         test("02 Jan 2006", SYBDATETIME, "38717 0");
     340           8 :         test("2 Jan 2006", SYBDATETIME, "38717 0");
     341           8 :         test("02Jan2006", SYBDATETIME, "38717 0");
     342           8 :         test("20060102", SYBDATETIME, "38717 0");
     343           8 :         test("060102", SYBDATETIME, "38717 0");
     344             : 
     345           8 :         test("2006-01-02", SYBDATE, "38717");
     346           8 :         test("12:34:56.337", SYBTIME, "13588901");
     347             : 
     348           8 :         test2("2006-01-02", SYBDATE, SYBDATE, "38717");
     349           8 :         test2("12:34:56.337", SYBTIME, SYBTIME, "13588901");
     350             : 
     351           8 :         test2("2006-01-02 12:34:56.337", SYBDATETIME, SYBDATE, "38717");
     352           8 :         test2("2006-01-02 12:34:56.337", SYBDATETIME, SYBTIME, "13588901");
     353             : 
     354           8 :         test("2006-01-02 12:34:56.337321", SYB5BIGTIME, "0x0000000a8bdf41a9");
     355           8 :         test("2006-01-23 12:34:56.337321", SYB5BIGDATETIME, "0x00e0e7c784d661a9");
     356           8 :         test("2006-01-02 12:34:56.337321", SYB5BIGDATETIME, "0x00e0e621122b81a9");
     357             : 
     358           8 :         test2("2006-01-02 12:34:56.337765", SYB5BIGDATETIME, SYBCHAR, "len=26 2006-01-02 12:34:56.337765");
     359           8 :         test("2006-01-02 12:34:56.337765", SYB5BIGDATETIME, "0x00e0e621122b8365");
     360             : 
     361           8 :         test2("2006-01-02 12:34:56.337", SYBMSDATETIME2, SYBDATE, "38717");
     362           8 :         test2("2006-01-02 12:34:56.337", SYBMSDATETIME2, SYBTIME, "13588901");
     363             : 
     364           8 :         test2("2006-01-02 12:34:56.337", SYBMSDATETIME2, SYBCHAR, "len=27 2006-01-02 12:34:56.3370000");
     365             : #if 0
     366             :         /* FIXME should fail conversion ?? */
     367             :         test2("2006-01-02", SYBDATE, SYBTIME, "0");
     368             :         test2("12:34:56.337", SYBTIME, SYBDATE, "0");
     369             : #endif
     370             : 
     371           8 :         test2("2006-01-02", SYBDATE, SYBCHAR, "len=10 2006-01-02");
     372           8 :         test2("12:34:56.337", SYBTIME, SYBCHAR, "len=12 12:34:56.337");
     373             : 
     374           8 :         test2("123", SYBINT1, SYBBINARY, "len=1 7B");
     375           8 :         test2("0.000001", SYBFLT8, SYBNUMERIC, "0.00000100");
     376             :         if (big_endian) {
     377             :                 test2("12345", SYBINT2, SYBBINARY, "len=2 30 39");
     378             :                 test2("123456789", SYBINT4, SYBBINARY, "len=4 07 5B CD 15");
     379             :                 test2("123456789", SYBUINT8, SYBBINARY, "len=8 00 00 00 00 07 5B CD 15");
     380             :                 test2("123456789", SYBINT8, SYBBINARY, "len=8 00 00 00 00 07 5B CD 15");
     381             :                 test2("-123456789", SYBINT8, SYBBINARY, "len=8 FF FF FF FF F8 A4 32 EB");
     382             :         } else {
     383           8 :                 test2("12345", SYBINT2, SYBBINARY, "len=2 39 30");
     384           8 :                 test2("123456789", SYBINT4, SYBBINARY, "len=4 15 CD 5B 07");
     385           8 :                 test2("123456789", SYBUINT8, SYBBINARY, "len=8 15 CD 5B 07 00 00 00 00");
     386           8 :                 test2("123456789", SYBINT8, SYBBINARY, "len=8 15 CD 5B 07 00 00 00 00");
     387           8 :                 test2("-123456789", SYBINT8, SYBBINARY, "len=8 EB 32 A4 F8 FF FF FF FF");
     388             :         }
     389             : 
     390             :         /* now try many int conversion operations */
     391         272 :         for (value = int_values; *value; ++value)
     392        2904 :         for (type1 = int_types; *type1 >= 0; ++type1)
     393       31944 :         for (type2 = int_types; *type2 >= 0; ++type2) {
     394             :                 char buf[64], expected[64];
     395             :                 CONV_RESULT cr_src, cr_dst;
     396             :                 TDS_INT len_src, len_dst;
     397             : 
     398             :                 /* try conversion from char (already tested above) */
     399       31944 :                 cr_src.n.precision = 20; cr_src.n.scale = 0;
     400       31944 :                 len_src = tds_convert(&ctx, SYBVARCHAR, *value, strlen(*value), *type1, &cr_src);
     401       31944 :                 cr_dst.n.precision = 20; cr_dst.n.scale = 0;
     402       31944 :                 len_dst = tds_convert(&ctx, SYBVARCHAR, *value, strlen(*value), *type2, &cr_dst);
     403       31944 :                 if (len_src <= 0 || len_dst <= 0)
     404       21784 :                         continue;
     405       10160 :                 cr_dst.n.precision = 20; cr_dst.n.scale = 0;
     406       10160 :                 if (tds_convert(&ctx, *type1, &cr_src.i, len_src, *type2, &cr_dst) <= 0) {
     407           0 :                         fprintf(stderr, "conversion from %s to %s of %s should succeed\n",
     408             :                                 tds_prtype(*type1), tds_prtype(*type2), *value);
     409           0 :                         return 1;
     410             :                 }
     411       10160 :                 memcpy(&cr_src, &cr_dst, sizeof(cr_dst));
     412       10160 :                 cr_dst.cc.c = buf;
     413       10160 :                 cr_dst.cc.len = sizeof(buf)-4;
     414       10160 :                 len_dst = tds_convert(&ctx, *type2, &cr_src.i, len_dst, TDS_CONVERT_CHAR, &cr_dst);
     415       10160 :                 if (len_dst <= 0) {
     416           0 :                         fprintf(stderr, "conversion from %s to string should succeed\n",
     417             :                                 tds_prtype(*type1));
     418           0 :                         return 1;
     419             :                 }
     420       10160 :                 buf[len_dst] = 0;
     421       10160 :                 if (*type2 == SYBMONEY4 || *type2 == SYBMONEY)
     422        2272 :                         sprintf(expected, "%s.0000", *value);
     423             :                 else
     424        7888 :                         strcpy(expected, *value);
     425       10160 :                 if (strcmp(buf, expected) != 0) {
     426           0 :                         fprintf(stderr, "conversion from %s to %s of %s got wrong value '%s'\n",
     427             :                                 tds_prtype(*type1), tds_prtype(*type2), *value, buf);
     428           0 :                         return 1;
     429             :                 }
     430             :         }
     431             : 
     432           8 :         tds_free_locale(ctx.locale);
     433             : 
     434           8 :         return 0;
     435             : }

Generated by: LCOV version 1.13