Prepared statements + binary protocol test update

tests/client_test.c

@@ -32,14 +32,13 @@
 #include <stdio.h>
 #include <string.h>
 
-#include <assert.h>
-
-
 /* mysql client headers */
 #include <my_sys.h>
 #include <mysql.h>
 #include <my_getopt.h>
 
+#include <assert.h>
+
 #ifndef true
 #define true 1
 #endif
@@ -58,100 +57,119 @@ static char *opt_user=0;
 static char *opt_password=0;
 static char *opt_host=0;
 static char *opt_unix_socket=0;
-static uint  opt_port;
+static unsigned int  opt_port;
 static my_bool tty_password=0;
 
 static MYSQL *mysql=0;
 static char query[255]; 
+static char current_db[]= "client_test_db";
 
-#define myheader(str) { printf("\n\n#######################\n"); \
-                        printf("%s",str); \
-                        printf("\n#######################\n"); \
+#define myheader(str) { fprintf(stdout,"\n\n#######################\n"); \
+                        fprintf(stdout,"%s",str); \
+                        fprintf(stdout,"\n#######################\n"); \
                       }
 
 #define init_bind(x) (bzero(x,sizeof(x)))
 
-void print_error(const char *msg)
+#ifndef mysql_param_result
+#define mysql_param_result mysql_prepare_result
+#endif
+
+static void print_error(const char *msg)
 {  
   if (mysql)
   {
-    fprintf(stderr,"\n [MySQL]%s \n",mysql_error(mysql));
+    if (mysql->server_version)
+      fprintf(stderr,"\n [MySQL-%s]",mysql->server_version);
+    else
+      fprintf(stderr,"\n [MySQL]");
+    fprintf(stderr," %s\n",mysql_error(mysql));
   }
-  else if(msg) fprintf(stderr, "%s\n", msg);
+  else if(msg) fprintf(stderr, " [MySQL] %s\n", msg);
 }
 
-void print_st_error(MYSQL_STMT *stmt, const char *msg)
+static void print_st_error(MYSQL_STMT *stmt, const char *msg)
 {  
   if (stmt)
   {
-    fprintf(stderr,"\n [MySQL]%s \n",mysql_stmt_error(stmt));
+    if (stmt->mysql && stmt->mysql->server_version)
+      fprintf(stderr,"\n [MySQL-%s]",stmt->mysql->server_version);
+    else
+      fprintf(stderr,"\n [MySQL]");
+
+    fprintf(stderr," %s\n",mysql_stmt_error(stmt));
   }
-  else if(msg) fprintf(stderr, "%s\n", msg);
+	else if(msg) fprintf(stderr, " [MySQL] %s\n", msg);
 }
+static void client_disconnect();
 
 #define myerror(msg) print_error(msg)
 #define mysterror(stmt, msg) print_st_error(stmt, msg)
 
-#define myassert(x) if(x) {\
-  fprintf(stderr,"ASSERTION FAILED AT %d@%s\n",__LINE__, __FILE__);\
-  exit(1);\
+#define myassert(exp) \
+  if(!exp) {\
+    client_disconnect(); \
+    fprintf(stderr,"\n"); \
+    assert(exp); \
 }
-#define myassert_r(x) if(!x) {\
-  fprintf(stderr,"ASSERTION FAILED AT %d@%s\n",__LINE__, __FILE__);\
-  exit(1);\
+#define myassert_r(exp) \
+  if(exp) {\
+    client_disconnect(); \
+    fprintf(stderr,"\n"); \
+    assert(!(exp)); \
 }
 
 #define myquery(r) \
-if( r != 0) \
 { \
+if( r || r == -1) \
   myerror(NULL); \
-  myassert(true);\
+ myassert(r == 0); \
 }
 
 #define myquery_r(r) \
-if( r != 0) \
 { \
+if( r || r == -1) \
   myerror(NULL); \
-  myassert_r(true);\
+myassert_r(r == 0); \
 }
 
 #define mystmt(stmt,r) \
-if( r != 0) \
 { \
+if( r || r == -1) \
   mysterror(stmt,NULL); \
-  myassert(true);\
+myassert(r == 0);\
 }
 
-#define myxquery(stmt) \
-if( stmt == 0) \
+#define mystmt_r(stmt,r) \
 { \
-  myerror(NULL); \
-  myassert(true);\
+if( r || r == -1) \
+  mysterror(stmt,NULL); \
+myassert_r(r == 0);\
 }
 
-#define myxquery_r(stmt) \
-if( stmt == 0) \
+#define mystmt_init(stmt) \
 { \
+if( stmt == 0) \
   myerror(NULL); \
-  myassert_r(true);\
-} \
-else myassert(true);
+myassert(stmt != 0); \
+}
 
-#define mystmt_r(stmt,r) \
-if( r != 0) \
+#define mystmt_init_r(stmt) \
 { \
-  mysterror(stmt,NULL); \
-  myassert_r(true);\
+myassert(stmt == 0);\
 } 
 
 #define mytest(x) if(!x) {myerror(NULL);myassert(true);}
 #define mytest_r(x) if(x) {myerror(NULL);myassert(true);}
 
+#define PREPARE(A,B) mysql_prepare(A,B,strlen(B))
+
 /********************************************************
 * connect to the server                                 *
 *********************************************************/
 static void client_connect()
 {
+  char buff[255];
   myheader("client_connect");  
 
   if(!(mysql = mysql_init(NULL)))
@@ -164,27 +182,36 @@ static void client_connect()
 			   opt_unix_socket, 0)))
   {
     myerror("connection failed");    
+    mysql_close(mysql);
     exit(0);
   }    
 
   /* set AUTOCOMMIT to ON*/
   mysql_autocommit(mysql, true);
+  sprintf(buff,"CREATE DATABASE IF NOT EXISTS %s", current_db);
+  mysql_query(mysql, buff);
+  sprintf(buff,"USE %s", current_db);
+  mysql_query(mysql, buff);
 }
 
 /********************************************************
 * close the connection                                  *
 *********************************************************/
-void client_disconnect()
+static void client_disconnect()
 {
-  myheader("client_disconnect");
-
+  if (mysql)
+  {
+    char buff[255];
+    sprintf(buff,"DROP DATABASE IF EXISTS %s", current_db);
+    mysql_query(mysql, buff);
     mysql_close(mysql);
+  }
 }
 
 /********************************************************
 * query processing                                      *
 *********************************************************/
