LTP GCOV extension - code coverage report
Current view: directory - dblib/unittests - null.c
Test: FreeTDS coverage
Date: 2008-11-21 Instrumented lines: 82
Code covered: 85.4 % Executed lines: 70

       1                 : /* 
       2                 :  * Purpose: Test NULL behavior in order to fix problems with PHP and NULLs
       3                 :  */
       4                 : #include <stdio.h>
       5                 : #include <stdlib.h>
       6                 : #include <string.h>
       7                 : #include <ctype.h>
       8                 : #include <sybfront.h>
       9                 : #include <sybdb.h>
      10                 : 
      11                 : #include "common.h"
      12                 : 
      13                 : static char software_version[] = "$Id: null.c,v 1.1.2.2 2007/11/15 13:52:58 freddy77 Exp $";
      14                 : static void *no_unused_var_warn[] = { software_version, no_unused_var_warn };
      15                 : 
      16                 : static DBPROCESS *dbproc = NULL;
      17                 : static int failed = 0;
      18                 : 
      19                 : static int
      20                 : ignore_msg_handler(DBPROCESS * dbproc, DBINT msgno, int state, int severity, char *text, char *server, char *proc, int line)
      21              24 : {
      22              24 :         dbsetuserdata(dbproc, (BYTE*) &msgno);
      23              24 :         return syb_msg_handler(dbproc, msgno, state, severity, text, server, proc, line);
      24                 : }
      25                 : 
      26                 : static int
      27                 : ignore_err_handler(DBPROCESS * dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr)
      28              24 : {
      29              24 :         dbsetuserdata(dbproc, (BYTE*) &dberr);
      30              24 :         return syb_err_handler(dbproc, severity, dberr, oserr, dberrstr, oserrstr);
      31                 : }
      32                 : 
      33                 : static void
      34                 : query(const char *query)
      35              78 : {
      36              78 :         printf("query: %s\n", query);
      37              78 :         dbcmd(dbproc, (char *) query);
      38              78 :         dbsqlexec(dbproc);
      39             138 :         while (dbresults(dbproc) == SUCCEED) {
      40                 :                 /* nop */
      41                 :         }
      42              78 : }
      43                 : 
      44                 : static void
      45                 : test0(int n, int len)
      46              48 : {
      47              48 :         dbfcmd(dbproc, "select c from #null where n = %d", n);
      48                 : 
      49              48 :         dbsqlexec(dbproc);
      50                 : 
      51              48 :         if (dbresults(dbproc) != SUCCEED || dbnextrow(dbproc) != REG_ROW) {
      52               0 :                 fprintf(stdout, "Was expecting a row.\n");
      53               0 :                 failed = 1;
      54               0 :                 dbcancel(dbproc);
      55               0 :                 return;
      56                 :         }
      57                 : 
      58              48 :         if (dbdatlen(dbproc, 1) != (len < 0 ? 0 : len) || (len < 0 && dbdata(dbproc, 1) != NULL) || (len >= 0 && dbdata(dbproc, 1) == NULL)) {
      59               6 :                 fprintf(stderr, "Unexpected result for n == %d len %d data %p\n", n, dbdatlen(dbproc, 1), dbdata(dbproc, 1));
      60               6 :                 dbcancel(dbproc);
      61               6 :                 failed = 1;
      62                 :         }
      63                 : 
      64              48 :         if (dbnextrow(dbproc) != NO_MORE_ROWS) {
      65               0 :                 fprintf(stderr, "Only one row expected\n");
      66               0 :                 dbcancel(dbproc);
      67               0 :                 failed = 1;
      68                 :         }
      69                 : 
      70              48 :         while (dbresults(dbproc) == SUCCEED) {
      71                 :                 /* nop */
      72                 :         }
      73                 : }
      74                 : 
      75                 : 
      76                 : static void
      77                 : test(const char *type, int give_err)
      78              18 : {
      79                 :         RETCODE ret;
      80                 : 
      81              18 :         dberrhandle(ignore_err_handler);
      82              18 :         dbmsghandle(ignore_msg_handler);
      83                 : 
      84              18 :         query("drop table #null");
      85                 : 
      86              18 :         printf("create table #null (n int, c %s NULL)\n", type);
      87              18 :         dbfcmd(dbproc, "create table #null (n int, c %s NULL)", type);
      88              18 :         dbsqlexec(dbproc);
      89                 : 
      90              18 :         ret = dbresults(dbproc);
      91                 : 
      92              18 :         dberrhandle(syb_err_handler);
      93              18 :         dbmsghandle(syb_msg_handler);
      94                 : 
      95              18 :         if (ret != SUCCEED) {
      96               6 :                 dbcancel(dbproc);
      97               6 :                 if (!give_err)
      98               6 :                         return;
      99               0 :                 fprintf(stdout, "Was expecting a result set.\n");
     100               0 :                 failed = 1;
     101               0 :                 return;
     102                 :         }
     103                 : 
     104              12 :         query("insert into #null values(1, '')");
     105              12 :         query("insert into #null values(2, NULL)");
     106              12 :         query("insert into #null values(3, ' ')");
     107              12 :         query("insert into #null values(4, 'a')");
     108                 : 
     109              12 :         test0(1, 0);
     110              12 :         test0(2, -1);
     111              12 :         test0(3, 1);
     112              12 :         test0(4, 1);
     113                 : 
     114              12 :         query("drop table #null");
     115                 : }
     116                 : 
     117                 : int
     118                 : main(int argc, char **argv)
     119               3 : {
     120                 :         LOGINREC *login;
     121                 : 
     122               3 :         read_login_info(argc, argv);
     123                 : 
     124               3 :         fprintf(stdout, "Start\n");
     125                 : 
     126               3 :         dbinit();
     127                 : 
     128               3 :         dberrhandle(syb_err_handler);
     129               3 :         dbmsghandle(syb_msg_handler);
     130                 : 
     131               3 :         fprintf(stdout, "About to logon\n");
     132                 : 
     133               3 :         login = dblogin();
     134               3 :         DBSETLPWD(login, PASSWORD);
     135               3 :         DBSETLUSER(login, USER);
     136               3 :         DBSETLAPP(login, "thread");
     137                 : 
     138               3 :         fprintf(stdout, "About to open \"%s\"\n", SERVER);
     139                 : 
     140               3 :         dbproc = dbopen(login, SERVER);
     141               3 :         if (!dbproc) {
     142               0 :                 fprintf(stderr, "Unable to connect to %s\n", SERVER);
     143               0 :                 return 1;
     144                 :         }
     145                 : 
     146               3 :         dbloginfree(login);
     147                 : 
     148               3 :         if (strlen(DATABASE))
     149               3 :                 dbuse(dbproc, DATABASE);
     150                 : 
     151               3 :         test("VARCHAR(10)", 1);
     152               3 :         test("TEXT", 1);
     153                 : 
     154               3 :         test("NVARCHAR(10)", 0);
     155               3 :         test("NTEXT", 0);
     156                 : 
     157               3 :         test("VARCHAR(MAX)", 0);
     158               3 :         test("NVARCHAR(MAX)", 0);
     159                 : 
     160               3 :         dbexit();
     161                 : 
     162               3 :         return failed ? 1 : 0;
     163                 : }
     164                 : 

Generated by: LTP GCOV extension version 1.6