LCOV - code coverage report
Current view: top level - src/dblib/unittests - null2.c (source / functions) Hit Total Coverage
Test: FreeTDS coverage Lines: 86 106 81.1 %
Date: 2025-01-18 11:50:39 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /* 
       2             :  * Purpose: Test NULL behavior using dbbind
       3             :  */
       4             : 
       5             : #include "common.h"
       6             : 
       7             : #if HAVE_UNISTD_H
       8             : #include <unistd.h>
       9             : #endif /* HAVE_UNISTD_H */
      10             : 
      11             : static DBPROCESS *dbproc = NULL;
      12             : static int failed = 0;
      13             : 
      14             : static int
      15           6 : ignore_msg_handler(DBPROCESS * dbproc TDS_UNUSED, DBINT msgno TDS_UNUSED, int state TDS_UNUSED, int severity TDS_UNUSED,
      16             :                    char *text TDS_UNUSED, char *server TDS_UNUSED, char *proc TDS_UNUSED, int line TDS_UNUSED)
      17             : {
      18           6 :         return 0;
      19             : }
      20             : 
      21             : static int
      22           6 : ignore_err_handler(DBPROCESS * dbproc TDS_UNUSED, int severity TDS_UNUSED, int dberr TDS_UNUSED,
      23             :                    int oserr TDS_UNUSED, char *dberrstr TDS_UNUSED, char *oserrstr TDS_UNUSED)
      24             : {
      25           6 :         return INT_CANCEL;
      26             : }
      27             : 
      28             : static void
      29         282 : query(const char *query)
      30             : {
      31         282 :         printf("query: %s\n", query);
      32         282 :         dbcmd(dbproc, (char *) query);
      33         282 :         dbsqlexec(dbproc);
      34         282 :         while (dbresults(dbproc) == SUCCEED) {
      35             :                 /* nop */
      36             :         }
      37         282 : }
      38             : 
      39             : static int use_nullbind = 0;
      40             : 
      41             : static void
      42         368 : test0(int n,  const char * expected)
      43             : {
      44             :         DBINT ind, expected_ind;
      45             :         char text_buf[16];
      46             : 
      47         368 :         dbfcmd(dbproc, "select c from #null where n = %d", n);
      48             : 
      49         368 :         dbsqlexec(dbproc);
      50             : 
      51         368 :         if (dbresults(dbproc) != SUCCEED) {
      52           0 :                 fprintf(stderr, "Was expecting a row.\n");
      53           0 :                 failed = 1;
      54           0 :                 dbcancel(dbproc);
      55           0 :                 return;
      56             :         }
      57             : 
      58         368 :         dbbind(dbproc, 1, NTBSTRINGBIND, 0, (BYTE *)text_buf);
      59         368 :         if (use_nullbind)
      60         184 :                 dbnullbind(dbproc, 1, &ind);
      61             : 
      62         368 :         memset(text_buf, 'a', sizeof(text_buf));
      63         368 :         ind = -5;
      64             : 
      65         368 :         if (dbnextrow(dbproc) != REG_ROW) {
      66           0 :                 fprintf(stderr, "Was expecting a row.\n");
      67           0 :                 failed = 1;
      68           0 :                 dbcancel(dbproc);
      69           0 :                 return;
      70             :         }
      71             : 
      72         368 :         text_buf[sizeof(text_buf) - 1] = 0;
      73         368 :         printf("ind %d text_buf -%s-\n", (int) ind, text_buf);
      74             : 
      75         368 :         expected_ind = 0;
      76         368 :         if (strcmp(expected, "aaaaaaaaaaaaaaa") == 0)
      77          46 :                 expected_ind = -1;
      78             : 
      79             :         /* do not check indicator if not bound */
      80         368 :         if (!use_nullbind)
      81         184 :                 ind = expected_ind;
      82         368 :         if (ind != expected_ind || strcmp(expected, text_buf) != 0) {
      83           0 :                 fprintf(stderr, "expected_ind %d expected -%s-\n", (int) expected_ind, expected);
      84           0 :                 failed = 1;
      85           0 :                 dbcancel(dbproc);
      86           0 :                 return;
      87             :         }
      88             : 
      89         368 :         if (dbnextrow(dbproc) != NO_MORE_ROWS) {
      90           0 :                 fprintf(stderr, "Only one row expected\n");
      91           0 :                 dbcancel(dbproc);
      92           0 :                 failed = 1;
      93             :         }
      94             : 
      95         368 :         while (dbresults(dbproc) == SUCCEED) {
      96             :                 /* nop */
      97             :         }
      98             : }
      99             : 
     100             : 
     101             : static void
     102          52 : test(const char *type, int give_err)
     103             : {
     104             :         RETCODE ret;
     105             : 
     106          52 :         query("if object_id('#null') is not NULL drop table #null");
     107             : 
     108          52 :         dberrhandle(ignore_err_handler);
     109          52 :         dbmsghandle(ignore_msg_handler);
     110             : 
     111          52 :         printf("create table #null (n int, c %s NULL)\n", type);
     112          52 :         dbfcmd(dbproc, "create table #null (n int, c %s NULL)", type);
     113          52 :         dbsqlexec(dbproc);
     114             : 
     115          52 :         ret = dbresults(dbproc);
     116             : 
     117          52 :         dberrhandle(syb_err_handler);
     118          52 :         dbmsghandle(syb_msg_handler);
     119             : 
     120          52 :         if (ret != SUCCEED) {
     121           6 :                 dbcancel(dbproc);
     122           6 :                 if (!give_err)
     123             :                         return;
     124           0 :                 printf("Was expecting a result set.\n");
     125           0 :                 failed = 1;
     126           0 :                 return;
     127             :         }
     128             : 
     129          46 :         query("insert into #null values(1, '')");
     130          46 :         query("insert into #null values(2, NULL)");
     131          46 :         query("insert into #null values(3, ' ')");
     132          46 :         query("insert into #null values(4, 'foo')");
     133             : 
     134          46 :         use_nullbind = 1;
     135          46 :         test0(1, "");
     136          46 :         test0(2, "aaaaaaaaaaaaaaa");
     137          46 :         test0(3, "");
     138          46 :         test0(4, "foo");
     139             : 
     140          46 :         use_nullbind = 0;
     141          46 :         test0(1, "");
     142          46 :         test0(2, "");
     143          46 :         test0(3, "");
     144          46 :         test0(4, "foo");
     145             : 
     146          46 :         query("drop table #null");
     147             : }
     148             : 
     149             : int
     150           8 : main(int argc, char **argv)
     151             : {
     152             :         LOGINREC *login;
     153             : 
     154           8 :         read_login_info(argc, argv);
     155             : 
     156           8 :         printf("Starting %s\n", argv[0]);
     157             : 
     158           8 :         dbinit();
     159             : 
     160           8 :         dberrhandle(syb_err_handler);
     161           8 :         dbmsghandle(syb_msg_handler);
     162             : 
     163           8 :         printf("About to logon\n");
     164             : 
     165           8 :         login = dblogin();
     166           8 :         DBSETLPWD(login, PASSWORD);
     167           8 :         DBSETLUSER(login, USER);
     168           8 :         DBSETLAPP(login, "null2");
     169             : 
     170           8 :         printf("About to open \"%s\"\n", SERVER);
     171             : 
     172           8 :         dbproc = dbopen(login, SERVER);
     173           8 :         if (!dbproc) {
     174           0 :                 fprintf(stderr, "Unable to connect to %s\n", SERVER);
     175           0 :                 return 1;
     176             :         }
     177             : 
     178           8 :         dbloginfree(login);
     179             : 
     180           8 :         if (strlen(DATABASE))
     181           8 :                 dbuse(dbproc, DATABASE);
     182             : 
     183           8 :         test("VARCHAR(10)", 1);
     184           8 :         test("CHAR(10)", 1);
     185           8 :         test("TEXT", 1);
     186             : 
     187           8 :         test("NVARCHAR(10)", 0);
     188             : #ifndef DBNTWIN32
     189           8 :         if (dbtds(dbproc) >= DBTDS_7_0)
     190           6 :                 test("NTEXT", 0);
     191             : #endif
     192             : 
     193           8 :         test("VARCHAR(MAX)", 0);
     194             : #ifndef DBNTWIN32
     195           8 :         if (dbtds(dbproc) >= DBTDS_7_0)
     196           6 :                 test("NVARCHAR(MAX)", 0);
     197             : #endif
     198             : 
     199           8 :         dbexit();
     200             : 
     201           8 :         return failed ? 1 : 0;
     202             : }
     203             : 

Generated by: LCOV version 1.13