-void client_query()
+static void client_query()
 {
   int rc;
 
@@ -222,7 +249,7 @@ void client_query()
 /********************************************************
 * print dashes                                          *
 *********************************************************/
-void my_print_dashes(MYSQL_RES *result)
+static void my_print_dashes(MYSQL_RES *result)
 {
   MYSQL_FIELD  *field;
   unsigned int i,j;
@@ -244,7 +271,7 @@ void my_print_dashes(MYSQL_RES *result)
 /********************************************************
 * print resultset metadata information                  *
 *********************************************************/
-void my_print_result_metadata(MYSQL_RES *result)
+static void my_print_result_metadata(MYSQL_RES *result)
 {
   MYSQL_FIELD  *field;
   unsigned int i,j;
@@ -288,6 +315,9 @@ int my_process_result_set(MYSQL_RES *result)
   unsigned int i;
   unsigned int row_count=0;
   
+  if (!result)
+    return 0;
+
   my_print_result_metadata(result);
 
   while((row = mysql_fetch_row(result)) != NULL)
@@ -313,50 +343,157 @@ int my_process_result_set(MYSQL_RES *result)
   my_print_dashes(result);
 
   if (mysql_errno(mysql) != 0)
-    fprintf(stderr, "\n\tmysql_fetch_row() failed\n");
+    fprintf(stderr, "\n mysql_fetch_row() failed\n");
   else
-    fprintf(stdout,"\n\t%d rows returned\n", row_count);
+    fprintf(stdout,"\n %d rows returned", row_count);
   return(row_count);
 }
 
-static void verify_col_data(const char *table, const char *col, const char *exp_data)
+/********************************************************
+* process the stmt result set                           *
+*********************************************************/
+uint my_process_stmt_result(MYSQL_STMT *stmt)
 {
-  MYSQL_STMT *stmt;
-  MYSQL_BIND  bind[1];
-  char        data[255];
-  int         rc;
+  int         field_count;
+  uint        row_count= 0;
+  MYSQL_BIND  buffer[50];
+  MYSQL_FIELD *field;
+  MYSQL_RES   *result;
+  char        data[50][255];
+  long        length[50];
+  int         rc, i;
 
-  init_bind(bind);
+  if (!(result= mysql_prepare_result(stmt)))
+  {
+    while (!mysql_fetch(stmt));
+    return 0;
+  }
   
-  bind[0].buffer_type=FIELD_TYPE_STRING;
-  bind[0].buffer= (char *)data;
-  bind[0].buffer_length= sizeof(data);
+  field_count= stmt->field_count;
+  for(i=0; i < field_count; i++)
+  {
+    buffer[i].buffer_type= MYSQL_TYPE_STRING;
+    buffer[i].buffer_length=50;
+    buffer[i].length=(long *)&length[i];
+    buffer[i].buffer=(gptr)data[i];
+  }
 
-  sprintf(query, "SELECT `%s` FROM `%s`", col, table);
+  my_print_result_metadata(result);
 
-  printf("\n %s", query);
-  stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  rc= mysql_bind_result(stmt,buffer);
+  mystmt(stmt,rc);
 
-  rc = mysql_bind_result(stmt,bind);
-  mystmt(stmt, rc);
+  mysql_field_seek(result, 0);  
+  while (mysql_fetch(stmt) == 0)
+  {    
+    fputc('\t',stdout);
+    fputc('|',stdout);
 
-  rc = mysql_execute(stmt);
-  mystmt(stmt, rc);
+    for (i=0; i < field_count; i++)
+    {
+      field = mysql_fetch_field(result);
+      if(length[i] == MYSQL_NULL_DATA)
+        fprintf(stdout, " %-*s |", (int) field->max_length, "NULL");
+      else if (IS_NUM(field->type))
+        fprintf(stdout, " %*s |", (int) field->max_length, data[i]);
+      else
+        fprintf(stdout, " %-*s |", (int) field->max_length, data[i]);
+    }
+    fputc('\t',stdout);
+    fputc('\n',stdout);
+    row_count++;
+  }
+  my_print_dashes(result);
+  fprintf(stdout,"\n %d rows returned", row_count);
+  mysql_free_result(result);
 
-  rc = mysql_fetch(stmt);
-  mystmt(stmt,rc);
+  return row_count;
+}
 
-  printf("\n data : %s (expected: %s)",data, exp_data);
-  assert(strcmp(data,exp_data)==0);
+/*
+  Utility function to verify a particular column data
+*/
+static void verify_col_data(const char *table, const char *col, 
+                            const char *exp_data)
+{
+  MYSQL_RES *result;
+  MYSQL_ROW row;
+  char      query[255]; 
+  int       rc, field= 1;
  
-  mysql_stmt_close(stmt);
+  if (table && col)
+  {
+    sprintf(query, "SELECT %s FROM %s LIMIT 1", col, table);
+
+    fprintf(stdout,"\n %s", query);
+    rc = mysql_query(mysql, query);
+    myquery(rc);
+
+    field= 0;
+  }
+
+  result = mysql_use_result(mysql);
+  mytest(result);
+
+  if (!(row= mysql_fetch_row(result)) || !row[field])
+  {
+    fprintf(stdout,"\n *** ERROR: FAILED TO GET THE RESULT ***");
+    exit(1);
+  }
+  fprintf(stdout,"\n obtained: `%s` (expected: `%s`)", 
+    row[field], exp_data);
+  myassert(strcmp(row[field],exp_data) == 0);
+  mysql_free_result(result);
+}
+
+/*
+  Utility function to verify the field members
+*/
+
+static void verify_prepare_field(MYSQL_RES *result, 
+      unsigned int no,const char *name, const char *org_name, 
+      enum enum_field_types type, const char *table, 
+      const char *org_table, const char *db)
+{
+  MYSQL_FIELD *field;
+
+  if (!(field= mysql_fetch_field_direct(result,no)))
+  {
+    fprintf(stdout,"\n *** ERROR: FAILED TO GET THE RESULT ***");
+    exit(1);
+  }
+  fprintf(stdout,"\n field[%d]:", no);
+  fprintf(stdout,"\n    name     :`%s`\t(expected: `%s`)", field->name, name);
+  fprintf(stdout,"\n    org_name :`%s`\t(expected: `%s`)", field->org_name, org_name);
+  fprintf(stdout,"\n    type     :`%d`\t(expected: `%d`)", field->type, type);
+  fprintf(stdout,"\n    table    :`%s`\t(expected: `%s`)", field->table, table);
+  fprintf(stdout,"\n    org_table:`%s`\t(expected: `%s`)", field->org_table, org_table);
+  fprintf(stdout,"\n    database :`%s`\t(expected: `%s`)", field->db, db);
+  fprintf(stdout,"\n");
+  myassert(strcmp(field->name,name) == 0);
+  myassert(strcmp(field->org_name,org_name) == 0);
+  myassert(field->type == type);
+  myassert(strcmp(field->table,table) == 0);
+  myassert(strcmp(field->org_table,org_table) == 0);
+  myassert(strcmp(field->db,db) == 0);
+}
+
+/*
+  Utility function to verify the parameter count
+*/
+static void verify_param_count(MYSQL_STMT *stmt, long exp_count)
+{
+  long param_count= mysql_param_count(stmt);
+  fprintf(stdout,"\n total parameters in stmt: %ld (expected: %ld)",
+                  param_count, exp_count);
+  myassert(param_count == exp_count);
 }
 
+
 /********************************************************
 * store result processing                               *
 *********************************************************/
-void client_store_result()
+static void client_store_result()
 {
   MYSQL_RES *result;
   int       rc;
@@ -375,9 +512,9 @@ void client_store_result()
 }
 
 /********************************************************
-* use result processing                                 *
+* fetch the results
 *********************************************************/
-void client_use_result()
+static void client_use_result()
 {
   MYSQL_RES *result;
   int       rc;
@@ -398,7 +535,7 @@ void client_use_result()
 /********************************************************
 * query processing                                      *
 *********************************************************/
-void test_debug_example()
+static void test_debug_example()
 {
   int rc;
   MYSQL_RES *result;
@@ -418,7 +555,7 @@ void test_debug_example()
   rc = mysql_query(mysql,"UPDATE test_debug_example SET name='updated' WHERE name='deleted'");
   myquery(rc);
 
-  rc = mysql_query(mysql,"SELECT * FROM test_debug_example");
+  rc = mysql_query(mysql,"SELECT * FROM test_debug_example where name='mysql'");
   myquery(rc);
 
   result = mysql_use_result(mysql);
@@ -434,7 +571,7 @@ void test_debug_example()
 /********************************************************
 * to test autocommit feature                            *
 *********************************************************/
-void test_tran_bdb()
+static void test_tran_bdb()
 {
   MYSQL_RES *result;
   MYSQL_ROW row;
@@ -512,7 +649,7 @@ void test_tran_bdb()
 /********************************************************
 * to test autocommit feature                            *
 *********************************************************/
-void test_tran_innodb()
+static void test_tran_innodb()
 {
   MYSQL_RES *result;
   MYSQL_ROW row;
@@ -591,10 +728,10 @@ void test_tran_innodb()
  To test simple prepares of all DML statements
 *********************************************************/
 
-void test_prepare_simple()
+static void test_prepare_simple()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
+  int        rc;
 
   myheader("test_prepare_simple");
 
@@ -610,41 +747,33 @@ void test_prepare_simple()
   /* alter table */
   strcpy(query,"ALTER TABLE test_prepare_simple ADD new char(20)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout,"\n total parameters in alter:%d\n", param_count);
-  assert(param_count == 0);
+  verify_param_count(stmt,0);
   mysql_stmt_close(stmt);
 
   /* insert */
   strcpy(query,"INSERT INTO test_prepare_simple VALUES(?,?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout,"\n total parameters in insert:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
   mysql_stmt_close(stmt);
 
   /* update */
   strcpy(query,"UPDATE test_prepare_simple SET id=? WHERE id=? AND name= ?");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout,"\n total parameters in update:%d\n", param_count);
-  assert(param_count == 3);
+  verify_param_count(stmt,3);
   mysql_stmt_close(stmt);
 
   /* delete */
   strcpy(query,"DELETE FROM test_prepare_simple WHERE id=10");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout,"\n total parameters in delete:%d\n", param_count);
-  assert(param_count == 0);
+  verify_param_count(stmt,0);
 
   rc = mysql_execute(stmt);
   mystmt(stmt, rc);
@@ -653,11 +782,9 @@ void test_prepare_simple()
   /* delete */
   strcpy(query,"DELETE FROM test_prepare_simple WHERE id=?");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout,"\n total parameters in delete:%d\n", param_count);
-  assert(param_count == 1);
+  verify_param_count(stmt,1);
 
   rc = mysql_execute(stmt);
   mystmt_r(stmt, rc);
@@ -666,11 +793,9 @@ void test_prepare_simple()
   /* select */
   strcpy(query,"SELECT * FROM test_prepare_simple WHERE id=? AND name= ?");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout,"\n total parameters in select:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
 
   mysql_stmt_close(stmt);
 
@@ -683,9 +808,10 @@ void test_prepare_simple()
 /********************************************************
 * to test simple prepare field results                  *
 *********************************************************/
-void test_prepare_field_result()
+static void test_prepare_field_result()
 {
   MYSQL_STMT *stmt;
+  MYSQL_RES  *result;
   int        rc,param_count;
 
   myheader("test_prepare_field_result");
@@ -696,29 +822,47 @@ void test_prepare_field_result()
   rc = mysql_commit(mysql);
   myquery(rc);
 
-  rc = mysql_query(mysql,"CREATE TABLE test_prepare_field_result(id int, name varchar(50), extra int)");
+  rc = mysql_query(mysql,"CREATE TABLE test_prepare_field_result(int_c int, \
+                          var_c varchar(50), ts_c timestamp(14),\
+                          char_c char(3), date_c date,extra tinyint)");
   myquery(rc); 
 
   /* insert */
-  strcpy(query,"SELECT id,name FROM test_prepare_field_result WHERE id=?");
+  strcpy(query,"SELECT int_c,var_c,date_c as date,ts_c,char_c FROM \
+                  test_prepare_field_result as t1 WHERE int_c=?");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout,"\n total parameters in insert:%d\n", param_count);
-  assert(param_count == 1);
-  mysql_stmt_close(stmt);
+  verify_param_count(stmt,1);
 
-  /* now fetch the results ..*/
-  rc = mysql_commit(mysql);
-  myquery(rc);
+  result = mysql_prepare_result(stmt);
+  mytest(result);
+  
+  my_print_result_metadata(result);
+
+  fprintf(stdout,"\n\n field attributes:\n");
+  verify_prepare_field(result,0,"int_c","int_c",MYSQL_TYPE_LONG,
+                       "t1","test_prepare_field_result",current_db);
+  verify_prepare_field(result,1,"var_c","var_c",MYSQL_TYPE_VAR_STRING,
+                       "t1","test_prepare_field_result",current_db);
+  verify_prepare_field(result,2,"date","date_c",MYSQL_TYPE_DATE,
+                       "t1","test_prepare_field_result",current_db);
+  verify_prepare_field(result,3,"ts_c","ts_c",MYSQL_TYPE_TIMESTAMP,
+                       "t1","test_prepare_field_result",current_db);
+  verify_prepare_field(result,4,"char_c","char_c",MYSQL_TYPE_STRING,
+                       "t1","test_prepare_field_result",current_db);
+
+  param_count= mysql_num_fields(result);
+  fprintf(stdout,"\n\n total fields: `%d` (expected: `5`)", param_count);
+  myassert(param_count == 5);
+  mysql_stmt_close(stmt);
 }
 
 
 /********************************************************
 * to test simple prepare field results                  *
 *********************************************************/
-void test_prepare_syntax()
+static void test_prepare_syntax()
 {
   MYSQL_STMT *stmt;
   int        rc;
@@ -736,11 +880,11 @@ void test_prepare_syntax()
 
   strcpy(query,"INSERT INTO test_prepare_syntax VALUES(?");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery_r(stmt);
+  mystmt_init_r(stmt);
 
   strcpy(query,"SELECT id,name FROM test_prepare_syntax WHERE id=? AND WHERE");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery_r(stmt);
+  mystmt_init_r(stmt);
 
   /* now fetch the results ..*/
   rc = mysql_commit(mysql);
@@ -751,10 +895,10 @@ void test_prepare_syntax()
 /********************************************************
 * to test simple prepare                                *
 *********************************************************/
-void test_prepare()
+static void test_prepare()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
+  int        rc;
   char       query[200];
   int        int_data;
   char       str_data[50];
@@ -779,7 +923,7 @@ void test_prepare()
   myquery(rc);
 
   rc = mysql_query(mysql,"CREATE TABLE my_prepare(col1 tinyint,\
-                                col2 varchar(50), col3 int,\
+                                col2 varchar(15), col3 int,\
                                 col4 smallint, col5 bigint, \
                                 col6 float, col7 double )");
   myquery(rc);
@@ -787,11 +931,9 @@ void test_prepare()
   /* insert by prepare */
   strcpy(query,"INSERT INTO my_prepare VALUES(?,?,?,?,?,?,?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 7);
+  verify_param_count(stmt,7);
 
   /* tinyint */
   bind[0].buffer_type=FIELD_TYPE_TINY;
@@ -852,7 +994,7 @@ void test_prepare()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert((int)tiny_data == my_process_result_set(result));
+  myassert((int)tiny_data == my_process_result_set(result));
   mysql_free_result(result);
 
 }
@@ -860,10 +1002,10 @@ void test_prepare()
 /********************************************************
 * to test double comparision                            *
 *********************************************************/
-void test_double_compare()
+static void test_double_compare()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
+  int        rc;
   char       query[200],real_data[10], tiny_data;
   double     double_data;
   MYSQL_RES  *result;
@@ -890,10 +1032,9 @@ void test_double_compare()
 
   strcpy(query, "UPDATE test_double_compare SET col1=100 WHERE col1 = ? AND col2 = ? AND COL3 = ?");
   stmt = mysql_prepare(mysql,query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in update:%d\n", param_count);
+  verify_param_count(stmt,3);
 
   /* tinyint */
   bind[0].buffer_type=FIELD_TYPE_TINY;
@@ -916,7 +1057,7 @@ void test_double_compare()
   mystmt(stmt, rc);
 
   rc = (int)mysql_affected_rows(mysql);
-  printf("\n total affected rows:%d",rc);
+  fprintf(stdout,"\n total affected rows:%d",rc);
 
   mysql_stmt_close(stmt);
 
@@ -932,21 +1073,17 @@ void test_double_compare()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert((int)tiny_data == my_process_result_set(result));
+  myassert((int)tiny_data == my_process_result_set(result));
   mysql_free_result(result);
-
 }
 
-
-
-
 /********************************************************
 * to test simple null                                   *
 *********************************************************/
-void test_null()
+static void test_null()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
+  int        rc;
   int        nData=1;
   MYSQL_RES  *result;
   MYSQL_BIND bind[2];
@@ -966,15 +1103,13 @@ void test_null()
   /* insert by prepare, wrong column name */
   strcpy(query,"INSERT INTO test_null(col3,col2) VALUES(?,?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery_r(stmt);
+  mystmt_init_r(stmt);
 
   strcpy(query,"INSERT INTO test_null(col1,col2) VALUES(?,?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
 
   bind[0].is_null=1;
   bind[0].buffer_type=MYSQL_TYPE_NULL;
@@ -1003,77 +1138,145 @@ void test_null()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert(nData == my_process_result_set(result));
+  myassert(nData == my_process_result_set(result));
   mysql_free_result(result);
 }
 
 
-
 /********************************************************
-* to test simple select                                 *
+* to test fetch null                                    *
 *********************************************************/
-void test_select_simple()
+static void test_fetch_null()
 {
   MYSQL_STMT *stmt;
-  int        rc,length;
+  int        rc;
   const char query[100];
-  MYSQL_RES  *result;
+  int        length[11], i, nData;
+  MYSQL_BIND bind[11];
 
-  myheader("test_select_simple");
+  myheader("test_fetch_null");
 
-  /* insert by prepare */
-  strcpy((char *)query, "SHOW TABLES FROM mysql");
+  init_bind(bind);
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_fetch_null");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"CREATE TABLE test_fetch_null(col1 tinyint, col2 smallint, \
+                                                       col3 int, col4 bigint, \
+                                                       col5 float, col6 double, \
+                                                       col7 date, col8 time, \
+                                                       col9 varbinary(10), \
+                                                       col10 varchar(50),\
+                                                       col11 char(20))");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"INSERT INTO test_fetch_null(col11) VALUES(1000)");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  /* fetch */
+  for (i=0; i < 10; i++)
+  {
+    bind[i].buffer_type=FIELD_TYPE_LONG;
+    length[i]=99;
+    bind[i].length= (long *)&length[i];
+  }
+  bind[i].buffer_type=FIELD_TYPE_LONG;
+  bind[i].buffer=(gptr)&nData;
+
+  strcpy((char *)query , "SELECT * FROM test_fetch_null");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  length = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in select:%d\n", length);
-  assert(length == 0);
+  rc = mysql_bind_result(stmt,bind);
+  mystmt(stmt, rc);
 
   rc = mysql_execute(stmt);
   mystmt(stmt, rc);
 
-  /* get the result */
-  result = mysql_store_result(mysql);
-  mytest(result);
+  rc = mysql_fetch(stmt);
+  mystmt(stmt,rc);
 
-  my_process_result_set(result);
-  mysql_free_result(result);
+  for (i=0; i < 10; i++)
+  {
+    fprintf(stdout, "\n data[%d]: %s", i, length[i] == MYSQL_NULL_DATA ? "NULL" : "NOT NULL");
+    myassert(length[i] == MYSQL_NULL_DATA);
+  }
+  fprintf(stdout, "\n data[%d]: %d", i, nData);
+  myassert(nData == 1000);
+
+  rc = mysql_fetch(stmt);
+  myassert(rc == MYSQL_NO_DATA);
 
   mysql_stmt_close(stmt);
+}
 
-#if 0
-  strcpy((char *)query , "SELECT @@ VERSION");
-  length = strlen(query);
-  rc = mysql_query(mysql,query);
-  myquery(rc);
+/********************************************************
+* to test simple select                                 *
+*********************************************************/
+static void test_select_version()
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  const char query[100];
 
-  /* get the result */
-  result = mysql_store_result(mysql);
-  mytest(result);
+  myheader("test_select_version");
 
-  my_process_result_set(result);
-  mysql_free_result(result);
-#endif
-}
+  strcpy((char *)query , "SELECT @@version");
+  stmt = PREPARE(mysql, query);
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,0);
 
+  rc = mysql_execute(stmt);
+  mystmt(stmt, rc);
+
+  my_process_stmt_result(stmt);
+  mysql_stmt_close(stmt);
+}
 
 /********************************************************
 * to test simple select                                 *
 *********************************************************/
-void test_select()
+static void test_select_simple()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count=0;
-  char       *szData=(char *)"updated-value";
-  int        nData=1;
-  MYSQL_BIND bind[2];
-  MYSQL_RES  *result;
+  int        rc;
+  const char query[100];
 
+  myheader("test_select_simple");
 
-  myheader("test_select");
+  /* insert by prepare */
+  strcpy((char *)query, "SHOW TABLES FROM mysql");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,0);
+
+  rc = mysql_execute(stmt);
+  mystmt(stmt, rc);
+
+  my_process_stmt_result(stmt);
+  mysql_stmt_close(stmt);
+}
+
+/********************************************************
+* to test simple select to debug                        *
+*********************************************************/
+static void test_select_direct()
+{
+  int        rc;
+  MYSQL_RES  *result;
+
+  myheader("test_select_direct");
   
-  init_bind(bind);
   rc = mysql_autocommit(mysql,true);
   myquery(rc);
 
@@ -1083,111 +1286,249 @@ void test_select()
   rc = mysql_commit(mysql);
   myquery(rc);
 
-  rc = mysql_query(mysql,"CREATE TABLE test_select(id int,name varchar(50))");
+  rc = mysql_query(mysql,"CREATE TABLE test_select(id int, id1 tinyint, \
+                                                   id2 float, \
+                                                   id3 double, \
+                                                   name varchar(50))");
   myquery(rc);
 
   rc = mysql_commit(mysql);
   myquery(rc);
 
   /* insert a row and commit the transaction */
-  rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,'venu')");
+  rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,5,2.3,4.5,'venu')");
   myquery(rc);
 
   rc = mysql_commit(mysql);
   myquery(rc);
 
-    /* now insert the second row, and rollback the transaction */
-  rc = mysql_query(mysql,"INSERT INTO test_select VALUES(20,'mysql')");
-  myquery(rc);
-
-  rc = mysql_commit(mysql);
+  rc = mysql_query(mysql,"SELECT * FROM test_select");
   myquery(rc);
 
-  strcpy(query,"SELECT * FROM test_select WHERE id=? AND name=?");
-  stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
-
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in select:%d\n", param_count);
-  assert(param_count == 2);
-
-  /* string data */
-  nData=10;
-  szData=(char *)"venu";
-  bind[1].buffer_type=FIELD_TYPE_STRING;
-  bind[1].buffer=szData;
-  bind[1].buffer_length=4;
-  bind[0].buffer=(gptr)&nData;
-  bind[0].buffer_type=FIELD_TYPE_LONG;
-
-  rc = mysql_bind_param(stmt,bind);
-  mystmt(stmt, rc);
-
-  rc = mysql_execute(stmt);
-  mystmt(stmt, rc);
-
   /* get the result */
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert( 1 == my_process_result_set(result));
+  my_process_result_set(result);
   mysql_free_result(result);
-
-  mysql_stmt_close(stmt);
-
-  /* bit complicated SELECT */
 }
 
-
-
-
 /********************************************************
-* to test simple update                                *
+* to test simple select with prepare                    *
 *********************************************************/
-void test_simple_update()
+static void test_select_prepare()
 {
+  int        rc, count;
   MYSQL_STMT *stmt;
-  int        rc,param_count;
-  char       szData[25];
-  int        nData=1;
-  MYSQL_RES  *result;
-  MYSQL_BIND bind[2];   
 
-  myheader("test_simple_update");
+  myheader("test_select_prepare");
   
-  init_bind(bind);
   rc = mysql_autocommit(mysql,true);
   myquery(rc);
 
-  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_update");
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_select");
   myquery(rc);
 
   rc = mysql_commit(mysql);
   myquery(rc);
 
-  rc = mysql_query(mysql,"CREATE TABLE test_update(col1 int,\
-                                col2 varchar(50), col3 int )");
+  rc = mysql_query(mysql,"CREATE TABLE test_select(id int, name varchar(50))");
   myquery(rc);
 
   rc = mysql_commit(mysql);
   myquery(rc);
 
-  rc = mysql_query(mysql,"INSERT INTO test_update VALUES(1,'MySQL',100)");
+  /* insert a row and commit the transaction */
+  rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,'venu')");
   myquery(rc);
 
-  assert(1 == mysql_affected_rows(mysql));
-
   rc = mysql_commit(mysql);
   myquery(rc);
 
-  /* insert by prepare */
-  strcpy(query,"UPDATE test_update SET col2=? WHERE col1=?");
+  stmt = mysql_prepare(mysql,"SELECT * FROM test_select",50);
+  mystmt_init(stmt);
+  
+  rc = mysql_execute(stmt);
+  mystmt(stmt,rc);
+
+  count= my_process_stmt_result(stmt);
+
+  rc = mysql_query(mysql,"DROP TABLE test_select");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"CREATE TABLE test_select(id tinyint, id1 int, \
+                                                   id2 float, id3 float, \
+                                                   name varchar(50))");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  /* insert a row and commit the transaction */
+  rc = mysql_query(mysql,"INSERT INTO test_select(id,id1,id2,name) VALUES(10,5,2.3,'venu')");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  stmt = mysql_prepare(mysql,"SELECT * FROM test_select",25);
+  mystmt_init(stmt);
+
+  rc = mysql_execute(stmt);
+  mystmt(stmt,rc);
+
+  my_process_stmt_result(stmt);
+}
+
+/********************************************************
+* to test simple select                                 *
+*********************************************************/
+static void test_select()
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       szData[25];
+  int        nData=1;
+  MYSQL_BIND bind[2];
+
+  myheader("test_select");
+
+  init_bind(bind);
+  rc = mysql_autocommit(mysql,true);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_select");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"CREATE TABLE test_select(id int,name varchar(50))");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  /* insert a row and commit the transaction */
+  rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,'venu')");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+    /* now insert the second row, and rollback the transaction */
+  rc = mysql_query(mysql,"INSERT INTO test_select VALUES(20,'mysql')");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  strcpy(query,"SELECT * FROM test_select WHERE id=? AND name=?");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,2);
+
+  /* string data */
+  nData=10;
+  strcpy(szData,(char *)"venu");
+  bind[1].buffer_type=FIELD_TYPE_STRING;
+  bind[1].buffer=szData;
+  bind[1].buffer_length=4;
+  bind[0].buffer=(gptr)&nData;
+  bind[0].buffer_type=FIELD_TYPE_LONG;
+
+  rc = mysql_bind_param(stmt,bind);
+  mystmt(stmt, rc);
+
+  rc = mysql_execute(stmt);
+  mystmt(stmt, rc);
+
+  myassert( 1 == my_process_stmt_result(stmt));
+
+  mysql_stmt_close(stmt);
+}
+
+/********************************************************
+* to test simple select show                            *
+*********************************************************/
+static void test_select_show()
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  MYSQL_RES  *result;
+
+  myheader("test_select_show");
+
+  mysql_autocommit(mysql,true);
+
+  strcpy(query,"SELECT * FROM mysql.host");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,0);
+
+  rc = mysql_execute(stmt);
+  mystmt(stmt, rc);
+
+  /* get the result */
+  result = mysql_store_result(mysql);
+  mytest(result);
+
+  my_process_result_set(result);
+  mysql_free_result(result);
+
+  mysql_stmt_close(stmt);
+}
+
+/********************************************************
+* to test simple update                                *
+*********************************************************/
+static void test_simple_update()
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       szData[25];
+  int        nData=1;
+  MYSQL_RES  *result;
+  MYSQL_BIND bind[2];   
+
+  myheader("test_simple_update");
+
+  init_bind(bind);
+  rc = mysql_autocommit(mysql,true);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_update");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"CREATE TABLE test_update(col1 int,\
+                                col2 varchar(50), col3 int )");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"INSERT INTO test_update VALUES(1,'MySQL',100)");
+  myquery(rc);
+
+  myassert(1 == mysql_affected_rows(mysql));
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  /* insert by prepare */
+  strcpy(query,"UPDATE test_update SET col2=? WHERE col1=?");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in update:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
 
   nData=1;
   bind[0].buffer_type=FIELD_TYPE_STRING;
@@ -1201,7 +1542,7 @@ void test_simple_update()
 
   rc = mysql_execute(stmt);
   mystmt(stmt, rc);
-  assert(1 == mysql_affected_rows(mysql));
+  myassert(1 == mysql_affected_rows(mysql));
 
   mysql_stmt_close(stmt);
 
@@ -1217,7 +1558,7 @@ void test_simple_update()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert(1 == my_process_result_set(result));
+  myassert(1 == my_process_result_set(result));
   mysql_free_result(result);
 }
 
@@ -1225,10 +1566,10 @@ void test_simple_update()
 /********************************************************
 * to test simple long data handling                     *
 *********************************************************/
-void test_long_data()
+static void test_long_data()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count, int_data=10;
+  int        rc, int_data;
   char       *data=NullS;
   MYSQL_RES  *result;
   MYSQL_BIND bind[3];
@@ -1255,15 +1596,13 @@ void test_long_data()
 
   strcpy(query,"INSERT INTO test_long_data(col1,col2) VALUES(?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery_r(stmt);
+  mystmt_init_r(stmt);
 
   strcpy(query,"INSERT INTO test_long_data(col1,col2,col3) VALUES(?,?,?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 3);
+  verify_param_count(stmt,3);
 
   bind[0].buffer=(char *)&int_data;
   bind[0].buffer_type=FIELD_TYPE_LONG;
@@ -1272,7 +1611,7 @@ void test_long_data()
   /* Non string or binary type, error */
   bind[1].buffer_type=FIELD_TYPE_LONG;
   rc = mysql_bind_param(stmt,bind);
-  fprintf(stdout,"mysql_bind_param() returned %d\n",rc);
+  fprintf(stdout," mysql_bind_param() returned: %d\n",rc);
   mystmt_r(stmt, rc);
 
   bind[1].buffer_type=FIELD_TYPE_STRING;
@@ -1280,36 +1619,37 @@ void test_long_data()
   rc = mysql_bind_param(stmt,bind);
   mystmt(stmt, rc);
 
+  int_data= 999;
   rc = mysql_execute(stmt);
-  fprintf(stdout,"mysql_execute() returned %d\n",rc);
-  assert(rc == MYSQL_NEED_DATA);
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
+  myassert(rc == MYSQL_NEED_DATA);
 
   data = (char *)"Micheal";
 
   /* supply data in pieces */
-  rc = mysql_send_long_data(stmt,1,data,7,1);
+  rc = mysql_send_long_data(stmt,1,data,7,0);
   mystmt(stmt, rc);
 
   /* try to execute mysql_execute() now, it should return
      MYSQL_NEED_DATA as the long data supply is not yet over
   */
   rc = mysql_execute(stmt);
-  fprintf(stdout,"mysql_execute() returned %d\n",rc);
-  assert(rc == MYSQL_NEED_DATA);
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
+  myassert(rc == MYSQL_NEED_DATA);
 
   /* append data again ..*/
 
   /* Indicate end of data */
-  data = (char *)" 'monty' widenius";
+  data = (char *)" 'monty' Widenius";
   rc = mysql_send_long_data(stmt,1,data,17,1);
   mystmt(stmt, rc);
 
-  rc = mysql_send_long_data(stmt,2,"Venu (venu@mysql.com",4,1);
+  rc = mysql_send_long_data(stmt,2,"Venu (venu@mysql.com)",4,1);
   mystmt(stmt, rc);
 
   /* execute */
   rc = mysql_execute(stmt);
-  fprintf(stdout,"mysql_execute() returned %d\n",rc);
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
   mystmt(stmt,rc);
 
   rc = mysql_commit(mysql);
@@ -1323,17 +1663,21 @@ void test_long_data()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert(1 == my_process_result_set(result));
+  myassert(1 == my_process_result_set(result));
   mysql_free_result(result);
+
+  verify_col_data("test_long_data","col1","999");
+  verify_col_data("test_long_data","col2","Micheal 'monty' Widenius");
+  verify_col_data("test_long_data","col3","Venu");
 }
 
 /********************************************************
 * to test long data (string) handling                   *
 *********************************************************/
-void test_long_data_str()
+static void test_long_data_str()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
+  int        rc, i;
   char       data[255];
   long       length;
   MYSQL_RES  *result;
@@ -1360,11 +1704,9 @@ void test_long_data_str()
 
   strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
 
   bind[0].buffer = (gptr)&length;
   bind[0].buffer_type = FIELD_TYPE_LONG;
@@ -1377,28 +1719,24 @@ void test_long_data_str()
 
   length = 10;
   rc = mysql_execute(stmt);
-  fprintf(stdout,"mysql_execute() returned %d\n",rc);
-  assert(rc == MYSQL_NEED_DATA);
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
+  myassert(rc == MYSQL_NEED_DATA);
 
   length = 40;
   sprintf(data,"MySQL AB");
 
   /* supply data in pieces */
-  {
-    int i;
   for(i=0; i < 4; i++)
   {
     rc = mysql_send_long_data(stmt,1,(char *)data,5,0);
     mystmt(stmt, rc);
   }
-
   /* try to execute mysql_execute() now, it should return
      MYSQL_NEED_DATA as the long data supply is not yet over
    */
   rc = mysql_execute(stmt);
-    fprintf(stdout,"mysql_execute() returned %d\n",rc);
-    assert(rc == MYSQL_NEED_DATA);
-  }
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
+  myassert(rc == MYSQL_NEED_DATA); 
 
   /* Indiate end of data supply */
   rc = mysql_send_long_data(stmt,1,0,0,1);
@@ -1406,7 +1744,7 @@ void test_long_data_str()
 
   /* execute */
   rc = mysql_execute(stmt);
-  fprintf(stdout,"mysql_execute() returned %d\n",rc);
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
   mystmt(stmt,rc);
 
   mysql_stmt_close(stmt);
@@ -1422,20 +1760,27 @@ void test_long_data_str()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert(1 == my_process_result_set(result));
+  myassert(1 == my_process_result_set(result));
   mysql_free_result(result);
+
+  sprintf(data,"%d", i*5);
+  verify_col_data("test_long_data_str","LENGTH(longstr)", data);
+  data[0]='\0';
+  while (i--)
+   sprintf(data,"%s%s", data,"MySQL");
+  verify_col_data("test_long_data_str","longstr", data);
 }
 
 
 /********************************************************
 * to test long data (string) handling                   *
 *********************************************************/
-void test_long_data_str1()
+static void test_long_data_str1()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
-  char       *data=(char *)"MySQL AB";
-  int        length;
+  int        rc;
+  char       data[255];
+  int        length, i;
   MYSQL_RES  *result;
   MYSQL_BIND bind[2];
 
@@ -1460,11 +1805,9 @@ void test_long_data_str1()
 
   strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
 
   bind[0].buffer=data;		  /* string data */
   bind[0].is_long_data=1;   /* specify long data suppy during run-time */
@@ -1478,15 +1821,13 @@ void test_long_data_str1()
 
   length = 10;
   rc = mysql_execute(stmt);
-  fprintf(stdout,"mysql_execute() returned %d\n",rc);
-  assert(rc == MYSQL_NEED_DATA);
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
+  myassert(rc == MYSQL_NEED_DATA);
 
-  length = strlen(data);
+  length = sprintf(data,"MySQL AB");
 
   /* supply data in pieces */
-  {
-    int i;
-    for(i=0; i < 2; i++)
+  for(i=0; i < 3; i++)
   {
     rc = mysql_send_long_data(stmt,0,data,length,0);
     mystmt(stmt, rc);
@@ -1498,24 +1839,23 @@ void test_long_data_str1()
      MYSQL_NEED_DATA as the long data supply is not yet over
   */
   rc = mysql_execute(stmt);
-    fprintf(stdout,"mysql_execute() returned %d\n",rc);
-    assert(rc == MYSQL_NEED_DATA);
-  }
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
+  myassert(rc == MYSQL_NEED_DATA);
  
   /* Indiate end of data supply */
   rc = mysql_send_long_data(stmt,1,0,0,1);
   mystmt(stmt, rc);
 
   rc = mysql_execute(stmt);
-  fprintf(stdout,"mysql_execute() returned %d\n",rc);
-  assert(rc == MYSQL_NEED_DATA);
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
+  myassert(rc == MYSQL_NEED_DATA);
 
   rc = mysql_send_long_data(stmt,0,0,0,1);
   mystmt(stmt, rc);
 
   /* execute */
   rc = mysql_execute(stmt);
-  fprintf(stdout,"mysql_execute() returned %d\n",rc);
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
   mystmt(stmt,rc);
 
   mysql_stmt_close(stmt);
@@ -1531,18 +1871,24 @@ void test_long_data_str1()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert(1 == my_process_result_set(result));
+  myassert(1 == my_process_result_set(result));
   mysql_free_result(result);
+
+  sprintf(data,"%d",i*length);
+  verify_col_data("test_long_data_str","length(longstr)",data);
+
+  sprintf(data,"%d",i*2);
+  verify_col_data("test_long_data_str","length(blb)",data);
 }
 
 
 /********************************************************
 * to test long data (binary) handling                   *
 *********************************************************/
-void test_long_data_bin()
+static void test_long_data_bin()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
+  int        rc;
   char       data[255];
   int        length;
   MYSQL_RES  *result;
@@ -1569,11 +1915,9 @@ void test_long_data_bin()
 
   strcpy(query,"INSERT INTO test_long_data_bin VALUES(?,?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
 
   bind[0].buffer = (gptr)&length;
   bind[0].buffer_type = FIELD_TYPE_LONG;
@@ -1586,8 +1930,8 @@ void test_long_data_bin()
 
   length = 10;
   rc = mysql_execute(stmt);
-  fprintf(stdout,"mysql_execute() returned %d\n",rc);
-  assert(rc == MYSQL_NEED_DATA);
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
+  myassert(rc == MYSQL_NEED_DATA);
 
   sprintf(data,"MySQL AB");
 
@@ -1604,8 +1948,8 @@ void test_long_data_bin()
        MYSQL_NEED_DATA as the long data supply is not yet over
     */
     rc = mysql_execute(stmt);
-    fprintf(stdout,"mysql_execute() returned %d\n",rc);
-    assert(rc == MYSQL_NEED_DATA);
+    fprintf(stdout," mysql_execute() returned %d\n",rc);
+    myassert(rc == MYSQL_NEED_DATA);
   }
 
   /* Indiate end of data supply */
@@ -1614,7 +1958,7 @@ void test_long_data_bin()
 
   /* execute */
   rc = mysql_execute(stmt);
-  fprintf(stdout,"mysql_execute() returned %d\n",rc);
+  fprintf(stdout," mysql_execute() returned %d\n",rc);
   mystmt(stmt,rc);
 
   mysql_stmt_close(stmt);
@@ -1630,7 +1974,7 @@ void test_long_data_bin()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert(1 == my_process_result_set(result));
+  myassert(1 == my_process_result_set(result));
   mysql_free_result(result);
 }
 
@@ -1638,10 +1982,10 @@ void test_long_data_bin()
 /********************************************************
 * to test simple delete                                 *
 *********************************************************/
-void test_simple_delete()
+static void test_simple_delete()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
+  int        rc;
   char       szData[30]={0};
   int        nData=1;
   MYSQL_RES  *result;
@@ -1670,7 +2014,7 @@ void test_simple_delete()
   rc = mysql_query(mysql,"INSERT INTO test_simple_delete VALUES(1,'MySQL',100)");
   myquery(rc);
 
-  assert(1 == mysql_affected_rows(mysql));
+  myassert(1 == mysql_affected_rows(mysql));
 
   rc = mysql_commit(mysql);
   myquery(rc);
@@ -1678,11 +2022,9 @@ void test_simple_delete()
   /* insert by prepare */
   strcpy(query,"DELETE FROM test_simple_delete WHERE col1=? AND col2=? AND col3=100");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in delete:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
 
   nData=1;
   strcpy(szData,"MySQL");
@@ -1697,7 +2039,7 @@ void test_simple_delete()
 
   rc = mysql_execute(stmt);
   mystmt(stmt, rc);
-  assert(1 == mysql_affected_rows(mysql));
+  myassert(1 == mysql_affected_rows(mysql));
 
   mysql_stmt_close(stmt);
 
@@ -1713,7 +2055,7 @@ void test_simple_delete()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert(0 == my_process_result_set(result));
+  myassert(0 == my_process_result_set(result));
   mysql_free_result(result);
 }
 
@@ -1722,10 +2064,10 @@ void test_simple_delete()
 /********************************************************
 * to test simple update                                 *
 *********************************************************/
-void test_update()
+static void test_update()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
+  int        rc;
   char       szData[25];
   int        nData=1;
   MYSQL_RES  *result;
@@ -1753,11 +2095,9 @@ void test_update()
 
   strcpy(query,"INSERT INTO test_update(col2,col3) VALUES(?,?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
 
   /* string data */
   bind[0].buffer_type=FIELD_TYPE_STRING;
@@ -1773,16 +2113,14 @@ void test_update()
   rc = mysql_execute(stmt);
   mystmt(stmt, rc);
 
-  assert(1 == mysql_affected_rows(mysql));
+  myassert(1 == mysql_affected_rows(mysql));
   mysql_stmt_close(stmt);
 
   strcpy(query,"UPDATE test_update SET col2=? WHERE col3=?");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in update:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
   nData=100;
 
 
@@ -1797,7 +2135,7 @@ void test_update()
 
   rc = mysql_execute(stmt);
   mystmt(stmt, rc);
-  assert(1 == mysql_affected_rows(mysql));
+  myassert(1 == mysql_affected_rows(mysql));
 
   mysql_stmt_close(stmt);
 
@@ -1813,7 +2151,7 @@ void test_update()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert(1 == my_process_result_set(result));
+  myassert(1 == my_process_result_set(result));
   mysql_free_result(result);
 }
 
@@ -1821,13 +2159,13 @@ void test_update()
 /********************************************************
 * to test simple prepare                                *
 *********************************************************/
-void test_init_prepare()
+static void test_prepare_noparam()
 {
   MYSQL_STMT *stmt;
-  int        param_count, rc;
+  int        rc;
   MYSQL_RES  *result;
 
-  myheader("test_init_prepare");
+  myheader("test_prepare_noparam");
 
   rc = mysql_query(mysql,"DROP TABLE IF EXISTS my_prepare");
   myquery(rc);
@@ -1842,11 +2180,9 @@ void test_init_prepare()
   /* insert by prepare */
   strcpy(query,"INSERT INTO my_prepare VALUES(10,'venu')");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 0);
+  verify_param_count(stmt,0);
 
   rc = mysql_execute(stmt);
   mystmt(stmt, rc);
@@ -1865,7 +2201,7 @@ void test_init_prepare()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert(1 == my_process_result_set(result));
+  myassert(1 == my_process_result_set(result));
   mysql_free_result(result);
 }
 
@@ -1873,12 +2209,12 @@ void test_init_prepare()
 /********************************************************
 * to test simple bind result                            *
 *********************************************************/
-void test_bind_result()
+static void test_bind_result()
 {
   MYSQL_STMT *stmt;
   int        rc;
   const char query[100];
-  int        nData;
+  int        nData, length, length1;
   char       szData[100];
   MYSQL_BIND bind[2];
 
@@ -1903,6 +2239,9 @@ void test_bind_result()
   rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(20,'MySQL')");
   myquery(rc);
 
+  rc = mysql_query(mysql,"INSERT INTO test_bind_result(col2) VALUES('monty')");
+  myquery(rc);
+
   rc = mysql_commit(mysql);
   myquery(rc);
 
@@ -1910,13 +2249,15 @@ void test_bind_result()
 
   bind[0].buffer_type=FIELD_TYPE_LONG;
   bind[0].buffer= (gptr) &nData;	/* integer data */
+  bind[0].length= (long *)&length;
   bind[1].buffer_type=FIELD_TYPE_STRING;
   bind[1].buffer=szData;		/* string data */
   bind[1].buffer_length=sizeof(szData);
+  bind[1].length=(long *)&length1;
 
   strcpy((char *)query , "SELECT * FROM test_bind_result");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
   rc = mysql_bind_result(stmt,bind);
   mystmt(stmt, rc);
@@ -1927,106 +2268,471 @@ void test_bind_result()
   rc = mysql_fetch(stmt);
   mystmt(stmt,rc);
 
-  printf("\n row 1:%d,%s",nData, szData);
-  assert(nData == 10);
-  assert(strcmp(szData,"venu")==0);
+  fprintf(stdout,"\n row 1: %d,%s(%d)",nData, szData, length1);
+  myassert(nData == 10);
+  myassert(strcmp(szData,"venu")==0);
+  myassert(length1 == 4);
+
+  rc = mysql_fetch(stmt);
+  mystmt(stmt,rc);
+
+  fprintf(stdout,"\n row 2: %d,%s(%d)",nData, szData, length1);
+  myassert(nData == 20);
+  myassert(strcmp(szData,"MySQL")==0);
+  myassert(length1 == 5);
 
+  length=99;
   rc = mysql_fetch(stmt);
   mystmt(stmt,rc);
  
-  printf("\n row 2:%d,%s",nData, szData);
-  assert(nData == 20);
-  assert(strcmp(szData,"MySQL")==0);
+  if (length == MYSQL_NULL_DATA)
+    fprintf(stdout,"\n row 3: NULL,%s(%d)", szData, length1);
+  else
+    fprintf(stdout,"\n row 3: %d,%s(%d)", nData, szData, length1);
+  myassert(length == MYSQL_NULL_DATA);
+  myassert(strcmp(szData,"monty")==0);
+  myassert(length1 == 5);
 
   rc = mysql_fetch(stmt);
-  assert(rc == MYSQL_NO_DATA);
+  myassert(rc == MYSQL_NO_DATA);
 
   mysql_stmt_close(stmt);
 }
 
+
 /********************************************************
-* to test simple prepare with all possible types        *
+* to test ext bind result                               *
 *********************************************************/
-void test_prepare_ext()
+static void test_bind_result_ext()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
-  char       *sql;
-  int        nData=1;
-  MYSQL_RES  *result;
-  char       tData=1;
-  short      sData=10;
-  longlong   bData=20;
-  MYSQL_BIND bind_int[6];
-
-  myheader("test_prepare_ext");
+  int        rc;
+  const char query[100];
+  uchar      t_data;
+  short      s_data;
+  int        i_data;
+  longlong   b_data;
+  float      f_data;
+  double     d_data;
+  char       szData[20], bData[20];
+  int        szLength, bLength;
+  MYSQL_BIND bind[8];
 
-  init_bind(bind_int);
+  myheader("test_bind_result_ext");
 
-  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prepare_ext");
+  init_bind(bind);
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_bind_result");
   myquery(rc);
 
   rc = mysql_commit(mysql);
   myquery(rc);
 
-  sql = (char *)"CREATE TABLE test_prepare_ext\
-			(\
-			c1  tinyint,\
-			c2  smallint,\
-			c3  mediumint,\
-			c4  int,\
-			c5  integer,\
-			c6  bigint,\
-			c7  float,\
-			c8  double,\
-			c9  double precision,\
-			c10 real,\
-			c11 decimal(7,4),\
-      c12 numeric(8,4),\
-			c13 date,\
-			c14 datetime,\
-			c15 timestamp(14),\
-			c16 time,\
-			c17 year,\
-			c18 bit,\
-      c19 bool,\
-			c20 char,\
-			c21 char(10),\
-			c22 varchar(30),\
-			c23 tinyblob,\
-			c24 tinytext,\
-			c25 blob,\
-			c26 text,\
-			c27 mediumblob,\
-			c28 mediumtext,\
-			c29 longblob,\
-			c30 longtext,\
-			c31 enum('one','two','three'),\
-			c32 set('monday','tuesday','wednesday'))";
+  rc = mysql_query(mysql,"CREATE TABLE test_bind_result(c1 tinyint, c2 smallint, \
+                                                        c3 int, c4 bigint, \
+                                                        c5 float, c6 double, \
+                                                        c7 varbinary(10), \
+                                                        c8 varchar(50))");
+  myquery(rc);
 
-  rc = mysql_query(mysql,sql);
+  rc = mysql_commit(mysql);
   myquery(rc);
 
-  /* insert by prepare - all integers */
-  strcpy(query,(char *)"INSERT INTO test_prepare_ext(c1,c2,c3,c4,c5,c6) VALUES(?,?,?,?,?,?)");
-  stmt = mysql_prepare(mysql,query, strlen(query));
+  rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(19,2999,3999,4999999,\
+                                                              2345.6,5678.89563,\
+                                                              'venu','mysql')");
   myquery(rc);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 6);
+  rc = mysql_commit(mysql);
+  myquery(rc);
 
-  /*tinyint*/
-  bind_int[0].buffer_type=FIELD_TYPE_TINY;
-  bind_int[0].buffer= (void *)&tData;
+  bind[0].buffer_type=MYSQL_TYPE_TINY;
+  bind[0].buffer=(gptr)&t_data;
 
-  /*smallint*/
-  bind_int[1].buffer_type=FIELD_TYPE_SHORT;
-  bind_int[1].buffer= (void *)&sData;
+  bind[1].buffer_type=MYSQL_TYPE_SHORT;
+  bind[2].buffer_type=MYSQL_TYPE_LONG;
   
-  /*mediumint*/
-  bind_int[2].buffer_type=FIELD_TYPE_LONG;
-  bind_int[2].buffer= (void *)&nData;
+  bind[3].buffer_type=MYSQL_TYPE_LONGLONG;
+  bind[1].buffer=(gptr)&s_data;
+  
+  bind[2].buffer=(gptr)&i_data;
+  bind[3].buffer=(gptr)&b_data;
+
+  bind[4].buffer_type=MYSQL_TYPE_FLOAT;
+  bind[4].buffer=(gptr)&f_data;
+
+  bind[5].buffer_type=MYSQL_TYPE_DOUBLE;
+  bind[5].buffer=(gptr)&d_data;
+
+  bind[6].buffer_type=MYSQL_TYPE_STRING;
+  bind[6].buffer=(gptr)&szData;
+  bind[6].length=(long *)&szLength;
+
+  bind[7].buffer_type=MYSQL_TYPE_TINY_BLOB;
+  bind[7].buffer=(gptr)&bData;
+  bind[7].length=(long *)&bLength;
+
+  strcpy((char *)query , "SELECT * FROM test_bind_result");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  rc = mysql_bind_result(stmt,bind);
+  mystmt(stmt, rc);
+
+  rc = mysql_execute(stmt);
+  mystmt(stmt, rc);
+
+  rc = mysql_fetch(stmt);
+  mystmt(stmt,rc);
+
+  fprintf(stdout, "\n data (tiny)   : %d", t_data);
+  fprintf(stdout, "\n data (short)  : %d", s_data);
+  fprintf(stdout, "\n data (int)    : %d", i_data);
+  fprintf(stdout, "\n data (big)    : %lld", b_data);
+
+  fprintf(stdout, "\n data (float)  : %f", f_data);
+  fprintf(stdout, "\n data (double) : %f", d_data);
+
+  fprintf(stdout, "\n data (str)    : %s(%d)", szData, szLength);
+  fprintf(stdout, "\n data (bin)    : %s(%d)", bData, bLength);
+
+
+  myassert(t_data == 19);
+  myassert(s_data == 2999);
+  myassert(i_data == 3999);
+  myassert(b_data == 4999999);
+  /*myassert(f_data == 2345.60);*/
+  /*myassert(d_data == 5678.89563);*/
+  myassert(strcmp(szData,"venu")==0);
+  myassert(strcmp(bData,"mysql")==0);
+  myassert(szLength == 4);
+  myassert(bLength == 5);
+
+  rc = mysql_fetch(stmt);
+  myassert(rc == MYSQL_NO_DATA);
+
+  mysql_stmt_close(stmt);
+}
+
+
+/********************************************************
+* to test ext bind result                               *
+*********************************************************/
+static void test_bind_result_ext1()
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  const char query[100];
+  char       t_data[20];
+  float      s_data;
+  short      i_data;
+  short      b_data;
+  int        f_data;
+  long       bData;
+  long       length[11];
+  char       d_data[20];
+  double     szData;
+  MYSQL_BIND bind[8];
+
+  myheader("test_bind_result_ext1");
+
+  init_bind(bind);
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_bind_result");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"CREATE TABLE test_bind_result(c1 tinyint, c2 smallint, \
+                                                        c3 int, c4 bigint, \
+                                                        c5 float, c6 double, \
+                                                        c7 varbinary(10), \
+                                                        c8 varchar(10))");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(120,2999,3999,54,\
+                                                              2.6,58.89,\
+                                                              '206','6.7')");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  bind[0].buffer_type=MYSQL_TYPE_STRING;
+  bind[0].buffer=(gptr)t_data;
+
+  for (rc=0; rc <= 7; rc++)
+    bind[rc].length= &length[rc];
+
+  bind[1].buffer_type=MYSQL_TYPE_FLOAT;
+  bind[1].buffer=(gptr)&s_data;
+
+  bind[2].buffer_type=MYSQL_TYPE_SHORT;
+  bind[2].buffer=(gptr)&i_data;
+
+  bind[3].buffer_type=MYSQL_TYPE_TINY;
+  bind[3].buffer=(gptr)&b_data;
+
+  bind[4].buffer_type=MYSQL_TYPE_LONG;
+  bind[4].buffer=(gptr)&f_data;
+
+  bind[5].buffer_type=MYSQL_TYPE_STRING;
+  bind[5].buffer=(gptr)d_data;
+
+  bind[6].buffer_type=MYSQL_TYPE_LONG;
+  bind[6].buffer=(gptr)&bData;
+
+  bind[7].buffer_type=MYSQL_TYPE_DOUBLE;
+  bind[7].buffer=(gptr)&szData;
+
+  strcpy((char *)query , "SELECT * FROM test_bind_result");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  rc = mysql_bind_result(stmt,bind);
+  mystmt(stmt, rc);
+
+  rc = mysql_execute(stmt);
+  mystmt(stmt, rc);
+
+  rc = mysql_fetch(stmt);
+  mystmt(stmt,rc);
+
+  fprintf(stdout, "\n data (tiny)   : %s(%ld)", t_data, length[0]);
+  fprintf(stdout, "\n data (short)  : %f(%ld)", s_data, length[1]);
+  fprintf(stdout, "\n data (int)    : %d(%ld)", i_data, length[2]);
+  fprintf(stdout, "\n data (big)    : %d(%ld)", b_data, length[3]);
+
+  fprintf(stdout, "\n data (float)  : %d(%ld)", f_data, length[4]);
+  fprintf(stdout, "\n data (double) : %s(%ld)", d_data, length[5]);
+
+  fprintf(stdout, "\n data (bin)    : %ld(%ld)", bData, length[6]);
+  fprintf(stdout, "\n data (str)    : %g(%ld)", szData, length[7]);
+
+  myassert(strcmp(t_data,"120")==0);
+  myassert(i_data == 3999);
+  myassert(f_data == 2);
+  myassert(strcmp(d_data,"58.89")==0);
+
+  myassert(length[0] == 3);
+  myassert(length[1] == 4);
+  myassert(length[2] == 2);
+  myassert(length[3] == 1);
+  myassert(length[4] == 4);
+  myassert(length[5] == 5);
+  myassert(length[6] == 4);
+  myassert(length[7] == 8);
+
+  rc = mysql_fetch(stmt);
+  myassert(rc == MYSQL_NO_DATA);
+
+  mysql_stmt_close(stmt);
+}
+
+/********************************************************
+* to test fetching of date, time and ts                 *
+*********************************************************/
+static void test_fetch_date()
+{
+  MYSQL_STMT *stmt;
+  int        rc, year;
+  char       date[25], time[25], ts[25], ts_4[15], ts_6[20], dt[20];
+  int        d_length, t_length, ts_length, ts4_length, ts6_length, 
+             dt_length, y_length;
+
+  MYSQL_BIND bind[3];
+
+  myheader("test_fetch_date");
+
+  init_bind(bind);
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_bind_result");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"CREATE TABLE test_bind_result(c1 date, c2 time, \
+                                                        c3 timestamp(14), \
+                                                        c4 year, \
+                                                        c5 datetime, \
+                                                        c6 timestamp(4), \
+                                                        c7 timestamp(6))");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES('2002-01-02',\
+                                                              '12:49:00',\
+                                                              '2002-01-02 17:46:59', \
+                                                              2010,\
+                                                              '2010-07-10', \
+                                                              '2020','1999-12-29')");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  bind[0].buffer_type=MYSQL_TYPE_STRING;
+  bind[1]=bind[2]=bind[0];
+
+  bind[0].buffer=(gptr)&date;
+  bind[0].length=(long *)&d_length;
+
+  bind[1].buffer=(gptr)&time;
+  bind[1].length=(long *)&t_length;
+
+  bind[2].buffer=(gptr)&ts;
+  bind[2].length=(long *)&ts_length;
+
+  bind[3].buffer_type=MYSQL_TYPE_LONG;
+  bind[3].buffer=(gptr)&year;
+  bind[3].length=(long *)&y_length;
+
+  bind[4].buffer_type=MYSQL_TYPE_STRING;
+  bind[4].buffer=(gptr)&dt;
+  bind[4].length=(long *)&dt_length;
+
+  bind[5].buffer_type=MYSQL_TYPE_STRING;
+  bind[5].buffer=(gptr)&ts_4;
+  bind[5].length=(long *)&ts4_length;
+
+  bind[6].buffer_type=MYSQL_TYPE_STRING;
+  bind[6].buffer=(gptr)&ts_6;
+  bind[6].length=(long *)&ts6_length;
+
+  stmt = mysql_prepare(mysql, "SELECT * FROM test_bind_result", 50);
+  mystmt_init(stmt);
+
+  rc = mysql_bind_result(stmt,bind);
+  mystmt(stmt, rc);
+
+  rc = mysql_execute(stmt);
+  mystmt(stmt, rc);
+
+  ts_4[0]='\0';
+  rc = mysql_fetch(stmt);
+  mystmt(stmt,rc);
+
+  fprintf(stdout, "\n date   : %s(%d)", date, d_length);
+  fprintf(stdout, "\n time   : %s(%d)", time, t_length);
+  fprintf(stdout, "\n ts     : %s(%d)", ts, ts_length);
+  fprintf(stdout, "\n year   : %d(%d)", year, y_length);
+  fprintf(stdout, "\n dt     : %s(%d)", dt,  dt_length);
+  fprintf(stdout, "\n ts(4)  : %s(%d)", ts_4, ts4_length);
+  fprintf(stdout, "\n ts(6)  : %s(%d)", ts_6, ts6_length);
+
+  myassert(strcmp(date,"2002-01-02")==0);
+  myassert(d_length == 10);
+
+  myassert(strcmp(time,"12:49:00")==0);
+  myassert(d_length == 8);
+
+  myassert(strcmp(ts,"2002-01-02 17:46:59")==0);
+  myassert(ts_length == 19);
+
+  myassert(year == 2010);
+  myassert(y_length == 4);
+  
+  myassert(strcmp(dt,"2010-07-10")==0);
+  myassert(dt_length == 10);
+
+  myassert(ts_4[0] == '\0');
+  myassert(ts4_length == 0);
+
+  myassert(strcmp(ts_6,"1999-12-29")==0);
+  myassert(ts6_length == 10);
+
+  rc = mysql_fetch(stmt);
+  myassert(rc == MYSQL_NO_DATA);
+
+  mysql_stmt_close(stmt);
+}
+
+
+/********************************************************
+* to test simple prepare with all possible types        *
+*********************************************************/
+static void test_prepare_ext()
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       *sql;
+  int        nData=1;
+  MYSQL_RES  *result;
+  char       tData=1;
+  short      sData=10;
+  longlong   bData=20;
+  MYSQL_BIND bind_int[6];
+
+  myheader("test_prepare_ext");
+
+  init_bind(bind_int);
+
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prepare_ext");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  sql = (char *)"CREATE TABLE test_prepare_ext\
+			(\
+			c1  tinyint,\
+			c2  smallint,\
+			c3  mediumint,\
+			c4  int,\
+			c5  integer,\
+			c6  bigint,\
+			c7  float,\
+			c8  double,\
+			c9  double precision,\
+			c10 real,\
+			c11 decimal(7,4),\
+      c12 numeric(8,4),\
+			c13 date,\
+			c14 datetime,\
+			c15 timestamp(14),\
+			c16 time,\
+			c17 year,\
+			c18 bit,\
+      c19 bool,\
+			c20 char,\
+			c21 char(10),\
+			c22 varchar(30),\
+			c23 tinyblob,\
+			c24 tinytext,\
+			c25 blob,\
+			c26 text,\
+			c27 mediumblob,\
+			c28 mediumtext,\
+			c29 longblob,\
+			c30 longtext,\
+			c31 enum('one','two','three'),\
+			c32 set('monday','tuesday','wednesday'))";
+
+  rc = mysql_query(mysql,sql);
+  myquery(rc);
+
+  /* insert by prepare - all integers */
+  strcpy(query,(char *)"INSERT INTO test_prepare_ext(c1,c2,c3,c4,c5,c6) VALUES(?,?,?,?,?,?)");
+  stmt = mysql_prepare(mysql,query, strlen(query));
+  myquery(rc);
+
+  verify_param_count(stmt,6);
+
+  /*tinyint*/
+  bind_int[0].buffer_type=FIELD_TYPE_TINY;
+  bind_int[0].buffer= (void *)&tData;
+
+  /*smallint*/
+  bind_int[1].buffer_type=FIELD_TYPE_SHORT;
+  bind_int[1].buffer= (void *)&sData;
+
+  /*mediumint*/
+  bind_int[2].buffer_type=FIELD_TYPE_LONG;
+  bind_int[2].buffer= (void *)&nData;
 
   /*int*/
   bind_int[3].buffer_type=FIELD_TYPE_LONG;
@@ -2065,7 +2771,7 @@ void test_prepare_ext()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert(nData == my_process_result_set(result));
+  myassert(nData == my_process_result_set(result));
   mysql_free_result(result);
 }
 
@@ -2075,14 +2781,14 @@ void test_prepare_ext()
 /********************************************************
 * to test real and alias names                          *
 *********************************************************/
-void test_field_names()
+static void test_field_names()
 {
   int        rc;
   MYSQL_RES  *result;
 
   myheader("test_field_names");
 
-  printf("\n%d,%d,%d",MYSQL_TYPE_DECIMAL,MYSQL_TYPE_NEWDATE,MYSQL_TYPE_ENUM);
+  fprintf(stdout,"\n %d,%d,%d",MYSQL_TYPE_DECIMAL,MYSQL_TYPE_NEWDATE,MYSQL_TYPE_ENUM);
   rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_field_names1");
   myquery(rc);
 
@@ -2108,7 +2814,7 @@ void test_field_names()
   result = mysql_use_result(mysql);
   mytest(result);
 
-  assert(0 == my_process_result_set(result));
+  myassert(0 == my_process_result_set(result));
   mysql_free_result(result);
 
   /* with table name included with true column name */
@@ -2118,23 +2824,20 @@ void test_field_names()
   result = mysql_use_result(mysql);
   mytest(result);
 
-  assert(0 == my_process_result_set(result));
+  myassert(0 == my_process_result_set(result));
   mysql_free_result(result);
 }
 
 /********************************************************
 * to test warnings                                      *
 *********************************************************/
-void test_warnings()
+static void test_warnings()
 {
   int        rc;
   MYSQL_RES  *result;
 
   myheader("test_warnings");
 
-  rc = mysql_query(mysql,"USE test");
-  myquery(rc);
-
   rc = mysql_query(mysql,"SHOW WARNINGS");
   myquery(rc);
 
@@ -2148,7 +2851,7 @@ void test_warnings()
 /********************************************************
 * to test errors                                        *
 *********************************************************/
-void test_errors()
+static void test_errors()
 {
   int        rc;
   MYSQL_RES  *result;
@@ -2170,10 +2873,10 @@ void test_errors()
 /********************************************************
 * to test simple prepare-insert                         *
 *********************************************************/
-void test_insert()
+static void test_insert()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count, length;
+  int        rc, length;
   char       query[200];
   char       str_data[50];
   char       tiny_data;
@@ -2199,11 +2902,9 @@ void test_insert()
   bzero(bind, sizeof(bind));
   strcpy(query,"INSERT INTO test_prep_insert VALUES(?,?)");
   stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,2);
 
   /* tinyint */
   bind[0].buffer_type=FIELD_TYPE_TINY;
@@ -2238,7 +2939,7 @@ void test_insert()
   result = mysql_store_result(mysql);
   mytest(result);
 
-  assert((int)tiny_data == my_process_result_set(result));
+  myassert((int)tiny_data == my_process_result_set(result));
   mysql_free_result(result);
 
 }
@@ -2246,10 +2947,10 @@ void test_insert()
 /********************************************************
 * to test simple prepare-resultset info                 *
 *********************************************************/
-void test_prepare_resultset()
+static void test_prepare_resultset()
 {
   MYSQL_STMT *stmt;
-  int        rc,param_count;
+  int        rc;
   char       query[200];
   MYSQL_RES  *result;
 
@@ -2268,38 +2969,15 @@ void test_prepare_resultset()
                                 name varchar(50),extra double)");
   myquery(rc);
 
-  /* insert by prepare */
-  strcpy(query,"INSERT INTO test_prepare_resultset(id,name) VALUES(?,?)");
-  stmt = mysql_prepare(mysql, query, strlen(query));
-  myxquery(stmt);
+  strcpy(query,"SELECT * FROM test_prepare_resultset");
+  stmt = PREPARE(mysql, query);
+  mystmt_init(stmt);
 
-  param_count = mysql_param_count(stmt);
-  fprintf(stdout," total parameters in insert:%d\n", param_count);
-  assert(param_count == 2);
+  verify_param_count(stmt,0);
 
-  rc = mysql_query(mysql,"SELECT * FROM test_prepare_resultset");
-  myquery(rc);
-
-  /* get the prepared-result */
   result = mysql_prepare_result(stmt);
-  assert( result != 0);
-
-  my_print_result_metadata(result);
-  mysql_free_result(result);
-
-  result = mysql_store_result(mysql);
   mytest(result);
-
-  assert(0 == my_process_result_set(result));
-  mysql_free_result(result);
-
-  /* get the prepared-result */
-  result = mysql_prepare_result(stmt);
-  assert( result != 0);
-
   my_print_result_metadata(result);
-  mysql_free_result(result);
-
   mysql_stmt_close(stmt);
 }
 
@@ -2307,7 +2985,7 @@ void test_prepare_resultset()
 * to test field flags (verify .NET provider)            *
 *********************************************************/
 
-void test_field_flags()
+static void test_field_flags()
 {
   int          rc;
   MYSQL_RES    *result;
@@ -2348,19 +3026,456 @@ void test_field_flags()
   for(i=0; i< mysql_num_fields(result); i++)
   {
     field = mysql_fetch_field(result);
-    printf("\nfield:%d",i);
+    fprintf(stdout,"\n field:%d",i);
     if(field->flags & NOT_NULL_FLAG)
-      printf("\n  NOT_NULL_FLAG");
+      fprintf(stdout,"\n  NOT_NULL_FLAG");
     if(field->flags & PRI_KEY_FLAG)
-      printf("\n  PRI_KEY_FLAG");
+      fprintf(stdout,"\n  PRI_KEY_FLAG");
     if(field->flags & UNIQUE_KEY_FLAG)
-      printf("\n  UNIQUE_KEY_FLAG");
+      fprintf(stdout,"\n  UNIQUE_KEY_FLAG");
     if(field->flags & MULTIPLE_KEY_FLAG)
-      printf("\n  MULTIPLE_KEY_FLAG");
+      fprintf(stdout,"\n  MULTIPLE_KEY_FLAG");
     if(field->flags & AUTO_INCREMENT_FLAG)
-      printf("\n  AUTO_INCREMENT_FLAG");
+      fprintf(stdout,"\n  AUTO_INCREMENT_FLAG");
+
+  }
+  mysql_free_result(result);
+}
 
+/**************************************************************
+ * Test mysql_stmt_close for open stmts                       *
+**************************************************************/
+static void test_stmt_close()
+{
+  MYSQL *lmysql;
+  MYSQL_STMT *stmt1, *stmt2, *stmt3, *stmt_x;
+  MYSQL_BIND  param[1];
+  MYSQL_RES   *result;
+  char  query[100];
+  unsigned int  count;
+  int   rc;
+  
+  myheader("test_stmt_close");  
+
+  init_bind(param);
+  if(!(lmysql = mysql_init(NULL)))
+  { 
+	  myerror("mysql_init() failed");
+    exit(0);
   }
+  if (!(mysql_real_connect(lmysql,opt_host,opt_user,
+			   opt_password, opt_db ? opt_db:"inter_client_test_db", opt_port,
+			   opt_unix_socket, 0)))
+  {
+    myerror("connection failed");
+    exit(0);
+  }   
+  if (opt_db)
+    strcpy(current_db,opt_db);
+
+  /* set AUTOCOMMIT to ON*/
+  mysql_autocommit(lmysql, true);
+  mysql_query(lmysql,"DROP TABLE IF EXISTS test_stmt_close");
+  mysql_query(lmysql,"CREATE TABLE test_stmt_close(id int)");
+
+  strcpy(query,"ALTER TABLE test_stmt_close ADD name varchar(20)");
+  stmt1= PREPARE(lmysql, query);
+  mystmt_init(stmt1);
+  count= mysql_param_count(stmt1);
+  fprintf(stdout,"\n total params in alter: %d", count);
+  myassert(count == 0);
+  strcpy(query,"INSERT INTO test_stmt_close(id) VALUES(?)");
+  stmt_x= PREPARE(mysql, query);
+  mystmt_init(stmt_x);
+  count= mysql_param_count(stmt_x);
+  fprintf(stdout,"\n total params in insert: %d", count);
+  myassert(count == 1);
+  strcpy(query,"UPDATE test_stmt_close SET id=? WHERE id=?");
+  stmt3= PREPARE(lmysql, query);
+  mystmt_init(stmt3);
+  count= mysql_param_count(stmt3);
+  fprintf(stdout,"\n total params in update: %d", count);
+  myassert(count == 2);
+  strcpy(query,"SELECT * FROM test_stmt_close WHERE id=?");
+  stmt2= PREPARE(lmysql, query);
+  mystmt_init(stmt2);
+  count= mysql_param_count(stmt2);
+  fprintf(stdout,"\n total params in select: %d", count);
+  myassert(count == 1);
+
+  rc= mysql_stmt_close(stmt1);
+  fprintf(stdout,"\n mysql_close_stmt(1) returned: %d", rc);
+  myassert(rc == 0);
+  mysql_close(lmysql); /* it should free all stmts */
+#if NOT_VALID 
+  rc= mysql_stmt_close(stmt3);
+  fprintf(stdout,"\n mysql_close_stmt(3) returned: %d", rc);
+  myassert( rc == 1);
+  rc= mysql_stmt_close(stmt2);
+  fprintf(stdout,"\n mysql_close_stmt(2) returned: %d", rc);
+  myassert( rc == 1);
+#endif
+
+  count= 100;
+  param[0].buffer=(gptr)&count;
+  param[0].buffer_type=MYSQL_TYPE_LONG;
+  rc = mysql_bind_param(stmt_x, param);
+  mystmt(stmt_x, rc);
+  rc = mysql_execute(stmt_x);
+  mystmt(stmt_x, rc);
+
+  rc= (ulong)mysql_affected_rows(stmt_x->mysql);
+  fprintf(stdout,"\n total rows affected: %d", rc);
+  myassert (rc == 1);
+
+  rc= mysql_stmt_close(stmt_x);
+  fprintf(stdout,"\n mysql_close_stmt(x) returned: %d", rc);
+  myassert( rc == 0);
+
+  /*verify_col_data("test_stmt_close", "id", "100");*/
+  rc = mysql_query(mysql,"SELECT id FROM test_stmt_close");
+  myquery(rc);
+
+  result = mysql_store_result(mysql);
+  mytest(result);
+
+  myassert(1 == my_process_result_set(result));
+  mysql_free_result(result);
+}
+
+/********************************************************
+ * To test simple set-variable prepare                   *
+*********************************************************/
+static void test_set_variable()
+{
+  MYSQL_STMT *stmt;
+  int        rc, select_limit=88;
+  char       query[200];
+  MYSQL_BIND bind[1];
+  MYSQL_RES  *result;
+
+
+  myheader("test_set_variable");
+
+  rc = mysql_autocommit(mysql, true);
+  myquery(rc);
+
+  strcpy(query,"SET GLOBAL delayed_insert_limit=?");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,1);
+
+  result= mysql_param_result(stmt);
+  mytest_r(result);
+
+  init_bind(bind);
+
+  bind[0].buffer_type= MYSQL_TYPE_LONG;
+  bind[0].buffer=(gptr)&select_limit;
+
+  rc = mysql_bind_param(stmt, bind);
+  mystmt(stmt,rc);
+
+  rc= mysql_execute(stmt);
+  mystmt(stmt,rc);
+
+  mysql_store_result(mysql);
+
+  strcpy(query,"show variables like 'delayed_insert_limit'");
+  rc = mysql_query(mysql,query);
+  myquery(rc);
+
+  verify_col_data(NullS, NullS, "88");
+
+#if TO_BE_FIXED
+
+  select_limit= 100;/* reset to default */
+  rc= mysql_execute(stmt);
+  mystmt(stmt,rc);
+
+  mysql_store_result(mysql);
+  mysql_stmt_close(stmt);
+
+  rc = mysql_query(mysql,query);
+  myquery(rc);
+  
+  verify_col_data(NullS, NullS, "100");
+#endif
+  mysql_stmt_close(stmt);
+}
+#if NOT_USED
+/* Insert meta info .. */
+static void test_insert_meta()
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       query[200];
+  MYSQL_RES  *result;
+  MYSQL_FIELD *field;
+
+  myheader("test_insert_meta");
+
+  rc = mysql_autocommit(mysql, true);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prep_insert");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"CREATE TABLE test_prep_insert(col1 tinyint,\
+                                col2 varchar(50), col3 varchar(30))");
+  myquery(rc);
+
+  strcpy(query,"INSERT INTO test_prep_insert VALUES(10,'venu1','test')");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,0);
+
+  result= mysql_param_result(stmt);
+  mytest_r(result);
+
+  strcpy(query,"INSERT INTO test_prep_insert VALUES(?,'venu',?)");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,2);
+
+  result= mysql_param_result(stmt);
+  mytest(result);
+
+  my_print_result_metadata(result);
+
+  mysql_field_seek(result, 0);
+  field= mysql_fetch_field(result);
+  mytest(field);
+  fprintf(stdout, "\n obtained: `%s` (expected: `%s`)", field->name, "col1");
+  myassert(strcmp(field->name,"col1")==0);
+
+  field= mysql_fetch_field(result);
+  mytest(field);
+  fprintf(stdout, "\n obtained: `%s` (expected: `%s`)", field->name, "col3");
+  myassert(strcmp(field->name,"col3")==0);
+
+  field= mysql_fetch_field(result);
+  mytest_r(field);
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+}
+
+/* Update meta info .. */
+static void test_update_meta()
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       query[200];
+  MYSQL_RES  *result;
+  MYSQL_FIELD *field;
+
+  myheader("test_update_meta");
+
+  rc = mysql_autocommit(mysql, true);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prep_update");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"CREATE TABLE test_prep_update(col1 tinyint,\
+                                col2 varchar(50), col3 varchar(30))");
+  myquery(rc);
+
+  strcpy(query,"UPDATE test_prep_update SET col1=10, col2='venu1' WHERE col3='test'");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,0);
+
+  result= mysql_param_result(stmt);
+  mytest_r(result);
+
+  strcpy(query,"UPDATE test_prep_update SET col1=?, col2='venu' WHERE col3=?");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,2);
+
+  result= mysql_param_result(stmt);
+  mytest(result);
+
+  my_print_result_metadata(result);
+
+  mysql_field_seek(result, 0);
+  field= mysql_fetch_field(result);
+  mytest(field);
+  fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col1");
+  fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_update");
+  myassert(strcmp(field->name,"col1")==0);
+  myassert(strcmp(field->table,"test_prep_update")==0);
+
+  field= mysql_fetch_field(result);
+  mytest(field);
+  fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col3");
+  fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_update");
+  myassert(strcmp(field->name,"col3")==0);
+  myassert(strcmp(field->table,"test_prep_update")==0);
+
+  field= mysql_fetch_field(result);
+  mytest_r(field);
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+}
+
+/* Select meta info .. */
+static void test_select_meta()
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       query[200];
+  MYSQL_RES  *result;
+  MYSQL_FIELD *field;
+
+  myheader("test_select_meta");
+
+  rc = mysql_autocommit(mysql, true);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prep_select");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"CREATE TABLE test_prep_select(col1 tinyint,\
+                                col2 varchar(50), col3 varchar(30))");
+  myquery(rc);
+
+  strcpy(query,"SELECT * FROM test_prep_select WHERE col1=10");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,0);
+
+  result= mysql_param_result(stmt);
+  mytest_r(result);
+
+  strcpy(query,"SELECT col1, col3 from test_prep_select WHERE col1=? AND col3='test' AND col2= ?");
+  stmt = mysql_prepare(mysql, query, strlen(query));
+  mystmt_init(stmt);
+
+  verify_param_count(stmt,2);
+
+  result= mysql_param_result(stmt);
+  mytest(result);
+
+  my_print_result_metadata(result);
+
+  mysql_field_seek(result, 0);
+  field= mysql_fetch_field(result);
+  mytest(field);
+  fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col1");
+  fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_select");
+  myassert(strcmp(field->name,"col1")==0);
+  myassert(strcmp(field->table,"test_prep_select")==0);
+
+  field= mysql_fetch_field(result);
+  mytest(field);
+  fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col2");
+  fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_select");
+  myassert(strcmp(field->name,"col2")==0);
+  myassert(strcmp(field->table,"test_prep_select")==0);
+
+  field= mysql_fetch_field(result);
+  mytest_r(field);
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+}
+#endif
+
+/* Test FUNCTION field info / DATE_FORMAT() table_name . */
+static void test_func_fields()
+{
+  int        rc;
+  MYSQL_RES  *result;
+  MYSQL_FIELD *field;
+
+  myheader("test_func_fields");
+
+  rc = mysql_autocommit(mysql, true);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_dateformat");
+  myquery(rc);
+
+  rc = mysql_commit(mysql);
+  myquery(rc);
+
+  rc = mysql_query(mysql,"CREATE TABLE test_dateformat(id int, \
+                                                       ts timestamp)");
+  myquery(rc);
+
+  rc = mysql_query(mysql, "INSERT INTO test_dateformat(id) values(10)");
+  myquery(rc);
+
+  rc = mysql_query(mysql, "SELECT ts FROM test_dateformat");
+  myquery(rc);
+
+  result = mysql_store_result(mysql);
+  mytest(result);
+
+  field = mysql_fetch_field(result);
+  mytest(field);
+  fprintf(stdout,"\n table name: `%s` (expected: `%s`)", field->table,
+                  "test_dateformat");
+  myassert(strcmp(field->table, "test_dateformat")==0);
+
+  field = mysql_fetch_field(result);
+  mytest_r(field); /* no more fields */
+
+  mysql_free_result(result);
+
+  /* DATE_FORMAT */
+  rc = mysql_query(mysql, "SELECT DATE_FORMAT(ts,'%Y') AS 'venu' FROM test_dateformat");
+  myquery(rc);
+
+  result = mysql_store_result(mysql);
+  mytest(result);
+
+  field = mysql_fetch_field(result);
+  mytest(field);
+  fprintf(stdout,"\n table name: `%s` (expected: `%s`)", field->table, "");
+  myassert(field->table[0] == '\0');
+
+  field = mysql_fetch_field(result);
+  mytest_r(field); /* no more fields */
+
+  mysql_free_result(result);
+
+  /* FIELD ALIAS TEST */
+  rc = mysql_query(mysql, "SELECT DATE_FORMAT(ts,'%Y')  AS 'YEAR' FROM test_dateformat");
+  myquery(rc);
+
+  result = mysql_store_result(mysql);
+  mytest(result);
+
+  field = mysql_fetch_field(result);
+  mytest(field);
+  fprintf(stdout,"\n field name: `%s` (expected: `%s`)", field->name, "YEAR");
+  fprintf(stdout,"\n field org name: `%s` (expected: `%s`)",field->org_name,"");
+  myassert(strcmp(field->name, "YEAR")==0);
+  myassert(field->org_name[0] == '\0');
+
+  field = mysql_fetch_field(result);
+  mytest_r(field); /* no more fields */
+
   mysql_free_result(result);
 }
 
@@ -2398,24 +3513,24 @@ static void usage(void)
   puts("and you are welcome to modify and redistribute it under the GPL license\n");
   puts("                 Copyright (C) 1995-2002 MySQL AB ");
   puts("-----------------------------------------------------------------------\n");
-  printf("usage: %s [OPTIONS]\n\n", my_progname);  
-  printf("\
+  fprintf(stdout,"usage: %s [OPTIONS]\n\n", my_progname);  
+  fprintf(stdout,"\
   -?, --help		Display this help message and exit.\n\
   -D  --database=...    Database name to be used for test.\n\
   -h, --host=...	Connect to host.\n\
   -p, --password[=...]	Password to use when connecting to server.\n");
 #ifdef __WIN__
-  printf("\
+  fprintf(stdout,"\
   -W, --pipe	        Use named pipes to connect to server.\n");
 #endif
-  printf("\
+  fprintf(stdout,"\
   -P, --port=...	Port number to use for connection.\n\
   -S, --socket=...	Socket file to use for connection.\n");
 #ifndef DONT_ALLOW_USER_CHANGE
-  printf("\
+  fprintf(stdout,"\
   -u, --user=#		User for login if not current user.\n");
 #endif  
-  printf("*********************************************************************\n");
+  fprintf(stdout,"*********************************************************************\n");
 }
 
 static my_bool
@@ -2472,23 +3587,51 @@ int main(int argc, char **argv)
   get_options(argc,argv);
     
   client_connect();       /* connect to server */ 
-  
+  test_select_prepare();
+  test_prepare();
+  test_prepare_simple();
+  test_bind_result();     /* result bind test */  
+  test_fetch_null();      /* to fetch null data */
+  test_fetch_date();
+  test_bind_result_ext(); /* result bind test - extension */
+  test_bind_result_ext1(); /* result bind test - extension */
+  test_select_direct();  /* direct select - protocol_simple debug */
+  test_select_prepare();  /* prepare select - protocol_prep debug */
+  test_select_direct();  /* direct select - protocol_simple debug */
+  test_select();
+  test_select_version();
+  test_set_variable();  /* set variable prepare */
+#if NOT_USED
+  test_select_meta();   /* select param meta information */
+  test_update_meta();   /* update param meta information */  
+  test_insert_meta();   /* insert param meta information */
+#endif
+  test_simple_update(); /* simple update test */
+  test_func_fields();
+  test_long_data();
+  test_insert();
+  test_set_variable();
+  test_tran_innodb();
+  test_select_version();
+  test_select_simple();
+  test_debug_example();
+  test_select();
+  test_select_show();
   test_null();          /* test null data handling */
   test_simple_update();  
-  //test_select_simple();
-  //test_prepare_resultset();
-  //test_select();        /* simple prepare-select */
+  test_prepare_resultset();
+  test_prepare_noparam();/* prepare without parameters */
+  test_select();        /* simple prepare-select */
   test_insert();        /* prepare with insert */
-  //test_bind_result();   /* result bind test */   
-  //test_long_data();     /* long data handling in pieces */
+  test_bind_result();   /* result bind test */   
+  test_long_data();     /* long data handling in pieces */
   test_prepare_simple();/* simple prepare */ 
   test_prepare();       /* prepare test */
-  test_prepare_simple();/* simple prepare */ 
   test_null();          /* test null data handling */
   test_debug_example(); /* some debugging case */
   test_update();        /* prepare-update test */
   test_simple_update(); /* simple prepare with update */
-  //test_long_data();     /* long data handling in pieces */
+  test_long_data();     /* long data handling in pieces */
   test_simple_delete(); /* prepare with delete */
   test_field_names();   /* test for field names */
   test_double_compare();/* float comparision */ 
@@ -2499,20 +3642,23 @@ int main(int argc, char **argv)
   test_tran_innodb();   /* transaction test on InnoDB table type */ 
   test_prepare_ext();   /* test prepare with all types conversion -- TODO */
   test_prepare_syntax();/* syntax check for prepares */
-  //test_prepare_field_result(); /* prepare meta info */
+  test_prepare_field_result(); /* prepare meta info */
+  test_prepare_resultset();
   test_field_names();   /* test for field names */
   test_field_flags();   /* test to help .NET provider team */
-  //test_long_data_str(); /* long data handling */
-  //test_long_data_str1();/* yet another long data handling */
-  //test_long_data_bin(); /* long binary insertion */
+  test_long_data_str(); /* long data handling */
+  test_long_data_str1();/* yet another long data handling */
+  test_long_data_bin(); /* long binary insertion */
   test_warnings();      /* show warnings test */
   test_errors();        /* show errors test */
-  //test_select_simple(); /* simple select prepare */
-  //test_prepare_resultset();/* prepare meta info test */
-
+  test_select_simple(); /* simple select prepare */
+  test_prepare_resultset();/* prepare meta info test */
+  test_func_fields();   /* FUNCTION field info */
+  /*test_stmt_close(); */    /* mysql_stmt_close() test -- hangs */
+  test_prepare_field_result(); /* prepare meta info */
   client_disconnect();  /* disconnect from server */
 
-  fprintf(stdout,"\ndone !!!\n");
+  fprintf(stdout,"\n\nSUCCESS !!!\n");
   return(0);
 }