Adding upstream version 1:10.5.12.upstream/1%10.5.12upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

37 files changed, 30271 insertions, 0 deletions

diff --git a/libmariadb/unittest/libmariadb/CMakeLists.txt b/libmariadb/unittest/libmariadb/CMakeLists.txt
new file mode 100644
index 00000000..e3ba18b8
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/CMakeLists.txt
@@ -0,0 +1,67 @@
+# Copyright (C) 2008 Sun Microsystems, Inc.
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+IF(SKIP_TESTS)
+  RETURN()
+ENDIF()
+
+ENABLE_TESTING()
+
+
+INCLUDE_DIRECTORIES(${CC_SOURCE_DIR}/include
+                    ${CC_BINARY_DIR}/include
+                    ${CC_SOURCE_DIR}/unittest/mytap
+                    ${CC_SOURCE_DIR}/unittest/libmariadb)
+ADD_DEFINITIONS(-DLIBMARIADB)
+
+SET(API_TESTS "conc336" "bulk1" "performance" "basic-t" "fetch" "charset" "logs" "cursor" "errors" "view" "ps" "ps_bugs" "sp" "result" "connection" "misc" "ps_new" "thread" "features-10_2" "bulk1")
+IF(WITH_DYNCOL)
+  SET(API_TESTS ${API_TESTS} "dyncol")
+ENDIF()
+
+SET(API_TESTS ${API_TESTS} "async")
+
+#exclude following tests from ctests, since we need to run them maually with different credentials
+SET(MANUAL_TESTS "t_aurora" "t_conc173" "rpl_api")
+# Get finger print from server certificate
+IF(WITH_SSL)
+  IF(CERT_PATH AND NOT DEFINED ENV{TRAVIS})
+    SET(API_TESTS ${API_TESTS} "ssl")
+    IF(WIN32)
+      STRING(REPLACE "\\" "\\\\" CERT_PATH ${CERT_PATH})
+    ENDIF()
+    ADD_DEFINITIONS(-DCERT_PATH="${CERT_PATH}")
+  ENDIF()
+ENDIF()
+
+ADD_LIBRARY(ma_getopt ma_getopt.c)
+
+FOREACH(API_TEST ${API_TESTS})
+  IF (NOT TARGET ${API_TEST})
+    ADD_EXECUTABLE(${API_TEST} ${API_TEST}.c)
+  ENDIF()
+  TARGET_LINK_LIBRARIES(${API_TEST} cctap ma_getopt mariadbclient)
+  ADD_TEST(${API_TEST} ${EXECUTABLE_OUTPUT_PATH}/${API_TEST})
+  IF(${API_TEST} STREQUAL "cursor" OR ${API_TEST} STREQUAL "ps_new")
+    SET_TESTS_PROPERTIES(${API_TEST} PROPERTIES TIMEOUT 360)
+  ELSE()
+    SET_TESTS_PROPERTIES(${API_TEST} PROPERTIES TIMEOUT 180)
+  ENDIF()
+ENDFOREACH(API_TEST)
+
+FOREACH(API_TEST ${MANUAL_TESTS})
+  ADD_EXECUTABLE(${API_TEST} ${API_TEST}.c)
+  TARGET_LINK_LIBRARIES(${API_TEST} cctap ma_getopt mariadbclient)
+ENDFOREACH()
diff --git a/libmariadb/unittest/libmariadb/async.c b/libmariadb/unittest/libmariadb/async.c
new file mode 100644
index 00000000..079f19d8
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/async.c
@@ -0,0 +1,271 @@
+/*
+  Copyright 2011 Kristian Nielsen and Monty Program Ab.
+
+  This file is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "my_test.h"
+#include "ma_common.h"
+
+
+#ifndef _WIN32
+#include <poll.h>
+#else
+#include <winsock2.h>
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <mysql.h>
+
+my_bool skip_async= 0;
+
+static int test_async(MYSQL *mysql)
+{
+  int type;
+  mariadb_get_info(mysql, MARIADB_CONNECTION_PVIO_TYPE, &type);
+  if (type > MARIADB_CONNECTION_TCP)
+  {
+    skip_async= 1;
+    diag("Asnyc IO not supported");
+  }
+  return OK;
+}
+
+static int
+wait_for_mysql(MYSQL *mysql, int status)
+{
+#ifdef _WIN32
+  fd_set rs, ws, es;
+  int res;
+  struct timeval tv, *timeout;
+  my_socket s= mysql_get_socket(mysql);
+  FD_ZERO(&rs);
+  FD_ZERO(&ws);
+  FD_ZERO(&es);
+  if (status & MYSQL_WAIT_READ)
+    FD_SET(s, &rs);
+  if (status & MYSQL_WAIT_WRITE)
+    FD_SET(s, &ws);
+  if (status & MYSQL_WAIT_EXCEPT)
+    FD_SET(s, &es);
+  if (status & MYSQL_WAIT_TIMEOUT)
+  {
+    tv.tv_sec= mysql_get_timeout_value(mysql);
+    tv.tv_usec= 0;
+    timeout= &tv;
+  }
+  else
+    timeout= NULL;
+  res= select(1, &rs, &ws, &es, timeout);
+  if (res == 0)
+    return MYSQL_WAIT_TIMEOUT;
+  else if (res == SOCKET_ERROR)
+  {
+    /*
+      In a real event framework, we should handle errors and re-try the select.
+    */
+    return MYSQL_WAIT_TIMEOUT;
+  }
+  else
+  {
+    int status= 0;
+    if (FD_ISSET(s, &rs))
+      status|= MYSQL_WAIT_READ;
+    if (FD_ISSET(s, &ws))
+      status|= MYSQL_WAIT_WRITE;
+    if (FD_ISSET(s, &es))
+      status|= MYSQL_WAIT_EXCEPT;
+    return status;
+  }
+#else
+  struct pollfd pfd;
+  int timeout;
+  int res= -1;
+
+  pfd.fd= mysql_get_socket(mysql);
+  pfd.events=
+    (status & MYSQL_WAIT_READ ? POLLIN : 0) |
+    (status & MYSQL_WAIT_WRITE ? POLLOUT : 0) |
+    (status & MYSQL_WAIT_EXCEPT ? POLLPRI : 0);
+  if (status & MYSQL_WAIT_TIMEOUT)
+  {
+    timeout= mysql_get_timeout_value_ms(mysql);
+  }
+  else
+    timeout= -1;
+  do {
+    res= poll(&pfd, 1, timeout);
+  } while (res == -1 && errno == EINTR);
+  if (res == 0)
+    return MYSQL_WAIT_TIMEOUT;
+  else if (res < 0)
+  {
+    /*
+      In a real event framework, we should handle EINTR and re-try the poll.
+    */
+    return MYSQL_WAIT_TIMEOUT;
+  }
+  else
+  {
+    int status= 0;
+    if (pfd.revents & POLLIN)
+      status|= MYSQL_WAIT_READ;
+    if (pfd.revents & POLLOUT)
+      status|= MYSQL_WAIT_WRITE;
+    if (pfd.revents & POLLPRI)
+      status|= MYSQL_WAIT_EXCEPT;
+    return status;
+  }
+#endif
+}
+
+static int async1(MYSQL *unused __attribute__((unused)))
+{
+  int err= 0, rc;
+  MYSQL mysql, *ret;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  int status;
+  uint default_timeout;
+  int i;
+
+  if (skip_async)
+    return SKIP;
+
+  for (i=0; i < 100; i++)
+  {
+
+    mysql_init(&mysql);
+    rc= mysql_options(&mysql, MYSQL_OPT_NONBLOCK, 0);
+    check_mysql_rc(rc, (MYSQL *)&mysql);
+
+    /* set timeouts to 300 microseconds */
+    default_timeout= 3;
+    mysql_options(&mysql, MYSQL_OPT_READ_TIMEOUT, &default_timeout);
+    mysql_options(&mysql, MYSQL_OPT_CONNECT_TIMEOUT, &default_timeout);
+    mysql_options(&mysql, MYSQL_OPT_WRITE_TIMEOUT, &default_timeout);
+    mysql_options(&mysql, MYSQL_READ_DEFAULT_GROUP, "myapp");
+    if (force_tls)
+      mysql_ssl_set(&mysql, NULL, NULL, NULL, NULL,NULL);
+
+    /* Returns 0 when done, else flag for what to wait for when need to block. */
+    status= mysql_real_connect_start(&ret, &mysql, hostname, username, password, schema, port, socketname, 0);
+    while (status)
+    {
+      status= wait_for_mysql(&mysql, status);
+      status= mysql_real_connect_cont(&ret, &mysql, status);
+    }
+    if (!ret)
+    {
+      diag("Error: %s", mysql_error(&mysql));
+      FAIL_IF(!ret, "Failed to mysql_real_connect()");
+    }
+
+    if (force_tls && !mysql_get_ssl_cipher(&mysql))
+    {
+      diag("Error: No tls connection");
+      return FAIL;
+    }
+
+    status= mysql_real_query_start(&err, &mysql, SL("SHOW STATUS"));
+    while (status)
+    {
+      status= wait_for_mysql(&mysql, status);
+      status= mysql_real_query_cont(&err, &mysql, status);
+    }
+    FAIL_IF(err, "mysql_real_query() returns error");
+
+    /* This method cannot block. */
+    res= mysql_use_result(&mysql);
+    FAIL_IF(!res, "mysql_use_result() returns error");
+
+    for (;;)
+    {
+      status= mysql_fetch_row_start(&row, res);
+      while (status)
+      {
+        status= wait_for_mysql(&mysql, status);
+        status= mysql_fetch_row_cont(&row, res, status);
+      }
+      if (!row)
+        break;
+    }
+    FAIL_IF(mysql_errno(&mysql), "Got error while retrieving rows");
+    mysql_free_result(res);
+
+    /*
+      mysql_close() sends a COM_QUIT packet, and so in principle could block
+      waiting for the socket to accept the data.
+      In practise, for many applications it will probably be fine to use the
+      blocking mysql_close().
+     */
+    status= mysql_close_start(&mysql);
+    while (status)
+    {
+      status= wait_for_mysql(&mysql, status);
+      status= mysql_close_cont(&mysql, status);
+    }
+  }
+  return OK;
+}
+
+static int test_conc131(MYSQL *unused __attribute__((unused)))
+{
+  int rc;
+  /* this test needs to run under valgrind */
+  MYSQL *mysql;
+  
+  if (skip_async)
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  rc= mysql_options(mysql, MYSQL_OPT_NONBLOCK, 0);
+  check_mysql_rc(rc, mysql);
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_conc129(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+  
+  if (skip_async)
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(mysql_close_start(mysql), "No error expected");
+  return OK;
+}
+
+
+struct my_tests_st my_tests[] = {
+  {"test_async", test_async, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"async1", async1, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_conc131", test_conc131, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {"test_conc129", test_conc129, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/basic-t.c b/libmariadb/unittest/libmariadb/basic-t.c
new file mode 100644
index 00000000..87bff9a9
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/basic-t.c
@@ -0,0 +1,843 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+
+/**
+  Some basic tests of the client API.
+*/
+
+#include "my_test.h"
+#include "ma_common.h"
+
+static int test_conc75(MYSQL *my)
+{
+  int rc;
+  MYSQL *mysql;
+  int i;
+  my_bool reconnect= 1;
+
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  mysql= mysql_init(NULL);
+
+  mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  my_test_connect(mysql, hostname, username, password, schema, port, socketname, 0| CLIENT_MULTI_RESULTS | CLIENT_REMEMBER_OPTIONS);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS a");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE a (a varchar(200))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_set_character_set(mysql, "utf8");
+  check_mysql_rc(rc, mysql);
+
+  for (i=0; i < 10; i++)
+  {
+    ulong thread_id= mysql_thread_id(mysql);
+    /* force reconnect */
+    mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+    diag("killing connection");
+    mysql_kill(my, thread_id);
+    mysql_ping(mysql);
+    rc= mysql_query(mysql, "load data local infile './nonexistingfile.csv' into table a (`a`)");
+    FAIL_IF(!test(mysql->options.client_flag | CLIENT_LOCAL_FILES), "client_flags not correct");
+    diag("thread1: %ld %ld", thread_id, mysql_thread_id(mysql));
+    FAIL_IF(thread_id == mysql_thread_id(mysql), "new thread id expected");
+    //diag("cs: %s", mysql->charset->csname);
+    //FAIL_IF(strcmp(mysql->charset->csname, "utf8"), "wrong character set");
+  }
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS a");
+  check_mysql_rc(rc, mysql);
+  mysql_close(mysql);
+  return OK;
+}
+
+
+static int test_conc74(MYSQL *unused __attribute__((unused)))
+{
+  int rc;
+  MYSQL *mysql;
+
+  mysql= mysql_init(NULL);
+
+
+  if (!my_test_connect(mysql, hostname, username, password, schema, port, socketname, 0| CLIENT_MULTI_RESULTS | CLIENT_REMEMBER_OPTIONS))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+    return FAIL;
+  }
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS a");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE a (a varchar(200))");
+  check_mysql_rc(rc, mysql);
+
+  mysql->options.client_flag&= ~CLIENT_LOCAL_FILES;
+
+  rc= mysql_query(mysql, "load data local infile './nonexistingfile.csv' into table a (`a`)");
+  FAIL_IF(!rc, "Error expected");
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS a");
+  check_mysql_rc(rc, mysql);
+
+  mysql_close(mysql);
+  return OK;
+}
+
+
+static int test_conc71(MYSQL *my)
+{
+  int rc;
+  MYSQL *mysql;
+  
+  /* uncomment if you want to test manually */
+  return SKIP;
+
+  mysql= mysql_init(NULL);
+
+
+  mysql_options(mysql, MYSQL_SET_CHARSET_NAME, "utf8");
+  mysql_options(mysql, MYSQL_OPT_COMPRESS, 0);
+  mysql_options(mysql, MYSQL_INIT_COMMAND, "/*!40101 SET SQL_MODE='' */");
+  mysql_options(mysql, MYSQL_INIT_COMMAND, "/*!40101 set @@session.wait_timeout=28800 */");
+
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(my));
+
+  diag("kill server");
+
+  rc= mysql_query(mysql, "SELECT 'foo' FROM DUAL");
+  check_mysql_rc(rc, mysql);
+
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_conc70(MYSQL *my)
+{
+  int rc;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  MYSQL *mysql;
+
+  SKIP_CONNECTION_HANDLER;
+
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  mysql= mysql_init(NULL);
+
+  rc= mysql_query(my, "SET @a:=@@max_allowed_packet");
+  check_mysql_rc(rc, my);
+
+  mysql_query(my, "SET global max_allowed_packet=1024*1024*22");
+  check_mysql_rc(rc, my);
+
+  mysql_options(mysql, MYSQL_OPT_COMPRESS, (void *)1);
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(my));
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a LONGBLOB) engine=MyISAM");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (REPEAT('A', 1024 * 1024 * 20))");
+  check_mysql_rc(rc, mysql);
+
+  if (mysql_warning_count(mysql))
+  {
+    diag("server doesn't accept package size");
+    return SKIP;
+  }
+
+
+  rc= mysql_query(mysql, "SELECT a FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  if (!(res= mysql_store_result(mysql)))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    return FAIL;
+  }
+
+  row= mysql_fetch_row(res);
+  diag("Length: %ld", (long)strlen(row[0]));
+  FAIL_IF(strlen(row[0]) != 1024 * 1024 * 20, "Wrong length");
+
+  mysql_free_result(res);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  mysql_close(mysql);
+
+  rc= mysql_query(my, "SET global max_allowed_packet=@a");
+  check_mysql_rc(rc, my);
+
+  return OK;
+}
+
+static int test_conc68(MYSQL *my)
+{
+  int rc;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  MYSQL *mysql;
+
+  SKIP_CONNECTION_HANDLER;
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+  
+  mysql= mysql_init(NULL);
+
+  rc= mysql_query(my, "SET @a:=@@max_allowed_packet");
+  check_mysql_rc(rc, my);
+
+  mysql_query(my, "SET global max_allowed_packet=1024*1024*22");
+
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(my));
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a LONGBLOB) ENGINE=MyISAM");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (REPEAT('A', 1024 * 1024 * 20))");
+  check_mysql_rc(rc, mysql); 
+  if (mysql_warning_count(mysql))
+  {
+    diag("server doesn't accept package size");
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "SELECT a FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  if (!(res= mysql_store_result(mysql)))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    return FAIL;
+  }
+
+  row= mysql_fetch_row(res);
+  diag("Length: %ld", (long)strlen(row[0]));
+  FAIL_IF(strlen(row[0]) != 1024 * 1024 * 20, "Wrong length");
+
+  mysql_free_result(res);
+  mysql_close(mysql);
+
+  rc= mysql_query(my, "SET global max_allowed_packet=@a");
+  check_mysql_rc(rc, my);
+
+  return OK;
+}
+
+
+static int basic_connect(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL_ROW row;
+  MYSQL_RES *res;
+  MYSQL_FIELD *field;
+  int rc;
+  MYSQL *my;
+
+  my= mysql_init(NULL);
+  FAIL_IF(!my, "mysql_init() failed");
+
+  FAIL_IF(!my_test_connect(my, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(my));
+
+  rc= mysql_query(my, "SELECT @@version");
+  check_mysql_rc(rc, my);
+
+  res= mysql_store_result(my);
+  FAIL_IF(!res, mysql_error(my));
+  field= mysql_fetch_fields(res);
+  FAIL_IF(!field, "couldn't fetch field");
+  while ((row= mysql_fetch_row(res)) != NULL)
+  {
+    FAIL_IF(mysql_num_fields(res) != 1, "Got the wrong number of fields");
+  }
+  FAIL_IF(mysql_errno(my), mysql_error(my));
+
+  mysql_free_result(res);
+  mysql_close(my);
+
+  return OK;
+}
+
+
+static int use_utf8(MYSQL *my)
+{
+  MYSQL_ROW row;
+  MYSQL_RES *res;
+  int rc;
+
+  /* Make sure that we actually ended up with utf8. */
+  rc= mysql_query(my, "SELECT @@character_set_connection");
+  check_mysql_rc(rc, my);
+
+  res= mysql_store_result(my);
+  FAIL_IF(!res, mysql_error(my));
+
+  while ((row= mysql_fetch_row(res)) != NULL)
+  {
+    FAIL_IF(strncmp(row[0], "utf8", 4), "wrong character set");
+  }
+  FAIL_IF(mysql_errno(my), mysql_error(my));
+  mysql_free_result(res);
+
+  return OK;
+}
+
+int client_query(MYSQL *mysql) {
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1("
+                         "id int primary key auto_increment, "
+                         "name varchar(20))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1(id int, name varchar(20))");
+  FAIL_IF(!rc, "Error expected");
+  rc= mysql_query(mysql, "INSERT INTO t1(name) VALUES('mysql')");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1(name) VALUES('monty')");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1(name) VALUES('venu')");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1(name) VALUES('deleted')");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1(name) VALUES('deleted')");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "UPDATE t1 SET name= 'updated' "
+                          "WHERE name= 'deleted'");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "UPDATE t1 SET id= 3 WHERE name= 'updated'");
+  FAIL_IF(!rc, "Error expected");
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug12001(MYSQL *mysql)
+{
+  MYSQL_RES *result;
+  const char *query= "DROP TABLE IF EXISTS test_table;"
+                     "CREATE TABLE test_table(id INT);"
+                     "INSERT INTO test_table VALUES(10);"
+                     "UPDATE test_table SET id=20 WHERE id=10;"
+                     "SELECT * FROM test_table;"
+                     "INSERT INTO non_existent_table VALUES(11);";
+  int rc, res;
+
+
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  do
+  {
+    if (mysql_field_count(mysql) &&
+        (result= mysql_use_result(mysql)))
+    {
+      mysql_free_result(result);
+    }
+  }
+  while (!(res= mysql_next_result(mysql)));
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_table");
+  check_mysql_rc(rc, mysql);
+
+  FAIL_UNLESS(res==1, "res != 1");
+
+  return OK;
+}
+
+
+/* connection options */
+struct my_option_st opt_utf8[] = {
+  {MYSQL_SET_CHARSET_NAME, (char *)"utf8"},
+  {0, NULL}
+};
+
+static int test_bad_union(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  const char *query= "SELECT 1, 2 union SELECT 1";
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  FAIL_UNLESS(rc && mysql_errno(mysql) == 1222, "Error expected");
+
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+/*
+   Test that mysql_insert_id() behaves as documented in our manual
+*/
+static int test_mysql_insert_id(MYSQL *mysql)
+{
+  unsigned long long res;
+  int rc;
+
+  if (mysql_get_server_version(mysql) < 50100) {
+    diag("Test requires MySQL Server version 5.1 or above");
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "drop table if exists t2");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "drop table if exists t3");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "drop table if exists t4");
+  check_mysql_rc(rc, mysql);
+  /* table without auto_increment column */
+  rc= mysql_query(mysql, "create table t1 (f1 int, f2 varchar(255), key(f1))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t2 (f1 int not null primary key auto_increment, f2 varchar(255))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t3 (f1 int not null primary key auto_increment, f2 varchar(255)) engine=MyISAM");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t4 (f1 int not null primary key "
+                  "auto_increment, f2 varchar(200), unique (f2)) engine=MyISAM");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "FLUSH TABLES");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "START TRANSACTION");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t1 values (1,'a')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+  rc= mysql_query(mysql, "insert into t1 values (null,'b')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+  rc= mysql_query(mysql, "insert into t1 select 5,'c'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+
+  /*
+    Test for bug #34889: mysql_client_test::test_mysql_insert_id test fails
+    sporadically
+  */
+  rc= mysql_query(mysql, "insert into t2 values (null,'b')");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 select 5,'c'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+  rc= mysql_query(mysql, "insert into t1 select null,'d'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+  rc= mysql_query(mysql, "insert into t1 values (null,last_insert_id(300))");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 300, "");
+  rc= mysql_query(mysql, "insert into t1 select null,last_insert_id(400)");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  /*
+    Behaviour change: old code used to return 0; but 400 is consistent
+    with INSERT VALUES, and the manual's section of mysql_insert_id() does not
+    say INSERT SELECT should be different.
+  */
+  FAIL_UNLESS(res == 400, "");
+
+  /* table with auto_increment column */
+  rc= mysql_query(mysql, "insert into t3 values (1,'a')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 1, "");
+  /* this should not influence next INSERT if it doesn't have auto_inc */
+  rc= mysql_query(mysql, "insert into t1 values (10,'e')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+
+  rc= mysql_query(mysql, "insert into t3 values (null,'b')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 2, "");
+  rc= mysql_query(mysql, "insert into t3 select 5,'c'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  /*
+    Manual says that for multirow insert this should have been 5, but does not
+    say for INSERT SELECT. This is a behaviour change: old code used to return
+    0. We try to be consistent with INSERT VALUES.
+  */
+  FAIL_UNLESS(res == 5, "");
+  rc= mysql_query(mysql, "insert into t3 select null,'d'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 6, "");
+  /* with more than one row */
+  rc= mysql_query(mysql, "insert into t3 values (10,'a'),(11,'b')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 11, "");
+  rc= mysql_query(mysql, "insert into t3 select 12,'a' union select 13,'b'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  /*
+    Manual says that for multirow insert this should have been 13, but does
+    not say for INSERT SELECT. This is a behaviour change: old code used to
+    return 0. We try to be consistent with INSERT VALUES.
+  */
+  FAIL_UNLESS(res == 13, "");
+  rc= mysql_query(mysql, "insert into t3 values (null,'a'),(null,'b')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 14, "");
+  rc= mysql_query(mysql, "insert into t3 select null,'a' union select null,'b'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 16, "");
+  rc= mysql_query(mysql, "insert into t3 select 12,'a' union select 13,'b'");
+  FAIL_IF(!rc, "Error expected");
+  rc= mysql_query(mysql, "insert ignore into t3 select 12,'a' union select 13,'b'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+  rc= mysql_query(mysql, "insert into t3 values (12,'a'),(13,'b')");
+  FAIL_IF(!rc, "Error expected");
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+  rc= mysql_query(mysql, "insert ignore into t3 values (12,'a'),(13,'b')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+  /* mixing autogenerated and explicit values */
+  rc= mysql_query(mysql, "insert into t3 values (null,'e'),(12,'a'),(13,'b')");
+  FAIL_IF(!rc, "Error expected");
+  rc= mysql_query(mysql, "insert into t3 values (null,'e'),(12,'a'),(13,'b'),(25,'g')");
+  FAIL_IF(!rc, "Error expected");
+  rc= mysql_query(mysql, "insert into t3 values (null,last_insert_id(300))");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  /*
+    according to the manual, this might be 20 or 300, but it looks like
+    auto_increment column takes priority over last_insert_id().
+  */
+  diag("res: %lld", res);
+  FAIL_UNLESS(res == 20, "");
+  /* If first autogenerated number fails and 2nd works: */
+  rc= mysql_query(mysql, "insert into t4 values (null,'e')");
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 1, "");
+  rc= mysql_query(mysql, "insert ignore into t4 values (null,'e'),(null,'a'),(null,'e')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 2, "");
+  /* If autogenerated fails and explicit works: */
+  rc= mysql_query(mysql, "insert ignore into t4 values (null,'e'),(12,'c'),(null,'d')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  /*
+    Behaviour change: old code returned 3 (first autogenerated, even if it
+    fails); we now return first successful autogenerated.
+  */
+  FAIL_UNLESS(res == 13, "");
+  /* UPDATE may update mysql_insert_id() if it uses LAST_INSERT_ID(#) */
+  rc= mysql_query(mysql, "update t4 set f1=14 where f1=12");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+  rc= mysql_query(mysql, "update t4 set f1=0 where f1=14");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+  rc= mysql_query(mysql, "update t4 set f2=last_insert_id(372) where f1=0");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 372, "");
+  /* check that LAST_INSERT_ID() does not update mysql_insert_id(): */
+  rc= mysql_query(mysql, "insert into t4 values (null,'g')");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 15, "");
+  rc= mysql_query(mysql, "update t4 set f2=(@li:=last_insert_id()) where f1=15");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+  /*
+    Behaviour change: now if ON DUPLICATE KEY UPDATE updates a row,
+    mysql_insert_id() returns the id of the row, instead of not being
+    affected.
+  */
+  rc= mysql_query(mysql, "insert into t4 values (null,@li) on duplicate key "
+                  "update f2=concat('we updated ',f2)");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 15, "");
+
+  rc= mysql_query(mysql, "drop table t1,t2,t3,t4");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test simple select to debug */
+
+static int test_select_direct(MYSQL *mysql)
+{
+  int        rc;
+  MYSQL_RES  *result;
+
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_select");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_select(id int, id1 tinyint, "
+                                                 " id2 float, "
+                                                 " id3 double, "
+                                                 " name varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  /* insert a row and commit the transaction */
+  rc= mysql_query(mysql, "INSERT INTO test_select VALUES(10, 5, 2.3, 4.5, 'venu')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT * FROM test_select");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_select");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/*
+  Ensure we execute the status code while testing
+*/
+
+static int test_status(MYSQL *mysql)
+{
+  mysql_stat(mysql);
+  check_mysql_rc(mysql_errno(mysql), mysql);
+  return OK;
+}
+
+static int bug_conc1(MYSQL *mysql)
+{
+  my_test_connect(mysql, hostname, username, password, schema,
+                     port, socketname, 0);
+  diag("errno: %d", mysql_errno(mysql));
+  FAIL_IF(mysql_errno(mysql) != CR_ALREADY_CONNECTED,
+          "Expected errno=CR_ALREADY_CONNECTED");
+  return OK;
+}
+
+static int test_options_initcmd(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql= mysql_init(NULL);
+  MYSQL_RES *res;
+  int rc;
+
+  mysql_options(mysql, MYSQL_INIT_COMMAND, "DROP TABLE IF EXISTS t1; CREATE TABLE t1 (a int)");
+  mysql_options(mysql, MYSQL_INIT_COMMAND, "INSERT INTO t1 VALUES (1),(2),(3)");
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
+                              port, socketname, 
+                              CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS), mysql_error(mysql));
+
+  rc= mysql_query(mysql, "SELECT a FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  FAIL_IF(mysql_num_rows(res) != 3, "Expected 3 rows");
+
+  mysql_free_result(res);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_extended_init_values(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql= mysql_init(NULL);
+
+  mysql_options(mysql, MYSQL_DEFAULT_AUTH, "unknown");
+  FAIL_IF(strcmp(mysql->options.extension->default_auth, "unknown"), "option not set");
+
+  mysql_options(mysql, MYSQL_PLUGIN_DIR, "/tmp/foo");
+  FAIL_IF(strcmp(mysql->options.extension->plugin_dir, "/tmp/foo"), "option not set");
+
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_reconnect_maxpackage(MYSQL *unused __attribute__((unused)))
+{
+  int rc;
+  ulong max_packet= 0;
+  MYSQL *mysql;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  char *query;
+  my_bool reconnect= 1;
+
+  SKIP_CONNECTION_HANDLER;
+
+  mysql= mysql_init(NULL);
+
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
+                              port, socketname,
+                              CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS), mysql_error(mysql));
+  mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+
+  rc= mysql_query(mysql, "SELECT @@max_allowed_packet");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+  max_packet= atol(row[0]);
+  diag("max_allowed_packet=%lu", max_packet);
+  mysql_free_result(res);
+
+  query= (char *)malloc(max_packet + 30);
+  memset(query, 0, max_packet + 30);
+
+  strcpy(query, "SELECT '");
+  memset(query + 8, 'A', max_packet);
+  strcat(query, "' FROM DUAL");
+
+  rc= mysql_query(mysql, query);
+  free(query);
+  if (!rc)
+  {
+    diag("expected error");
+    mysql_close(mysql);
+    return FAIL;
+  }
+  else
+    diag("Error (expected): %s", mysql_error(mysql));
+
+  rc= mysql_ping(mysql);
+  /* if the server is under load, poll might not report closed
+     socket since FIN packet came too late */
+  if (rc)
+    rc= mysql_ping(mysql);
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "SELECT @@max_allowed_packet");
+  check_mysql_rc(rc, mysql);
+   res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+  max_packet= atol(row[0]);
+  diag("max_allowed_packet=%lu", max_packet);
+  mysql_free_result(res);
+
+
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_compressed(MYSQL *unused __attribute__((unused)))
+{
+  int rc;
+  MYSQL *mysql= mysql_init(NULL);
+  MYSQL_RES *res;
+  my_bool reconnect= 1;
+
+  mysql_options(mysql, MYSQL_OPT_COMPRESS, (void *)1);
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
+                              port, socketname, 
+                              CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS), mysql_error(mysql));
+  mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+
+  rc= mysql_query(mysql, "SHOW VARIABLES");
+  check_mysql_rc(rc, mysql);
+
+  if ((res= mysql_store_result(mysql)))
+    mysql_free_result(res);
+
+  mysql_close(mysql);
+
+  return OK;
+}
+
+struct my_tests_st my_tests[] = {
+  {"test_conc75", test_conc75, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_conc74", test_conc74, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_conc71", test_conc71, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_conc70", test_conc70, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_conc68", test_conc68, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_compressed", test_compressed, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {"test_reconnect_maxpackage", test_reconnect_maxpackage, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {"basic_connect", basic_connect, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {"use_utf8", use_utf8, TEST_CONNECTION_NEW, 0,  opt_utf8,  NULL},
+  {"client_query", client_query, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_bad_union", test_bad_union, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_select_direct", test_select_direct, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_mysql_insert_id", test_mysql_insert_id, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_bug12001", test_bug12001, TEST_CONNECTION_NEW, CLIENT_MULTI_STATEMENTS,  NULL,  NULL},
+  {"test_status", test_status, TEST_CONNECTION_NEW, CLIENT_MULTI_STATEMENTS,  NULL,  NULL},
+  {"bug_conc1", bug_conc1, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_options_initcmd", test_options_initcmd, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {"test_extended_init_values", test_extended_init_values, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  diag("user: %s", username);
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/bulk1.c b/libmariadb/unittest/libmariadb/bulk1.c
new file mode 100644
index 00000000..d220aa31
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/bulk1.c
@@ -0,0 +1,1100 @@
+/*
+  Copyright 2011 Kristian Nielsen and Monty Program Ab.
+
+  This file is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "my_test.h"
+#include "ma_common.h"
+
+#define TEST_ARRAY_SIZE 1024
+
+static my_bool bulk_enabled= 0;
+
+char *rand_str(size_t length) {
+    const char charset[] = "0123456789"
+                     "abcdefghijklmnopqrstuvwxyz"
+                     "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    char *dest= (char *)malloc(length+1);
+    char *p= dest;
+    while (length-- > 0) {
+        *dest++ = charset[rand() % sizeof(charset)];
+    }
+    *dest = '\0';
+    return p;
+}
+
+static int check_bulk(MYSQL *mysql)
+{
+  bulk_enabled= (!(mysql->server_capabilities & CLIENT_MYSQL) &&
+      (mysql->extension->mariadb_server_capabilities &
+      (MARIADB_CLIENT_STMT_BULK_OPERATIONS >> 32)));
+  diag("bulk %ssupported", bulk_enabled ? "" : "not ");
+  return OK;
+}
+
+static int bulk1(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  const char *stmt_str= "INSERT INTO bulk1 VALUES (?,?)";
+  unsigned int array_size= TEST_ARRAY_SIZE;
+  int rc;
+  unsigned int i;
+  char **buffer;
+  unsigned long *lengths;
+  unsigned int *vals;
+  MYSQL_BIND bind[2];
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  unsigned int intval;
+
+  if (!bulk_enabled)
+    return SKIP;
+
+  rc= mysql_select_db(mysql, "testc");
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE bulk1 (a int , b VARCHAR(255))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_str));
+  check_stmt_rc(rc, stmt);
+
+  /* allocate memory */
+  buffer= calloc(TEST_ARRAY_SIZE, sizeof(char *));
+  lengths= (unsigned long *)calloc(sizeof(long), TEST_ARRAY_SIZE);
+  vals= (unsigned int *)calloc(sizeof(int), TEST_ARRAY_SIZE);
+
+  for (i=0; i < TEST_ARRAY_SIZE; i++)
+  {
+    buffer[i]= rand_str(254);
+    lengths[i]= -1;
+    vals[i]= i;
+  }
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 2);
+  bind[0].buffer_type= MYSQL_TYPE_LONG;
+  bind[0].buffer= vals;
+  bind[1].buffer_type= MYSQL_TYPE_STRING;
+  bind[1].buffer= (void *)buffer;
+  bind[1].length= (unsigned long *)lengths;
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  for (i=0; i < 100; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    FAIL_IF(mysql_stmt_affected_rows(stmt) != TEST_ARRAY_SIZE, "affected_rows != TEST_ARRAY_SIZE");
+  }
+
+  for (i=0; i < array_size; i++)
+    free(buffer[i]);
+
+  free(buffer);
+  free(lengths);
+  free(vals);
+
+  rc= mysql_stmt_close(stmt);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT COUNT(*) FROM bulk1");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+  intval= atoi(row[0]);
+  mysql_free_result(res);
+  FAIL_IF(intval != array_size * 100, "Expected 102400 rows");
+
+  rc= mysql_query(mysql, "SELECT MAX(a) FROM bulk1");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+  intval= atoi(row[0]);
+  mysql_free_result(res);
+  FAIL_IF(intval != array_size - 1, "Expected max value 1024");
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int bulk2(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+  MYSQL_BIND bind[2];
+  unsigned int i;
+  unsigned int array_size=1024;
+  char indicator[1024];
+  long lval[1024];
+
+  if (!bulk_enabled)
+    return SKIP;
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk2");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE bulk2 (a int default 4, b int default 2)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO bulk2 VALUES (?,1)"));
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, 2 * sizeof(MYSQL_BIND));
+
+  for (i=0; i < array_size; i++)
+  {
+    indicator[i]= STMT_INDICATOR_DEFAULT;
+    lval[i]= i;
+  }
+
+  bind[0].buffer_type= MYSQL_TYPE_LONG;
+  bind[0].u.indicator= indicator;
+  bind[1].buffer_type= MYSQL_TYPE_LONG;
+  bind[1].buffer= &lval;
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk2");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int bulk3(MYSQL *mysql)
+{
+  struct st_bulk3 {
+    char char_value[20];
+    unsigned long length;
+    int  int_value;
+  };
+
+  struct st_bulk3 val[3]= {{"Row 1", 5, 1},
+                           {"Row 02", 6, 2},
+                           {"Row 003", 7, 3}};
+  int rc;
+  MYSQL_BIND bind[2];
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  size_t row_size= sizeof(struct st_bulk3);
+  int array_size= 3;
+
+  if (!bulk_enabled)
+    return SKIP;
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk3");
+  check_mysql_rc(rc,mysql);
+  rc= mysql_query(mysql, "CREATE TABLE bulk3 (name varchar(20), row int)");
+  check_mysql_rc(rc,mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO bulk3 VALUES (?,?)"));
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, sizeof(MYSQL_BIND)*2);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ROW_SIZE, &row_size);
+  check_stmt_rc(rc, stmt);
+
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+  bind[0].buffer= &val[0].char_value;
+  bind[0].length= &val[0].length;
+  bind[1].buffer_type= MYSQL_TYPE_LONG;
+  bind[1].buffer= &val[0].int_value;
+
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk3");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int bulk4(MYSQL *mysql)
+{
+  struct st_bulk4 {
+    char char_value[20];
+    char indicator1;
+    int  int_value;
+    char indicator2;
+  };
+
+  struct st_bulk4 val[]= {{"Row 1", STMT_INDICATOR_NTS, 0, STMT_INDICATOR_DEFAULT},
+                          {"Row 2", STMT_INDICATOR_NTS, 0, STMT_INDICATOR_DEFAULT},
+                          {"Row 3", STMT_INDICATOR_NTS, 0, STMT_INDICATOR_DEFAULT}};
+  int rc;
+  MYSQL_BIND bind[2];
+  MYSQL_RES *res;
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  size_t row_size= sizeof(struct st_bulk4);
+  int array_size= 3;
+  unsigned long lengths[3]= {-1, -1, -1};
+
+  if (!bulk_enabled)
+    return SKIP;
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk4");
+  check_mysql_rc(rc,mysql);
+  rc= mysql_query(mysql, "CREATE TABLE bulk4 (name varchar(20), row int not null default 3)");
+  check_mysql_rc(rc,mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO bulk4 VALUES (?,?)"));
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, sizeof(MYSQL_BIND)*2);
+  
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ROW_SIZE, &row_size);
+  check_stmt_rc(rc, stmt);
+
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+  bind[0].u.indicator= &val[0].indicator1;
+  bind[0].buffer= &val[0].char_value;
+  bind[0].length= lengths;
+  bind[1].buffer_type= MYSQL_TYPE_LONG;
+  bind[1].u.indicator= &val[0].indicator2;
+
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "SELECT * FROM bulk4 WHERE row=3");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  rc= (int)mysql_num_rows(res);
+  mysql_free_result(res);
+  FAIL_IF(rc != 3, "expected 3 rows");
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk4");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int bulk_null(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+  MYSQL_BIND bind[2];
+  unsigned int param_count= 2;
+  unsigned int array_size= 2;
+  unsigned long lengths[2]= {-1, -1};
+  char **buf= calloc(1, 2 * sizeof(char *));
+
+  if (!bulk_enabled)
+  {
+    free(buf);
+    return SKIP;
+  }
+
+  buf[0]= strdup("foo");
+  buf[1]= strdup("foobar");
+
+  rc= mariadb_stmt_execute_direct(stmt, "DROP TABLE IF EXISTS bulk_null", -1);
+  check_stmt_rc(rc, stmt);
+
+  rc= mariadb_stmt_execute_direct(stmt, "CREATE TABLE bulk_null (a int not null auto_increment primary key, b varchar(20))", -1);
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, 2 * sizeof(MYSQL_BIND));
+  bind[0].buffer_type= MYSQL_TYPE_NULL;
+  bind[1].buffer_type= MYSQL_TYPE_STRING;
+  bind[1].buffer= buf;
+  bind[1].length= lengths;
+
+  mysql_stmt_close(stmt);
+  stmt= mysql_stmt_init(mysql);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_PREBIND_PARAMS, &param_count);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mariadb_stmt_execute_direct(stmt, "INSERT INTO bulk_null VALUES (?, ?)", -1);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+  free(buf[0]);
+  free(buf[1]);
+  free(buf);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk_null");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int bulk5(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_BIND bind[3];
+  MYSQL_RES *res;
+  unsigned long rows;
+  unsigned int array_size= 5;
+  int rc;
+  int intval[]= {12,13,14,15,16};
+  int id[]= {1,2,3,4,5};
+
+  if (!bulk_enabled)
+    return SKIP;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk5");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE bulk5 (a int, b int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO bulk5 VALUES (1,1), (2,2), (3,3), (4,4), (5,5)");
+  check_mysql_rc(rc, mysql);
+
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 3);
+
+  rc= mysql_stmt_prepare(stmt, SL("UPDATE bulk5 SET a=? WHERE a=?"));
+  check_stmt_rc(rc, stmt);
+
+  bind[0].buffer_type= MYSQL_TYPE_LONG;
+  bind[0].buffer= &intval;
+  bind[1].buffer_type= MYSQL_TYPE_LONG;
+  bind[1].buffer= &id;
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "SELECT * FROM bulk5 WHERE a=b+11");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  rows= (unsigned long)mysql_num_rows(res);
+  diag("rows: %lu", rows);
+  mysql_free_result(res);
+
+  FAIL_IF(rows != 5, "expected 5 rows");
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk5");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int bulk6(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_BIND bind[3];
+  MYSQL_RES *res;
+  unsigned long rows;
+  unsigned int array_size= 5;
+  int rc;
+  int intval[]= {12,13,14,15,16};
+  int id[]= {1,2,3,4,5};
+  char indicator[5];
+
+  if (!bulk_enabled)
+    return SKIP;
+  memset(indicator, STMT_INDICATOR_IGNORE, 5);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk6");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE bulk6 (a int, b int default 4)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO bulk6 VALUES (1,1), (2,2), (3,3), (4,4), (5,5)");
+  check_mysql_rc(rc, mysql);
+
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 3);
+
+  /* 1st case: UPDATE */
+  rc= mysql_stmt_prepare(stmt, SL("UPDATE bulk6 SET a=?, b=? WHERE a=?"));
+  check_stmt_rc(rc, stmt);
+
+  bind[0].buffer_type= MYSQL_TYPE_LONG;
+  bind[0].buffer= &intval;
+  bind[1].buffer_type= MYSQL_TYPE_LONG;
+  bind[1].buffer= &intval;
+  bind[1].u.indicator= indicator;
+  bind[2].buffer_type= MYSQL_TYPE_LONG;
+  bind[2].buffer= &id;
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "SELECT * FROM bulk6 WHERE a=b+11");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  rows= (unsigned long)mysql_num_rows(res);
+  mysql_free_result(res);
+
+  FAIL_IF(rows != 5, "expected 5 rows");
+
+  /* 2nd case: INSERT - ignore indicator should be same as default */
+  rc= mysql_query(mysql, "DELETE FROM bulk6");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO bulk6 VALUES (?,?)"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+
+  /* this should insert 5 default values (=4) */
+  memset(indicator, STMT_INDICATOR_DEFAULT, 5);
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /* this should insert 5 default values (=4) */
+  memset(indicator, STMT_INDICATOR_IGNORE, 5);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "SELECT * FROM bulk6 WHERE b=4");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  rows= (unsigned long)mysql_num_rows(res);
+  mysql_free_result(res);
+
+  FAIL_IF(rows != 10, "expected 10 rows");
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk6");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_conc243(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind[3];
+  MYSQL_RES  *result;
+  MYSQL_ROW  row;
+
+  struct st_data {
+    unsigned long id;
+    char id_ind;
+    char forename[30];
+    char forename_ind;
+    char surname[30];
+    char surname_ind;
+  };
+
+  struct st_data data[]= {
+    {0, STMT_INDICATOR_NULL, "Monty", STMT_INDICATOR_NTS, "Widenius", STMT_INDICATOR_NTS},
+    {0, STMT_INDICATOR_NULL, "David", STMT_INDICATOR_NTS, "Axmark", STMT_INDICATOR_NTS},
+    {0, STMT_INDICATOR_NULL, "default", STMT_INDICATOR_DEFAULT, "N.N.", STMT_INDICATOR_NTS},
+  };
+
+  unsigned int array_size= 1;
+  size_t row_size= sizeof(struct st_data);
+  int rc;
+
+  if (!bulk_enabled)
+    return SKIP;
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk_example2");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE bulk_example2 (id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,"\
+                         "forename CHAR(30) NOT NULL DEFAULT 'unknown', surname CHAR(30))");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO bulk_example2 VALUES (?,?,?)"));
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 3);
+
+  /* We autogenerate id's, so all indicators are STMT_INDICATOR_NULL */
+  bind[0].u.indicator= &data[0].id_ind;
+  bind[0].buffer_type= MYSQL_TYPE_LONG;
+
+  bind[1].buffer= &data[0].forename;
+  bind[1].buffer_type= MYSQL_TYPE_STRING;
+  bind[1].u.indicator= &data[0].forename_ind;
+
+  bind[2].buffer_type= MYSQL_TYPE_STRING;
+  bind[2].buffer= &data[0].surname;
+  bind[2].u.indicator= &data[0].surname_ind;
+
+  /* set array size */
+  mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+
+  /* set row size */
+  mysql_stmt_attr_set(stmt, STMT_ATTR_ROW_SIZE, &row_size);
+
+  /* bind parameter */
+  mysql_stmt_bind_param(stmt, bind);
+
+  /* execute */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "SELECT forename, surname FROM bulk_example2");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result || !mysql_num_rows(result), "Invalid resultset");
+  row = mysql_fetch_row(result);
+  if (strcmp(row[0], "Monty") || strcmp(row[1], "Widenius"))
+  {
+    mysql_free_result(result);
+    diag("Wrong values");
+    return FAIL;
+  }
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE bulk_example2");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+static int bulk7(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+  int array_size= 5;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("UPDATE t1 SET a=a+1"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+
+  FAIL_IF(!rc, "Error expected: Bulk operation without parameters is not supported");
+  diag("%s", mysql_stmt_error(stmt));
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_char_conv1(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  MYSQL_BIND bind_in, bind_out;
+  char buffer[100];
+  char outbuffer[100];
+
+  if (!bulk_enabled)
+    return SKIP;
+  stmt= mysql_stmt_init(mysql);
+  strcpy (buffer, "\xC3\x82\xC3\x83\xC3\x84\x00");
+
+  rc= mysql_query(mysql, "SET NAMES UTF8");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS char_conv");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE char_conv (a varchar(20)) CHARSET=latin1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO char_conv VALUES (?)"));
+  check_stmt_rc(rc, stmt);
+
+  memset(&bind_in, 0, sizeof(MYSQL_BIND));
+  bind_in.buffer_type= MYSQL_TYPE_STRING;
+  bind_in.buffer_length= -1;
+  bind_in.buffer= &buffer;
+
+  rc= mysql_stmt_bind_param(stmt, &bind_in);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("SELECT a from char_conv"));
+  check_stmt_rc(rc, stmt);
+
+  memset(&bind_out, 0, sizeof(MYSQL_BIND));
+  bind_out.buffer_type= MYSQL_TYPE_STRING;
+  bind_out.buffer_length= 100;
+  bind_out.buffer= outbuffer;
+
+  rc= mysql_stmt_bind_result(stmt, &bind_out);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(rc == MYSQL_NO_DATA, "Error");
+
+  mysql_stmt_close(stmt);
+
+
+  if (strcmp(buffer, outbuffer))
+  {
+    diag("Error: Expected '%s' instead of '%s'", buffer, outbuffer);
+    return FAIL;
+  }
+
+  rc= mysql_query(mysql, "DROP TABLE char_conv");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+static int test_char_conv2(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  int array_size= 1;
+  MYSQL_BIND bind_in, bind_out;
+  char *buffer[1];
+  char outbuffer[100];
+
+  if (!bulk_enabled)
+    return SKIP;
+
+  stmt= mysql_stmt_init(mysql);
+  buffer[0]= calloc(1, 7);
+  strcpy (buffer[0], "\xC3\x82\xC3\x83\xC3\x84\x00");
+
+  rc= mysql_query(mysql, "SET NAMES UTF8");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS char_conv");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE char_conv (a varchar(20)) CHARSET=latin1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO char_conv VALUES (?)"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+
+  memset(&bind_in, 0, sizeof(MYSQL_BIND));
+  bind_in.buffer_type= MYSQL_TYPE_STRING;
+  bind_in.buffer_length= -1;
+  bind_in.buffer= &buffer;
+
+  rc= mysql_stmt_bind_param(stmt, &bind_in);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("SELECT a from char_conv"));
+  check_stmt_rc(rc, stmt);
+
+  memset(&bind_out, 0, sizeof(MYSQL_BIND));
+  bind_out.buffer_type= MYSQL_TYPE_STRING;
+  bind_out.buffer_length= 100;
+  bind_out.buffer= outbuffer;
+
+  rc= mysql_stmt_bind_result(stmt, &bind_out);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(rc == MYSQL_NO_DATA, "Error");
+
+  mysql_stmt_close(stmt);
+
+
+  if (strcmp(buffer[0], outbuffer))
+  {
+    diag("Error: Expected '%s' instead of '%s'", buffer[0], outbuffer);
+    return FAIL;
+  }
+  free(buffer[0]);
+
+  rc= mysql_query(mysql, "DROP TABLE char_conv");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+static int bulk_skip_row(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind[3];
+  MYSQL_RES  *result;
+  MYSQL_ROW  row;
+
+  struct st_data {
+    unsigned long id;
+    char id_ind;
+    char forename[30];
+    char forename_ind;
+    char surname[30];
+    char surname_ind;
+  };
+
+  struct st_data data[]={
+    { 0, STMT_INDICATOR_NULL, "Monty", STMT_INDICATOR_NTS, "Widenius", STMT_INDICATOR_IGNORE_ROW },
+    { 0, STMT_INDICATOR_IGNORE_ROW, "David", STMT_INDICATOR_NTS, "Axmark", STMT_INDICATOR_NTS },
+    { 0, STMT_INDICATOR_NULL, "default", STMT_INDICATOR_DEFAULT, "N.N.", STMT_INDICATOR_NTS },
+  };
+
+  unsigned int array_size= 3;
+  size_t row_size= sizeof(struct st_data);
+  int rc;
+
+  if (!bulk_enabled)
+    return SKIP;
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk_example2");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE bulk_example2 (id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,"\
+    "forename CHAR(30) NOT NULL DEFAULT 'unknown', surname CHAR(30))");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO bulk_example2 VALUES (?,?,?)"));
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 3);
+
+  /* We autogenerate id's, so all indicators are STMT_INDICATOR_NULL */
+  bind[0].u.indicator= &data[0].id_ind;
+  bind[0].buffer_type= MYSQL_TYPE_LONG;
+
+  bind[1].buffer= &data[0].forename;
+  bind[1].buffer_type= MYSQL_TYPE_STRING;
+  bind[1].u.indicator= &data[0].forename_ind;
+
+  bind[2].buffer_type= MYSQL_TYPE_STRING;
+  bind[2].buffer= &data[0].surname;
+  bind[2].u.indicator= &data[0].surname_ind;
+
+  /* set array size */
+  mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+
+  /* set row size */
+  mysql_stmt_attr_set(stmt, STMT_ATTR_ROW_SIZE, &row_size);
+
+  /* bind parameter */
+  mysql_stmt_bind_param(stmt, bind);
+
+  /* execute */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "SELECT forename, surname FROM bulk_example2");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result || mysql_num_rows(result) != 1, "Invalid resultset");
+  
+  row = mysql_fetch_row(result);
+  if (strcmp(row[0], "unknown") || strcmp(row[1], "N.N."))
+  {
+    mysql_free_result(result);
+    diag("Wrong values");
+    return FAIL;
+  }
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE bulk_example2");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int bulk_null_null(MYSQL *mysql)
+{
+  struct st_bulk4 {
+    char char_value[20];
+    char indicator1;
+    int  int_value;
+    char indicator2;
+    double double_value;
+    char indicator3;
+    char time_value[20];
+    char indicator4;
+    char decimal_value[4];
+    char indicator5;
+  };
+
+  struct st_bulk4 val[]= {{"3",      STMT_INDICATOR_NTS,
+                           3,        STMT_INDICATOR_NONE,
+                           3.0,      STMT_INDICATOR_NONE,
+                           "00:00:00",  STMT_INDICATOR_NTS,
+                           "3.0",    STMT_INDICATOR_NTS},
+                          {"3",      STMT_INDICATOR_NULL,
+                           3,        STMT_INDICATOR_NULL,
+                           3.0,      STMT_INDICATOR_NULL,
+                           "00:00:00",  STMT_INDICATOR_NULL,
+                           "3.0",    STMT_INDICATOR_NULL},
+                          {"3",      STMT_INDICATOR_NTS,
+                           3,        STMT_INDICATOR_NONE,
+                           3.0,      STMT_INDICATOR_NONE,
+                           "00:00:00",  STMT_INDICATOR_NTS,
+                           "3.0",    STMT_INDICATOR_NTS}};
+  int rc;
+  MYSQL_BIND bind[5];
+  MYSQL_RES *res;
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  size_t row_size= sizeof(struct st_bulk4);
+  int array_size= 3;
+  unsigned long server_version= mysql_get_server_version(mysql);
+  unsigned long lengths[3]= {-1, -1, -1};
+
+  if (!bulk_enabled)
+    return SKIP;
+
+  if (server_version > 100300 &&
+      server_version < 100305)
+    return SKIP;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk_null");
+  check_mysql_rc(rc,mysql);
+  rc= mysql_query(mysql, "CREATE TABLE bulk_null "
+                         "(s varchar(20), "
+                         " i int, "
+                         " d double, "
+                         " t time, "
+                         " c decimal(3,1))");
+  check_mysql_rc(rc,mysql);
+
+  rc= mysql_stmt_prepare(stmt, "INSERT INTO bulk_null VALUES (?,?,?,?,?)", -1);
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, sizeof(MYSQL_BIND)*2);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ROW_SIZE, &row_size);
+  check_stmt_rc(rc, stmt);
+
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+  bind[0].u.indicator= &val[0].indicator1;
+  bind[0].buffer= &val[0].char_value;
+  bind[0].length= lengths;
+  bind[1].buffer_type= MYSQL_TYPE_LONG;
+  bind[1].buffer= &val[0].int_value;
+  bind[1].u.indicator= &val[0].indicator2;
+  bind[2].buffer_type= MYSQL_TYPE_DOUBLE;
+  bind[2].buffer= &val[0].double_value;
+  bind[2].u.indicator= &val[0].indicator3;
+  bind[3].buffer_type= MYSQL_TYPE_STRING;
+  bind[3].u.indicator= &val[0].indicator4;
+  bind[3].buffer= &val[0].time_value;
+  bind[3].length= lengths;
+  bind[4].buffer_type= MYSQL_TYPE_NEWDECIMAL;
+  bind[4].u.indicator= &val[0].indicator5;
+  bind[4].buffer= &val[0].decimal_value;
+  bind[4].length= lengths;
+
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "SELECT * FROM bulk_null WHERE s='3'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  rc= (int)mysql_num_rows(res);
+  mysql_free_result(res);
+  FAIL_IF(rc != 2, "expected 2 rows");
+
+  rc= mysql_query(mysql, "SELECT * FROM bulk_null WHERE i=3");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  rc= (int)mysql_num_rows(res);
+  mysql_free_result(res);
+  FAIL_IF(rc != 2, "expected 2 rows");
+
+  rc= mysql_query(mysql, "SELECT * FROM bulk_null WHERE d=3.0");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  rc= (int)mysql_num_rows(res);
+  mysql_free_result(res);
+  FAIL_IF(rc != 2, "expected 2 rows");
+
+  rc= mysql_query(mysql, "SELECT * FROM bulk_null WHERE t='00:00:00'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  rc= (int)mysql_num_rows(res);
+  mysql_free_result(res);
+  FAIL_IF(rc != 2, "expected 2 rows");
+
+  rc= mysql_query(mysql, "SELECT * FROM bulk_null WHERE c=3.0");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  rc= (int)mysql_num_rows(res);
+  mysql_free_result(res);
+  FAIL_IF(rc != 2, "expected 2 rows");
+
+  rc= mysql_query(mysql, "DROP TABLE bulk_null");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_mdev16593(MYSQL *mysql)
+{
+  int i;
+  int rc;
+  MYSQL_BIND bind[2];
+  unsigned int array_size= 2;
+  int val_a[2]= {1,2};
+  char indicators[2]= {STMT_INDICATOR_NULL, STMT_INDICATOR_NULL};
+  const char *testcase[]= {"MYSQL_TYPE_LONG", "MYSQL_TYPE_NULL", "STMT_INDICATOR_NULL"};
+
+  diag("waiting for server fix");
+  return SKIP;
+
+  for (i=0; i < 3; i++)
+  {
+    MYSQL_RES *res;
+    MYSQL_ROW row;
+    MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+    rc= mysql_query(mysql, "CREATE OR REPLACE TABLE t1 (a int not null auto_increment primary key, b int)");
+    check_mysql_rc(rc, mysql);
+
+    memset(&bind, 0, sizeof(MYSQL_BIND));
+    switch (i) {
+    case 0:
+      bind[0].buffer_type= MYSQL_TYPE_LONG;
+      break;
+    case 1:
+      bind[0].buffer_type= MYSQL_TYPE_NULL;
+      break;
+    case 2:
+      bind[0].buffer_type= MYSQL_TYPE_LONG;
+      bind[0].u.indicator= indicators;
+      break;
+    }
+    bind[0].buffer= val_a;
+    bind[1].buffer_type= MYSQL_TYPE_LONG;
+    bind[1].buffer= val_a;
+
+    rc= mysql_stmt_prepare(stmt, SL("insert into t1 values(?,?)"));
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_bind_param(stmt, bind);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_query(mysql, "COMMIT");
+    check_mysql_rc(rc, mysql);
+
+    diag("Insert id with buffer_type %s: %lld", 
+        testcase[i],
+        mysql_stmt_insert_id(stmt));
+
+    rc= mysql_query(mysql, "SELECT max(a) FROM t1");
+    check_mysql_rc(rc, mysql);
+
+    res= mysql_store_result(mysql);
+    row= mysql_fetch_row(res);
+    diag("Max value for t1.a=%s", row[0]);
+    mysql_free_result(res);
+
+    mysql_stmt_close(stmt);
+  }
+  return OK;
+}
+
+struct my_tests_st my_tests[] = {
+  {"check_bulk", check_bulk, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_mdev16593", test_mdev16593, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"bulk_null_null", bulk_null_null, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_char_conv1", test_char_conv1, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_char_conv2", test_char_conv2, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_conc243", test_conc243, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"update_no_param", bulk7, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"bulk5", bulk5, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"bulk6", bulk6, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"bulk1", bulk1, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"bulk2", bulk2, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"bulk3", bulk3, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"bulk4", bulk4, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"bulk_null", bulk_null, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"bulk_skip_row", bulk_skip_row, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/charset.c b/libmariadb/unittest/libmariadb/charset.c
new file mode 100644
index 00000000..6424b94f
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/charset.c
@@ -0,0 +1,850 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+#include "my_test.h"
+
+/*
+ test gbk charset escaping
+
+ The important part is that 0x27 (') is the second-byte in a invalid
+ two-byte GBK character here. But 0xbf5c is a valid GBK character, so
+ it needs to be escaped as 0x5cbf27
+
+*/
+#define TEST_BUG8378_IN  "\xef\xbb\xbf\x27\xbf\x10"
+#define TEST_BUG8378_OUT "\xef\xbb\x5c\xbf\x5c\x27\x5c\xbf\x10"
+
+/* set connection options */
+struct my_option_st opt_bug8378[] = {
+  {MYSQL_SET_CHARSET_NAME, (char *) "gbk"},
+  {0, NULL}
+};
+
+int bug_8378(MYSQL *mysql) {
+  int rc, len;
+  char out[9], buf[256];
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+
+  len= mysql_real_escape_string(mysql, out, TEST_BUG8378_IN, 4);
+  FAIL_IF(memcmp(out, TEST_BUG8378_OUT, len), "wrong result");
+
+  sprintf(buf, "SELECT '%s' FROM DUAL", TEST_BUG8378_OUT);
+ 
+  rc= mysql_query(mysql, buf);
+  check_mysql_rc(rc, mysql);
+
+  if ((res= mysql_store_result(mysql))) {
+    row= mysql_fetch_row(res);
+    if (memcmp(row[0], TEST_BUG8378_IN, 4)) {
+      mysql_free_result(res);
+      return FAIL;
+    }
+    mysql_free_result(res);
+  } else
+    return FAIL;
+
+  return OK;
+}
+
+int test_client_character_set(MYSQL *mysql)
+{
+  MY_CHARSET_INFO cs;
+  char *csname= (char*) "utf8";
+  char *csdefault= (char*)mysql_character_set_name(mysql);
+
+  FAIL_IF(mysql_set_character_set(mysql, csname), mysql_error(mysql));
+
+  mysql_get_character_set_info(mysql, &cs);
+
+  FAIL_IF(strcmp(cs.csname, "utf8") || strcmp(cs.name, "utf8_general_ci"), "Character set != UTF8");
+  FAIL_IF(mysql_set_character_set(mysql, csdefault), mysql_error(mysql));
+
+  return OK;
+}
+
+/*
+ * Regression test for bug #10214
+ *
+ * Test escaping with NO_BACKSLASH_ESCAPES
+ *
+ */
+int bug_10214(MYSQL *mysql)
+{
+  int   len, rc;
+  char  out[8];
+
+  /* reset sql_mode */
+  rc= mysql_query(mysql, "SET sql_mode=''");
+  check_mysql_rc(rc, mysql);
+
+  len= mysql_real_escape_string(mysql, out, "a'b\\c", 5);
+  FAIL_IF(memcmp(out, "a\\'b\\\\c", len), "wrong result");
+
+  rc= mysql_query(mysql, "set sql_mode='NO_BACKSLASH_ESCAPES'");
+  check_mysql_rc(rc, mysql);
+  FAIL_IF(!(mysql->server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES), 
+          "wrong server status: NO_BACKSLASH_ESCAPES not set");
+
+  len= mysql_real_escape_string(mysql, out, "a'b\\c", 5);
+  FAIL_IF(memcmp(out, "a''b\\c", len), "wrong result");
+
+  return OK;
+}
+
+/*
+ *  simple escaping of special chars
+ */
+int test_escaping(MYSQL *mysql)
+{
+  int i= 0, rc, len;
+  char out[20];
+  const char *escape_chars[] = {"'", "\x0", "\n", "\r", "\\", "\0", NULL};
+
+  /* reset sql_mode, mysql_change_user call doesn't reset it */
+  rc= mysql_query(mysql, "SET sql_mode=''");
+  check_mysql_rc(rc, mysql);
+
+  while (escape_chars[i]) {
+    len= mysql_real_escape_string(mysql, out, escape_chars[i], 1);
+    FAIL_IF(len < 2, "Len < 2");
+    i++;
+  }
+
+  return OK;
+}
+
+/*
+ * server doesn't reset sql_mode after COM_CHANGE_USER
+ */
+int bug_41785(MYSQL *mysql)
+{
+  char out[10];
+  int rc, len;
+
+  len= mysql_real_escape_string(mysql, out, "\\", 1);
+  FAIL_IF(len != 2, "len != 2");
+
+  rc= mysql_query(mysql, "SET SQL_MODE=NO_BACKSLASH_ESCAPES");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "SET sql_mode=''");
+  check_mysql_rc(rc, mysql);
+
+  mysql_change_user(mysql, "root", "", "test");
+
+  len= mysql_real_escape_string(mysql, out, "\\", 1);
+  FAIL_IF(len != 2, "len != 2");
+
+  return OK;
+}
+
+static int test_conversion(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  const char *stmt_text;
+  int rc;
+  MYSQL_BIND my_bind[1];
+  uchar buff[4];
+  ulong length;
+
+  stmt_text= "DROP TABLE IF EXISTS t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "CREATE TABLE t1 (a TEXT) DEFAULT CHARSET latin1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "SET character_set_connection=utf8, character_set_client=utf8, "
+             " character_set_results=latin1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  stmt_text= "INSERT INTO t1 (a) VALUES (?)";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer= (char*) buff;
+  my_bind[0].length= &length;
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+
+  mysql_stmt_bind_param(stmt, my_bind);
+
+  buff[0]= (uchar) 0xC3;
+  buff[1]= (uchar) 0xA0;
+  length= 2;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  stmt_text= "SELECT a FROM t1";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  my_bind[0].buffer_length= sizeof(buff);
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(length == 1, "length != 1");
+  FAIL_UNLESS(buff[0] == 0xE0, "buff[0] != 0xE0");
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  stmt_text= "DROP TABLE t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "SET NAMES DEFAULT";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug27876(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_RES *result;
+
+  uchar utf8_func[] =
+  {
+    0xd1, 0x84, 0xd1, 0x83, 0xd0, 0xbd, 0xd0, 0xba,
+    0xd1, 0x86, 0xd0, 0xb8, 0xd0, 0xb9, 0xd0, 0xba,
+    0xd0, 0xb0,
+    0x00
+  };
+
+  uchar utf8_param[] =
+  {
+    0xd0, 0xbf, 0xd0, 0xb0, 0xd1, 0x80, 0xd0, 0xb0,
+    0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x82, 0xd1, 0x8a,
+    0xd1, 0x80, 0x5f, 0xd0, 0xb2, 0xd0, 0xb5, 0xd1,
+    0x80, 0xd1, 0x81, 0xd0, 0xb8, 0xd1, 0x8f,
+    0x00
+  };
+
+  char query[500];
+
+  rc= mysql_query(mysql, "set names utf8");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "select version()");
+  check_mysql_rc(rc, mysql);
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+  mysql_free_result(result);
+
+  sprintf(query, "DROP FUNCTION IF EXISTS %s", (char*) utf8_func);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(query,
+          "CREATE FUNCTION %s( %s VARCHAR(25))"
+          " RETURNS VARCHAR(25) DETERMINISTIC RETURN %s",
+          (char*) utf8_func, (char*) utf8_param, (char*) utf8_param);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+  sprintf(query, "SELECT %s(VERSION())", (char*) utf8_func);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+  mysql_free_result(result);
+
+  sprintf(query, "DROP FUNCTION %s", (char*) utf8_func);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "set names default");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_ps_i18n(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *stmt_text;
+  MYSQL_BIND bind_array[2];
+
+  /* Represented as numbers to keep UTF8 tools from clobbering them. */
+  const char *koi8= "\xee\xd5\x2c\x20\xda\xc1\x20\xd2\xd9\xc2\xc1\xcc\xcb\xd5";
+  const char *cp1251= "\xcd\xf3\x2c\x20\xe7\xe0\x20\xf0\xfb\xe1\xe0\xeb\xea\xf3";
+  char buf1[16], buf2[16];
+  ulong buf1_len, buf2_len;
+
+  stmt_text= "DROP TABLE IF EXISTS t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  /*
+    Create table with binary columns, set session character set to cp1251,
+    client character set to koi8, and make sure that there is conversion
+    on insert and no conversion on select
+  */
+
+  stmt_text= "CREATE TABLE t1 (c1 VARBINARY(255), c2 VARBINARY(255))";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "SET CHARACTER_SET_CLIENT=koi8r, "
+                 "CHARACTER_SET_CONNECTION=cp1251, "
+                 "CHARACTER_SET_RESULTS=koi8r";
+
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  memset(bind_array, '\0', sizeof(bind_array));
+  bind_array[0].buffer_type= MYSQL_TYPE_STRING;
+  bind_array[0].buffer= (void *) koi8;
+  bind_array[0].buffer_length= (unsigned long)strlen(koi8);
+
+  bind_array[1].buffer_type= MYSQL_TYPE_STRING;
+  bind_array[1].buffer= (void *) koi8;
+  bind_array[1].buffer_length= (unsigned long)strlen(koi8);
+
+  stmt= mysql_stmt_init(mysql);
+  check_stmt_rc(rc, stmt);
+
+  stmt_text= "INSERT INTO t1 (c1, c2) VALUES (?, ?)";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_bind_param(stmt, bind_array);
+  check_stmt_rc(rc, stmt);
+
+//  mysql_stmt_send_long_data(stmt, 0, koi8, strlen(koi8));
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  stmt_text= "SELECT c1, c2 FROM t1";
+
+  /* c1 and c2 are binary so no conversion will be done on select */
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  bind_array[0].buffer= buf1;
+  bind_array[0].buffer_length= sizeof(buf1);
+  bind_array[0].length= &buf1_len;
+
+  bind_array[1].buffer= buf2;
+  bind_array[1].buffer_length= sizeof(buf2);
+  bind_array[1].length= &buf2_len;
+
+  mysql_stmt_bind_result(stmt, bind_array);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(buf1_len == strlen(cp1251), "buf1_len != strlen(cp1251)");
+  FAIL_UNLESS(buf2_len == strlen(cp1251), "buf2_len != strlen(cp1251)");
+  FAIL_UNLESS(!memcmp(buf1, cp1251, buf1_len), "buf1 != cp1251");
+  FAIL_UNLESS(!memcmp(buf2, cp1251, buf1_len), "buf2 != cp1251");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  stmt_text= "DROP TABLE IF EXISTS t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  /*
+    Now create table with two cp1251 columns, set client character
+    set to koi8 and supply columns of one row as string and another as
+    binary data. Binary data must not be converted on insert, and both
+    columns must be converted to client character set on select.
+  */
+
+  stmt_text= "CREATE TABLE t1 (c1 VARCHAR(255) CHARACTER SET cp1251, "
+                              "c2 VARCHAR(255) CHARACTER SET cp1251)";
+
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "INSERT INTO t1 (c1, c2) VALUES (?, ?)";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  /* this data must be converted */
+  bind_array[0].buffer_type= MYSQL_TYPE_STRING;
+  bind_array[0].buffer= (void *) koi8;
+  bind_array[0].buffer_length= (unsigned long)strlen(koi8);
+
+  bind_array[1].buffer_type= MYSQL_TYPE_STRING;
+  bind_array[1].buffer= (void *) koi8;
+  bind_array[1].buffer_length= (unsigned long)strlen(koi8);
+
+  mysql_stmt_bind_param(stmt, bind_array);
+
+//  mysql_stmt_send_long_data(stmt, 0, koi8, strlen(koi8));
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  /* this data must not be converted */
+  bind_array[0].buffer_type= MYSQL_TYPE_BLOB;
+  bind_array[0].buffer= (void *) cp1251;
+  bind_array[0].buffer_length= (unsigned long)strlen(cp1251);
+
+  bind_array[1].buffer_type= MYSQL_TYPE_BLOB;
+  bind_array[1].buffer= (void *) cp1251;
+  bind_array[1].buffer_length= (unsigned long)strlen(cp1251);
+
+  mysql_stmt_bind_param(stmt, bind_array);
+
+//  mysql_stmt_send_long_data(stmt, 0, cp1251, strlen(cp1251));
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  /* Fetch data and verify that rows are in koi8 */
+
+  stmt_text= "SELECT c1, c2 FROM t1";
+
+  /* c1 and c2 are binary so no conversion will be done on select */
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  bind_array[0].buffer= buf1;
+  bind_array[0].buffer_length= sizeof(buf1);
+  bind_array[0].length= &buf1_len;
+
+  bind_array[1].buffer= buf2;
+  bind_array[1].buffer_length= sizeof(buf2);
+  bind_array[1].length= &buf2_len;
+
+  mysql_stmt_bind_result(stmt, bind_array);
+
+  while ((rc= mysql_stmt_fetch(stmt)) == 0)
+  {
+    FAIL_UNLESS(buf1_len == strlen(koi8), "buf1_len != strlen(koi8)");
+    FAIL_UNLESS(buf2_len == strlen(koi8), "buf2_len != strlen(koi8)");
+    FAIL_UNLESS(!memcmp(buf1, koi8, buf1_len), "buf1 != koi8");
+    FAIL_UNLESS(!memcmp(buf2, koi8, buf1_len), "buf2 != koi8");
+  }
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+  mysql_stmt_close(stmt);
+
+  stmt_text= "DROP TABLE t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "SET NAMES DEFAULT";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/*
+  Bug#30472: libmysql doesn't reset charset, insert_id after succ.
+  mysql_change_user() call row insertions.
+*/
+
+static int bug30472_retrieve_charset_info(MYSQL *con,
+                                           char *character_set_name,
+                                           char *character_set_client,
+                                           char *character_set_results,
+                                           char *collation_connection)
+{
+  MYSQL_RES *rs;
+  MYSQL_ROW row;
+  int       rc;
+
+  /* Get the cached client character set name. */
+
+  strcpy(character_set_name, mysql_character_set_name(con));
+
+  /* Retrieve server character set information. */
+
+  rc= mysql_query(con, "SHOW VARIABLES LIKE 'character_set_client'");
+  check_mysql_rc(rc, con);
+
+  rs= mysql_store_result(con);
+  FAIL_IF(!rs, "Invalid result set");
+  row= mysql_fetch_row(rs);
+  FAIL_IF(!row, "Couldn't fetch row");
+  strcpy(character_set_client, row[1]);
+  mysql_free_result(rs);
+
+  rc= mysql_query(con, "SHOW VARIABLES LIKE 'character_set_results'");
+  check_mysql_rc(rc, con);
+  rs= mysql_store_result(con);
+  FAIL_IF(!rs, "Invalid result set");
+  row= mysql_fetch_row(rs);
+  FAIL_IF(!row, "Couldn't fetch row");
+  strcpy(character_set_results, row[1]);
+  mysql_free_result(rs);
+
+  rc= mysql_query(con, "SHOW VARIABLES LIKE 'collation_connection'");
+  check_mysql_rc(rc, con);
+  rs= mysql_store_result(con);
+  FAIL_IF(!rs, "Invalid result set");
+  row= mysql_fetch_row(rs);
+  FAIL_IF(!row, "Couldn't fetch row");
+  strcpy(collation_connection, row[1]);
+  mysql_free_result(rs);
+  return OK;
+}
+
+#define MY_CS_NAME_SIZE 32
+
+static int test_bug30472(MYSQL *mysql)
+{
+  int   rc;
+
+  char character_set_name_1[MY_CS_NAME_SIZE];
+  char character_set_client_1[MY_CS_NAME_SIZE];
+  char character_set_results_1[MY_CS_NAME_SIZE];
+  char collation_connnection_1[MY_CS_NAME_SIZE];
+
+  char character_set_name_2[MY_CS_NAME_SIZE];
+  char character_set_client_2[MY_CS_NAME_SIZE];
+  char character_set_results_2[MY_CS_NAME_SIZE];
+  char collation_connnection_2[MY_CS_NAME_SIZE];
+
+  char character_set_name_3[MY_CS_NAME_SIZE];
+  char character_set_client_3[MY_CS_NAME_SIZE];
+  char character_set_results_3[MY_CS_NAME_SIZE];
+  char collation_connnection_3[MY_CS_NAME_SIZE];
+
+  char character_set_name_4[MY_CS_NAME_SIZE];
+  char character_set_client_4[MY_CS_NAME_SIZE];
+  char character_set_results_4[MY_CS_NAME_SIZE];
+  char collation_connnection_4[MY_CS_NAME_SIZE];
+
+  SKIP_MAXSCALE;
+
+  if (mysql_get_server_version(mysql) < 50100 || !is_mariadb) 
+  {
+    diag("Test requires MySQL Server version 5.1 or above");
+    return SKIP;
+  }
+  /* Retrieve character set information. */
+
+  mysql_set_character_set(mysql, "latin1");
+  bug30472_retrieve_charset_info(mysql,
+                                 character_set_name_1,
+                                 character_set_client_1,
+                                 character_set_results_1,
+                                 collation_connnection_1);
+
+  /* Switch client character set. */
+
+  FAIL_IF(mysql_set_character_set(mysql, "utf8"), "Setting cs to utf8 failed");
+
+  /* Retrieve character set information. */
+
+  bug30472_retrieve_charset_info(mysql,
+                                 character_set_name_2,
+                                 character_set_client_2,
+                                 character_set_results_2,
+                                 collation_connnection_2);
+
+  /*
+    Check that
+      1) character set has been switched and
+      2) new character set is different from the original one.
+  */
+
+  FAIL_UNLESS(strncmp(character_set_name_2, "utf8", 4) == 0, "cs_name != utf8");
+  FAIL_UNLESS(strncmp(character_set_client_2, "utf8", 4) == 0, "cs_client != utf8");
+  FAIL_UNLESS(strncmp(character_set_results_2, "utf8", 4) == 0, "cs_result != ut8");
+  if (mariadb_connection(mysql) && mysql_get_server_version(mysql) < 100600) {
+    FAIL_UNLESS(strcmp(collation_connnection_2, "utf8_general_ci") == 0, "collation != utf8_general_ci");
+  } else {
+    FAIL_UNLESS(strcmp(collation_connnection_2, "utf8mb3_general_ci") == 0, "collation != utf8_general_ci");
+  }
+
+  diag("%s %s", character_set_name_1, character_set_name_2);
+  FAIL_UNLESS(strcmp(character_set_name_1, character_set_name_2) != 0, "cs_name1 = cs_name2");
+  FAIL_UNLESS(strcmp(character_set_client_1, character_set_client_2) != 0, "cs_client1 = cs_client2");
+  FAIL_UNLESS(strcmp(character_set_results_1, character_set_results_2) != 0, "cs_result1 = cs_result2");
+  FAIL_UNLESS(strcmp(collation_connnection_1, collation_connnection_2) != 0, "collation1 = collation2");
+
+  /* Call mysql_change_user() with the same username, password, database. */
+
+  rc= mysql_change_user(mysql, username, password, (schema) ? schema : "test");
+  mysql_set_character_set(mysql, "latin1");
+  check_mysql_rc(rc, mysql);
+
+  /* Retrieve character set information. */
+
+  bug30472_retrieve_charset_info(mysql,
+                                 character_set_name_3,
+                                 character_set_client_3,
+                                 character_set_results_3,
+                                 collation_connnection_3);
+
+  /* Check that character set information has been reset. */
+
+  FAIL_UNLESS(strcmp(character_set_name_1, character_set_name_3) == 0, "cs_name1 != cs_name3");
+  FAIL_UNLESS(strcmp(character_set_client_1, character_set_client_3) == 0, "cs_client1 != cs_client3");
+  FAIL_UNLESS(strcmp(character_set_results_1, character_set_results_3) == 0, "cs_result1 != cs_result3");
+  FAIL_UNLESS(strcmp(collation_connnection_1, collation_connnection_3) == 0, "collation1 != collation3");
+
+  /* Change connection-default character set in the client. */
+
+  mysql_options(mysql, MYSQL_SET_CHARSET_NAME, "utf8");
+
+  /*
+    Call mysql_change_user() in order to check that new connection will
+    have UTF8 character set on the client and on the server.
+  */
+
+  rc= mysql_change_user(mysql, username, password, (schema) ? schema : "test");
+  check_mysql_rc(rc, mysql);
+
+  /* Retrieve character set information. */
+
+  bug30472_retrieve_charset_info(mysql,
+                                 character_set_name_4,
+                                 character_set_client_4,
+                                 character_set_results_4,
+                                 collation_connnection_4);
+
+  /* Check that we have UTF8 on the server and on the client. */
+  FAIL_UNLESS(strcmp(character_set_name_4, "utf8") == 0, "cs_name != utf8");
+  if (mariadb_connection(mysql) && mysql_get_server_version(mysql) < 100600) {
+    FAIL_UNLESS(strcmp(character_set_client_4, "utf8") == 0, "cs_client != utf8");
+    FAIL_UNLESS(strcmp(character_set_results_4, "utf8") == 0, "cs_result != utf8");
+    FAIL_UNLESS(strcmp(collation_connnection_4, "utf8_general_ci") == 0, "collation_connection != utf8_general_ci");
+  } else {
+    FAIL_UNLESS(strcmp(character_set_client_4, "utf8mb3") == 0, "cs_client != utf8");
+    FAIL_UNLESS(strcmp(character_set_results_4, "utf8mb3") == 0, "cs_result != utf8");
+    FAIL_UNLESS(strcmp(collation_connnection_4, "utf8mb3_general_ci") == 0, "collation_connection != utf8_general_ci");
+  }
+
+  /* That's it. Cleanup. */
+
+  return OK;
+}
+
+static int test_bug_54100(MYSQL *mysql)
+{
+  MYSQL_RES *result;
+  MYSQL_ROW row;
+  int rc;
+
+  rc= mysql_query(mysql, "SHOW CHARACTER SET");
+  check_mysql_rc(rc, mysql);
+  
+  result= mysql_store_result(mysql);
+
+  while ((row= mysql_fetch_row(result)))
+  {
+    /* ignore ucs2 */
+    if (strcmp(row[0], "ucs2")
+        && strcmp(row[0], "utf16le")
+        && (strcmp(row[0], "utf8mb4") && mariadb_connection(mysql) && mysql_get_server_version(mysql) < 100600)
+        && (strcmp(row[0], "utf8") && mariadb_connection(mysql) && mysql_get_server_version(mysql) >= 100600)
+        && strcmp(row[0], "utf16")
+        && strcmp(row[0], "utf32")) {
+      rc= mysql_set_character_set(mysql, row[0]);
+      check_mysql_rc(rc, mysql);
+    }
+  }
+  mysql_free_result(result);
+
+  return OK;
+}
+
+
+/* We need this internal function for the test */
+
+static int test_utf16_utf32_noboms(MYSQL *mysql __attribute__((unused)))
+{
+#ifndef HAVE_ICONV
+  diag("MariaDB Connector/C was built without iconv support");
+  return SKIP;
+#else
+  const char *csname[]= {"utf16", "utf16le", "utf32", "utf8"};
+  MARIADB_CHARSET_INFO  *csinfo[sizeof(csname)/sizeof(char*)];
+
+  const int     UTF8= sizeof(csname)/sizeof(char*) - 1;
+
+  unsigned char in_string[][8]= {"\xd8\x02\xdc\x60\0",      /* utf16(be) */
+                                 "\x02\xd8\x60\xdc\0",      /* utf16le   */
+                                 "\x00\x01\x08\x60\0\0\0",  /* utf32(be) */
+                                 "\xF0\x90\xA1\xA0" };      /* utf8      */
+  size_t       in_oct_len[]= {6, 6, 8, 5};
+
+  char   buffer[8], as_hex[16];
+  int    i, error;
+  size_t rc, in_len, out_len;
+
+  for (i= 0; i < (int)(sizeof(csname)/sizeof(char*)); ++i)
+  {
+    csinfo[i]= mariadb_get_charset_by_name(csname[i]);
+
+    if (csinfo[i] == NULL)
+    {
+      diag("Could not get cs info for %s", csname[i]);
+      return FAIL;
+    }
+  }
+
+  for (i= 0; i < UTF8; ++i)
+  {
+    in_len=  in_oct_len[i];
+    out_len= sizeof(buffer);
+
+    diag("Converting %s->%s", csname[i], csname[UTF8]);
+    rc= mariadb_convert_string((char *)in_string[i], &in_len, csinfo[i], buffer, &out_len, csinfo[UTF8], &error);
+
+    FAIL_IF(rc == (size_t)-1, "Conversion failed");
+    FAIL_IF(rc != in_oct_len[UTF8], "Incorrect number of written bytes");
+
+    if (memcmp(buffer, in_string[UTF8], rc) != 0)
+    {
+      mysql_hex_string(as_hex, buffer, (unsigned long)rc);
+      diag("Converted string(%s) does not match the expected one", as_hex);
+      return FAIL;
+    }
+
+    in_len=  in_oct_len[UTF8];
+    out_len= sizeof(buffer);
+
+    diag("Converting %s->%s", csname[UTF8], csname[i]);
+    rc= mariadb_convert_string((char *)in_string[UTF8], &in_len, csinfo[UTF8], buffer, &out_len, csinfo[i], &error);
+
+    FAIL_IF(rc == (size_t)-1, "Conversion failed");
+    diag("rc=%lu oct_len: %lu", (unsigned long)rc, (unsigned long)in_oct_len[i]);
+    FAIL_IF(rc != in_oct_len[i], "Incorrect number of written bytes");
+
+    if (memcmp(buffer, in_string[i], rc) != 0)
+    {
+      mysql_hex_string(as_hex, buffer, (unsigned long)rc);
+      diag("Converted string(%s) does not match the expected one", as_hex);
+      return FAIL;
+    }
+  }
+
+  return OK;
+#endif
+}
+
+static int charset_auto(MYSQL *my __attribute__((unused)))
+{
+  const char *csname1, *csname2;
+  const char *osname;
+  MYSQL *mysql= mysql_init(NULL);
+  int rc;
+
+  osname= madb_get_os_character_set();
+
+  mysql_options(mysql, MYSQL_SET_CHARSET_NAME, "auto");
+
+  FAIL_IF(!my_test_connect(mysql, hostname, username,
+                             password, schema, port, socketname, 0), 
+         mysql_error(mysql));
+
+  csname1= mysql_character_set_name(mysql);
+  diag("Character set: %s os charset: %s", csname1, osname);
+
+  FAIL_IF(strcmp(osname, csname1), "character set is not os character set");
+
+  if (strcmp(osname, "utf8"))
+  {
+    rc= mysql_set_character_set(mysql, "utf8");
+    check_mysql_rc(rc, mysql);
+
+    csname2= mysql_character_set_name(mysql);
+    diag("Character set: %s", csname2);
+
+    FAIL_IF(!strcmp(csname2, csname1), "Wrong charset: expected utf8");
+
+    rc= mysql_set_character_set(mysql, "auto");
+    check_mysql_rc(rc, mysql);
+
+    csname2= mysql_character_set_name(mysql);
+    diag("Character set: %s", csname2);
+    FAIL_IF(strcmp(csname2, osname), "Wrong charset: expected os charset");
+  }
+  mysql_close(mysql);
+  return OK;
+}
+
+/* check if all server character sets are supported */
+static int test_conc223(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  int found= 0;
+
+  SKIP_MYSQL(mysql);
+
+  rc= mysql_query(mysql, "SELECT ID, CHARACTER_SET_NAME, COLLATION_NAME FROM INFORMATION_SCHEMA.COLLATIONS");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  while ((row = mysql_fetch_row(res)))
+  {
+    int id= atoi(row[0]);
+    if (!mariadb_get_charset_by_nr(id))
+    {
+      diag("%04d %s %s", id, row[1], row[2]);
+      found++;
+    }
+  }
+  mysql_free_result(res);
+  if (found)
+  {
+    diag("%d character sets/collations not found", found);
+    return FAIL;
+  }
+  return OK;
+}
+
+struct my_tests_st my_tests[] = {
+  {"test_conc223", test_conc223, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"charset_auto", charset_auto, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"bug_8378: mysql_real_escape with gbk", bug_8378, TEST_CONNECTION_NEW, 0,  opt_bug8378,  NULL},
+  {"test_client_character_set", test_client_character_set, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"bug_10214: mysql_real_escape with NO_BACKSLASH_ESCAPES", bug_10214, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_escaping", test_escaping, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL}, 
+  {"test_conversion", test_conversion, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"bug_41785", bug_41785, TEST_CONNECTION_DEFAULT, 0,  NULL, "not fixed yet"},
+  {"test_bug27876", test_bug27876, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_bug30472", test_bug30472, TEST_CONNECTION_NEW, 0,  NULL, NULL},
+  {"test_ps_i18n", test_ps_i18n, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_bug_54100", test_bug_54100, TEST_CONNECTION_NEW, 0, NULL, NULL}, 
+  {"test_utf16_utf32_noboms", test_utf16_utf32_noboms, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {NULL, NULL, 0, 0, NULL, 0}
+};
+
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+   get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/conc336.c b/libmariadb/unittest/libmariadb/conc336.c
new file mode 100644
index 00000000..e382f471
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/conc336.c
@@ -0,0 +1,53 @@
+#include "my_test.h"
+
+#define MAX_COUNT 2000
+
+int main(int argc, char *argv[]) {
+
+	MYSQL *mysql;
+	int i;
+
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  if (IS_SKYSQL(hostname))
+    return 0;
+
+  diag("hostname: %s", hostname);
+
+	for (i = 0; i < MAX_COUNT; ++i) {
+
+		if (mysql_library_init(-1, NULL, NULL) != 0) {
+			diag("mysql_library_init failed");
+			return 1;
+		}
+
+		mysql = mysql_init(NULL);
+		if (!mysql) {
+			diag("mysql_init failed");
+			return 1;
+		}
+
+    if (force_tls)
+      mysql_options(mysql, MYSQL_OPT_SSL_ENFORCE, &force_tls);
+
+		if (!mysql_real_connect(mysql, hostname, username, password, schema, port, socketname, 0)) {
+			diag("mysql_real_connect failed: %s", mysql_error(mysql));
+			return 1;
+		}
+
+		if (mysql_query(mysql, "SELECT NULL LIMIT 0") != 0) {
+			diag("mysql_query failed: %s", mysql_error(mysql));
+			return 1;
+		}
+
+		mysql_close(mysql);
+		mysql_library_end();
+
+	}
+
+	return 0;
+
+}
diff --git a/libmariadb/unittest/libmariadb/connection.c b/libmariadb/unittest/libmariadb/connection.c
new file mode 100644
index 00000000..f05dff12
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/connection.c
@@ -0,0 +1,1976 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+/**
+  Some basic tests of the client API.
+*/
+
+#include "my_test.h"
+
+static int test_conc66(MYSQL *my)
+{
+  MYSQL *mysql= mysql_init(NULL);
+  int rc;
+  FILE *fp;
+  char query[1024];
+
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  if (!is_mariadb)
+    return SKIP;
+
+  if (!(fp= fopen("./my-conc66-test.cnf", "w")))
+    return FAIL;
+
+  fprintf(fp, "[notmygroup]\n");
+  fprintf(fp, "user=foo\n");
+  fprintf(fp, "[conc-66]\n");
+  fprintf(fp, "user=conc66\n");
+  fprintf(fp, "port=3306\n");
+  fprintf(fp, "enable-local-infile\n");
+  fprintf(fp, "password='test@A1\\\";#test'\n");
+
+  fclose(fp);
+
+  rc= mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "conc-66");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_options(mysql, MYSQL_READ_DEFAULT_FILE, "./my-conc66-test.cnf");
+  check_mysql_rc(rc, mysql);
+
+  sprintf(query, "GRANT ALL ON %s.* TO 'conc66'@'%s' IDENTIFIED BY 'test@A1\";#test'", schema, this_host ? this_host : "localhost");
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, my);
+  rc= mysql_query(my, "FLUSH PRIVILEGES");
+  check_mysql_rc(rc, my);
+  if (!my_test_connect(mysql, hostname, NULL,
+                             NULL, schema, port, socketname, 0))
+  {
+    diag("user: %s", mysql->options.user);
+    diag("Error: %s", mysql_error(mysql));
+    return FAIL;
+  }
+    diag("user: %s", mysql->options.user);
+  
+  sprintf(query, "DROP user 'conc66'@'%s'", this_host ? this_host : "localhost");
+  rc= mysql_query(my, query);
+
+  check_mysql_rc(rc, my);
+  mysql_close(mysql);
+  return OK; 
+}
+
+static int test_bug20023(MYSQL *mysql)
+{
+  int sql_big_selects_orig;
+  int max_join_size_orig;
+
+  int sql_big_selects_2;
+  int sql_big_selects_3;
+  int sql_big_selects_4;
+  int sql_big_selects_5;
+  int rc;
+
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  if (!is_mariadb)
+    return SKIP;
+
+  if (mysql_get_server_version(mysql) < 50100) {
+    diag("Test requires MySQL Server version 5.1 or above");
+    return SKIP;
+  }
+
+  /***********************************************************************
+    Remember original SQL_BIG_SELECTS, MAX_JOIN_SIZE values.
+  ***********************************************************************/
+
+  query_int_variable(mysql,
+                     "@@session.sql_big_selects",
+                     &sql_big_selects_orig);
+
+  query_int_variable(mysql,
+                     "@@global.max_join_size",
+                     &max_join_size_orig);
+
+  /***********************************************************************
+    Test that COM_CHANGE_USER resets the SQL_BIG_SELECTS to the initial value.
+  ***********************************************************************/
+
+  /* Issue COM_CHANGE_USER. */
+  rc= mysql_change_user(mysql, username, password, schema);
+  check_mysql_rc(rc, mysql);
+
+  /* Query SQL_BIG_SELECTS. */
+
+  query_int_variable(mysql,
+                     "@@session.sql_big_selects",
+                     &sql_big_selects_2);
+
+  /* Check that SQL_BIG_SELECTS is reset properly. */
+
+  FAIL_UNLESS(sql_big_selects_orig == sql_big_selects_2, "Different value for sql_big_select");
+
+  /***********************************************************************
+    Test that if MAX_JOIN_SIZE set to non-default value,
+    SQL_BIG_SELECTS will be 0.
+  ***********************************************************************/
+
+  /* Set MAX_JOIN_SIZE to some non-default value. */
+
+  rc= mysql_query(mysql, "SET @@global.max_join_size = 10000");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "SET @@session.max_join_size = default");
+  check_mysql_rc(rc, mysql);
+
+  /* Issue COM_CHANGE_USER. */
+
+  rc= mysql_change_user(mysql, username, password, schema);
+  check_mysql_rc(rc, mysql);
+
+  /* Query SQL_BIG_SELECTS. */
+
+  query_int_variable(mysql,
+                     "@@session.sql_big_selects",
+                     &sql_big_selects_3);
+
+  /* Check that SQL_BIG_SELECTS is 0. */
+
+  FAIL_UNLESS(sql_big_selects_3 == 0, "big_selects != 0");
+
+  /***********************************************************************
+    Test that if MAX_JOIN_SIZE set to default value,
+    SQL_BIG_SELECTS will be 1.
+  ***********************************************************************/
+
+  /* Set MAX_JOIN_SIZE to the default value (-1). */
+
+  rc= mysql_query(mysql, "SET @@global.max_join_size = cast(-1 as unsigned int)");
+  rc= mysql_query(mysql, "SET @@session.max_join_size = default");
+
+  /* Issue COM_CHANGE_USER. */
+
+  rc= mysql_change_user(mysql, username, password, schema);
+  check_mysql_rc(rc, mysql);
+
+  /* Query SQL_BIG_SELECTS. */
+
+  query_int_variable(mysql,
+                     "@@session.sql_big_selects",
+                     &sql_big_selects_4);
+
+  /* Check that SQL_BIG_SELECTS is 1. */
+
+  FAIL_UNLESS(sql_big_selects_4 == 1, "sql_big_select != 1");
+
+  /***********************************************************************
+    Restore MAX_JOIN_SIZE.
+    Check that SQL_BIG_SELECTS will be the original one.
+  ***********************************************************************/
+
+  rc= mysql_query(mysql, "SET @@global.max_join_size = cast(-1 as unsigned int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SET @@session.max_join_size = default");
+  check_mysql_rc(rc, mysql);
+
+  /* Issue COM_CHANGE_USER. */
+
+  rc= mysql_change_user(mysql, username, password, schema);
+  check_mysql_rc(rc, mysql);
+
+  /* Query SQL_BIG_SELECTS. */
+
+  query_int_variable(mysql,
+                     "@@session.sql_big_selects",
+                     &sql_big_selects_5);
+
+  /* Check that SQL_BIG_SELECTS is 1. */
+
+  FAIL_UNLESS(sql_big_selects_5 == sql_big_selects_orig, "big_select != 1");
+
+  /***********************************************************************
+    That's it. Cleanup.
+  ***********************************************************************/
+
+  return OK;
+}
+
+static int test_change_user(MYSQL *mysql)
+{
+  char buff[256];
+  const char *user_pw= "mysqltest_pw";
+  const char *user_no_pw= "mysqltest_no_pw";
+  const char *pw= "password";
+  const char *db= "mysqltest_user_test_database";
+  int rc;
+
+  diag("Due to mysql_change_user security fix this test will not work anymore.");
+  return(SKIP);
+
+  /* Prepare environment */
+  sprintf(buff, "drop database if exists %s", db);
+  rc= mysql_query(mysql, buff);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(buff, "create database %s", db);
+  rc= mysql_query(mysql, buff);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(buff,
+          "grant select on %s.* to %s@'%%' identified by '%s'",
+          db,
+          user_pw,
+          pw);
+  rc= mysql_query(mysql, buff);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(buff,
+          "grant select on %s.* to %s@'%%'",
+          db,
+          user_no_pw);
+  rc= mysql_query(mysql, buff);
+  check_mysql_rc(rc, mysql);
+
+
+  /* Try some combinations */
+  rc= mysql_change_user(mysql, NULL, NULL, NULL);
+  FAIL_UNLESS(rc, "Error expected");
+
+
+  rc= mysql_change_user(mysql, "", NULL, NULL);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, "", "", NULL);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, "", "", "");
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, NULL, "", "");
+  FAIL_UNLESS(rc, "Error expected");
+
+
+  rc= mysql_change_user(mysql, NULL, NULL, "");
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, "", NULL, "");
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user_pw, NULL, "");
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user_pw, "", "");
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user_pw, "", NULL);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user_pw, NULL, NULL);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user_pw, "", db);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user_pw, NULL, db);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user_pw, pw, db);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_change_user(mysql, user_pw, pw, NULL);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_change_user(mysql, user_pw, pw, "");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_change_user(mysql, user_no_pw, pw, db);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user_no_pw, pw, "");
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user_no_pw, pw, NULL);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user_no_pw, "", NULL);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_change_user(mysql, user_no_pw, "", "");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_change_user(mysql, user_no_pw, "", db);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_change_user(mysql, user_no_pw, NULL, db);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_change_user(mysql, "", pw, db);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, "", pw, "");
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, "", pw, NULL);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, NULL, pw, NULL);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, NULL, NULL, db);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, NULL, "", db);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, "", "", db);
+  FAIL_UNLESS(rc, "Error expected");
+
+  /* Cleanup the environment */
+
+  rc= mysql_change_user(mysql, username, password, schema);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(buff, "drop database %s", db);
+  rc= mysql_query(mysql, buff);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(buff, "drop user %s@'%%'", user_pw);
+  rc= mysql_query(mysql, buff);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(buff, "drop user %s@'%%'", user_no_pw);
+  rc= mysql_query(mysql, buff);
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/**
+  Bug#31669 Buffer overflow in mysql_change_user()
+*/
+
+#define LARGE_BUFFER_SIZE 2048
+
+static int test_bug31669(MYSQL *mysql)
+{
+  int rc;
+  static char buff[LARGE_BUFFER_SIZE+1];
+  static char user[USERNAME_CHAR_LENGTH+1];
+  static char db[NAME_CHAR_LEN+1];
+  static char query[LARGE_BUFFER_SIZE*2];
+
+  diag("Due to mysql_change_user security fix this test will not work anymore.");
+  return(SKIP);
+
+  rc= mysql_change_user(mysql, NULL, NULL, NULL);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc= mysql_change_user(mysql, "", "", "");
+  FAIL_UNLESS(rc, "Error expected");
+
+  memset(buff, 'a', sizeof(buff));
+
+  rc= mysql_change_user(mysql, buff, buff, buff);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc = mysql_change_user(mysql, username, password, schema);
+  check_mysql_rc(rc, mysql);
+
+  memset(db, 'a', sizeof(db));
+  db[NAME_CHAR_LEN]= 0;
+  sprintf(query, "CREATE DATABASE IF NOT EXISTS %s", db);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  memset(user, 'b', sizeof(user));
+  user[USERNAME_CHAR_LENGTH]= 0;
+  memset(buff, 'c', sizeof(buff));
+  buff[LARGE_BUFFER_SIZE]= 0;
+  sprintf(query, "GRANT ALL PRIVILEGES ON *.* TO '%s'@'%%' IDENTIFIED BY '%s' WITH GRANT OPTION", user, buff);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "FLUSH PRIVILEGES");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_change_user(mysql, user, buff, db);
+  check_mysql_rc(rc, mysql);
+
+  user[USERNAME_CHAR_LENGTH-1]= 'a';
+  rc= mysql_change_user(mysql, user, buff, db);
+  FAIL_UNLESS(rc, "Error expected");
+
+  user[USERNAME_CHAR_LENGTH-1]= 'b';
+  buff[LARGE_BUFFER_SIZE-1]= 'd';
+  rc= mysql_change_user(mysql, user, buff, db);
+  FAIL_UNLESS(rc, "Error expected");
+
+  buff[LARGE_BUFFER_SIZE-1]= 'c';
+  db[NAME_CHAR_LEN-1]= 'e';
+  rc= mysql_change_user(mysql, user, buff, db);
+  FAIL_UNLESS(rc, "Error expected");
+
+  db[NAME_CHAR_LEN-1]= 'a';
+  rc= mysql_change_user(mysql, user, buff, db);
+  FAIL_UNLESS(!rc, "Error expected");
+
+  rc= mysql_change_user(mysql, user + 1, buff + 1, db + 1);
+  FAIL_UNLESS(rc, "Error expected");
+
+  rc = mysql_change_user(mysql, username, password, schema);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(query, "DROP DATABASE %s", db);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(query, "DELETE FROM mysql.user WHERE User='%s'", user);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+  FAIL_UNLESS(mysql_affected_rows(mysql) == 1, "");
+
+  return OK;
+}
+
+/**
+     Bug# 33831 my_test_connect() should fail if
+     given an already connected MYSQL handle.
+*/
+
+static int test_bug33831(MYSQL *mysql)
+{
+  FAIL_IF(my_test_connect(mysql, hostname, username,
+                             password, schema, port, socketname, 0), 
+         "Error expected");
+  
+  return OK;
+}
+
+/* Test MYSQL_OPT_RECONNECT, Bug#15719 */
+
+static int test_opt_reconnect(MYSQL *mysql)
+{
+  my_bool my_true= TRUE;
+  int rc;
+  my_bool reconnect;
+
+  printf("true: %d\n", TRUE);
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "not enough memory");
+
+  mysql_get_option(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_UNLESS(reconnect == 0, "reconnect != 0");
+
+  rc= mysql_options(mysql, MYSQL_OPT_RECONNECT, &my_true);
+  check_mysql_rc(rc, mysql);
+
+  mysql_get_option(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_UNLESS(reconnect == 1, "reconnect != 1");
+
+  if (!(my_test_connect(mysql, hostname, username,
+                           password, schema, port,
+                           socketname, 0)))
+  {
+    diag("connection failed");
+    mysql_close(mysql);
+    return FAIL;
+  }
+
+  mysql_get_option(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_UNLESS(reconnect == 1, "reconnect != 1");
+
+  mysql_close(mysql);
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "not enough memory");
+
+  mysql_get_option(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_UNLESS(reconnect == 0, "reconnect != 0");
+
+  if (!(my_test_connect(mysql, hostname, username,
+                           password, schema, port,
+                           socketname, 0)))
+  {
+    diag("connection failed");
+    mysql_close(mysql);
+    return FAIL;
+  }
+
+  mysql_get_option(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_UNLESS(reconnect == 0, "reconnect != 0");
+
+  mysql_close(mysql);
+  return OK;
+}
+
+
+static int test_compress(MYSQL *mysql)
+{
+  // maxscale doesn't support compression
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  int rc;
+  SKIP_MAXSCALE;
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "not enough memory");
+
+  /* use compressed protocol */
+  rc= mysql_options(mysql, MYSQL_OPT_COMPRESS, NULL);
+
+
+
+  if (!(my_test_connect(mysql, hostname, username,
+                           password, schema, port,
+                           socketname, 0)))
+  {
+    diag("connection failed");
+    return FAIL;
+  }
+
+  rc= mysql_query(mysql, "SHOW STATUS LIKE 'compression'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+  FAIL_UNLESS(strcmp(row[1], "ON") == 0, "Compression off");
+  mysql_free_result(res);
+
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_reconnect(MYSQL *mysql)
+{
+  my_bool my_true= TRUE;
+  MYSQL *mysql1;
+  int rc;
+  my_bool reconnect;
+  SKIP_MAXSCALE;
+
+  mysql1= mysql_init(NULL);
+  FAIL_IF(!mysql1, "not enough memory");
+
+  mysql_get_option(mysql1, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_UNLESS(reconnect == 0, "reconnect != 0");
+
+  rc= mysql_options(mysql1, MYSQL_OPT_RECONNECT, &my_true);
+  check_mysql_rc(rc, mysql1);
+
+  mysql_get_option(mysql1, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_UNLESS(reconnect == 1, "reconnect != 1");
+
+  if (!(my_test_connect(mysql1, hostname, username,
+                           password, schema, port,
+                           socketname, 0)))
+  {
+    diag("connection failed");
+    return FAIL;
+  }
+
+  mysql_get_option(mysql1, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_UNLESS(reconnect == 1, "reconnect != 1");
+
+  diag("Thread_id before kill: %lu", mysql_thread_id(mysql1));
+  mysql_kill(mysql, mysql_thread_id(mysql1));
+
+  mysql_ping(mysql1);
+
+  rc= mysql_query(mysql1, "SELECT 1 FROM DUAL LIMIT 0");
+  check_mysql_rc(rc, mysql1);
+  diag("Thread_id after kill: %lu", mysql_thread_id(mysql1));
+
+  mysql_get_option(mysql1, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_UNLESS(reconnect == 1, "reconnect != 1");
+  mysql_close(mysql1);
+  return OK;
+}
+
+int test_conc21(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_RES *res= NULL;
+  MYSQL_ROW row;
+  char tmp[256];
+  unsigned int check_server_version= 0;
+  int major=0, minor= 0, patch=0;
+  SKIP_MAXSCALE;
+
+  rc= mysql_query(mysql, "SELECT @@version");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  FAIL_IF(res == NULL, "invalid result set");
+
+  row= mysql_fetch_row(res);
+  strcpy(tmp, row[0]);
+  mysql_free_result(res);
+  
+  sscanf(tmp, "%d.%d.%d", &major, &minor, &patch);
+
+  check_server_version= major * 10000 + minor * 100 + patch;
+
+  FAIL_IF(mysql_get_server_version(mysql) != check_server_version, "Numeric server version mismatch");
+  FAIL_IF(strcmp(mysql_get_server_info(mysql), tmp) != 0, "String server version mismatch");
+  return OK;
+}
+
+int test_conc26(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_SET_CHARSET_NAME, "utf8");
+
+  FAIL_IF(my_test_connect(mysql, hostname, "notexistinguser", "password", schema, port, NULL, CLIENT_REMEMBER_OPTIONS), 
+          "Error expected");
+
+  FAIL_IF(!mysql->options.charset_name || strcmp(mysql->options.charset_name, "utf8") != 0, 
+          "expected charsetname=utf8");
+  mysql_close(mysql);
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(my_test_connect(mysql, hostname, "notexistinguser", "password", schema, port, NULL, 0), 
+          "Error expected");
+  FAIL_IF(mysql->options.charset_name, "Error: options not freed");
+  mysql_close(mysql);
+
+  return OK;
+}
+
+int test_connection_timeout(MYSQL *unused __attribute__((unused)))
+{
+  unsigned int timeout= 5;
+  time_t start, elapsed;
+  MYSQL *mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (unsigned int *)&timeout);
+  start= time(NULL);
+  if (my_test_connect(mysql, "192.168.1.101", "notexistinguser", "password", schema, port, NULL, CLIENT_REMEMBER_OPTIONS))
+  {
+    diag("Error expected - maybe you have to change hostname");
+    return FAIL;
+  }
+  elapsed= time(NULL) - start;
+  diag("elapsed: %lu", (unsigned long)elapsed);
+  mysql_close(mysql);
+  FAIL_IF((unsigned int)elapsed > 2 * timeout, "timeout ignored");
+  return OK;
+}
+
+int test_connection_timeout2(MYSQL *unused __attribute__((unused)))
+{
+  unsigned int timeout= 5;
+  time_t start, elapsed;
+  MYSQL *mysql;
+
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (unsigned int *)&timeout);
+  mysql_options(mysql, MYSQL_INIT_COMMAND, "set @a:=SLEEP(6)");
+  start= time(NULL);
+  if (my_test_connect(mysql, hostname, username, password, schema, port, NULL, CLIENT_REMEMBER_OPTIONS))
+  {
+    diag("timeout error expected");
+    return FAIL;
+  }
+  elapsed= time(NULL) - start;
+  diag("elapsed: %lu", (unsigned long)elapsed);
+  mysql_close(mysql);
+  FAIL_IF((unsigned int)elapsed > 2 * timeout, "timeout ignored");
+  return OK;
+}
+
+int test_connection_timeout3(MYSQL *unused __attribute__((unused)))
+{
+  unsigned int timeout= 5;
+  unsigned int read_write_timeout= 10;
+  int rc;
+  time_t start, elapsed;
+  MYSQL *mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (unsigned int *)&timeout);
+  mysql_options(mysql, MYSQL_OPT_READ_TIMEOUT, (unsigned int *)&read_write_timeout);
+  mysql_options(mysql, MYSQL_OPT_WRITE_TIMEOUT, (unsigned int *)&read_write_timeout);
+  mysql_options(mysql, MYSQL_INIT_COMMAND, "set @a:=SLEEP(6)");
+  start= time(NULL);
+  if (my_test_connect(mysql, hostname, username, password, schema, port, socketname, CLIENT_REMEMBER_OPTIONS))
+  {
+    diag("timeout error expected");
+    elapsed= time(NULL) - start;
+    diag("elapsed: %lu", (unsigned long)elapsed);
+    return FAIL;
+  }
+  elapsed= time(NULL) - start;
+  diag("elapsed: %lu", (unsigned long)elapsed);
+  FAIL_IF((unsigned int)elapsed > timeout + 1, "timeout ignored");
+
+  mysql_close(mysql);
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (unsigned int *)&timeout);
+  mysql_options(mysql, MYSQL_OPT_READ_TIMEOUT, (unsigned int *)&read_write_timeout);
+  mysql_options(mysql, MYSQL_OPT_WRITE_TIMEOUT, (unsigned int *)&read_write_timeout);
+
+  if (!my_test_connect(mysql, hostname, username, password, schema, port, socketname, CLIENT_REMEMBER_OPTIONS))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    return FAIL;
+  }
+
+  start= time(NULL);
+  rc= mysql_query(mysql, "SET @a:=SLEEP(12)");
+  elapsed= time(NULL) - start;
+  diag("elapsed: %lu", (unsigned long)elapsed);
+  FAIL_IF(!rc, "timeout expected");
+  mysql_close(mysql);
+  return OK;
+}
+
+
+/* test should run with valgrind */
+static int test_conc118(MYSQL *mysql)
+{
+  int rc;
+  my_bool reconnect= 1;
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+
+  mysql->options.unused_1= 1;
+
+  rc= mysql_kill(mysql, mysql_thread_id(mysql));
+
+  mysql_ping(mysql);
+
+  rc= mysql_query(mysql, "SET @a:=1");
+  check_mysql_rc(rc, mysql);
+
+  FAIL_IF(mysql->options.unused_1 != 1, "options got lost");
+
+  rc= mysql_kill(mysql, mysql_thread_id(mysql));
+
+  mysql_ping(mysql);
+  rc= mysql_query(mysql, "SET @a:=1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_wrong_bind_address(MYSQL *unused __attribute__((unused)))
+{
+  const char *bind_addr= "100.188.111.112";
+  MYSQL *mysql;
+
+  if (!hostname || !strcmp(hostname, "localhost"))
+  {
+    diag("test doesn't work with unix sockets");
+    return SKIP;
+  }
+ 
+  mysql=  mysql_init(NULL);
+
+  mysql_options(mysql, MYSQL_OPT_BIND, bind_addr);
+  if (my_test_connect(mysql, hostname, username,
+                             password, schema, port, socketname, 0))
+  {
+    diag("Error expected");
+    mysql_close(mysql);
+    return FAIL;
+  }
+  diag("Error: %s", mysql_error(mysql));
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_bind_address(MYSQL *my)
+{
+  MYSQL *mysql;
+  char *bind_addr= getenv("MYSQL_TEST_BINDADDR");
+  char query[128];
+  int rc;
+
+  SKIP_SKYSQL;
+
+  if (!hostname || !strcmp(hostname, "localhost"))
+  {
+    diag("test doesn't work with unix sockets");
+    return SKIP;
+  }
+
+  sprintf(query, "DROP USER '%s'@'%s'", username, bind_addr);
+  rc= mysql_query(my, query);
+
+  sprintf(query, "CREATE USER '%s'@'%s' IDENTIFIED BY '%s'", username, bind_addr, password);
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, my);
+
+  sprintf(query, "GRANT ALL ON %s.* TO '%s'@'%s'", schema, username, bind_addr);
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, my);
+
+  if (!bind_addr)
+  {
+    diag("No bind address specified");
+    return SKIP;
+  }
+
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_OPT_BIND, bind_addr);
+
+  if (!my_test_connect(mysql, bind_addr, username,
+                             password, schema, port, socketname, 0))
+  {
+    diag("Error: %s\n", mysql_error(mysql));
+    mysql_close(mysql);
+    return FAIL;
+  }
+  diag("%s", mysql_get_host_info(mysql));
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_get_options(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql= mysql_init(NULL);
+  int options_int[]= {MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_LOCAL_INFILE,
+                      MYSQL_OPT_PROTOCOL, MYSQL_OPT_READ_TIMEOUT, MYSQL_OPT_WRITE_TIMEOUT, 0};
+  my_bool options_bool[]= {MYSQL_OPT_RECONNECT, MYSQL_REPORT_DATA_TRUNCATION,
+                           MYSQL_OPT_COMPRESS, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, MYSQL_SECURE_AUTH,
+#ifdef _WIN32    
+    MYSQL_OPT_NAMED_PIPE,
+#endif
+                          0};
+  int options_char[]= {MYSQL_READ_DEFAULT_FILE, MYSQL_READ_DEFAULT_GROUP, MYSQL_SET_CHARSET_NAME,
+                       MYSQL_OPT_SSL_KEY, MYSQL_OPT_SSL_CA, MYSQL_OPT_SSL_CERT, MYSQL_OPT_SSL_CAPATH,
+                       MYSQL_OPT_SSL_CIPHER, MYSQL_OPT_BIND, MARIADB_OPT_SSL_FP, MARIADB_OPT_SSL_FP_LIST,
+                       MARIADB_OPT_TLS_PASSPHRASE, 0};
+
+  const char *init_command[3]= {"SET @a:=1", "SET @b:=2", "SET @c:=3"};
+  int elements= 0;
+  char **command;
+
+
+  int intval[2]= {1, 0};
+  my_bool boolval[2]= {1, 0};
+  const char *char1= "test";
+  char *char2;
+  int i;
+  MYSQL *userdata;
+  const char *attr_key[] = {"foo1", "foo2", "foo3"};
+  const char *attr_val[] = {"bar1", "bar2", "bar3"};
+  char **key, **val;
+
+  for (i=0; options_int[i]; i++)
+  {
+    mysql_options(mysql, options_int[i], &intval[0]);
+    intval[1]= 0;
+    mysql_get_optionv(mysql, options_int[i], &intval[1]);
+    FAIL_IF(intval[0] != intval[1], "mysql_get_optionv (int) failed");
+  }
+  for (i=0; options_bool[i]; i++)
+  {
+    mysql_options(mysql, options_bool[i], &boolval[0]);
+    intval[1]= 0;
+    mysql_get_optionv(mysql, options_bool[i], &boolval[1]);
+    FAIL_IF(boolval[0] != boolval[1], "mysql_get_optionv (my_bool) failed");
+  }
+  for (i=0; options_char[i]; i++)
+  {
+    mysql_options(mysql, options_char[i], char1);
+    char2= NULL;
+    mysql_get_optionv(mysql, options_char[i], (void *)&char2);
+    if (options_char[i] != MYSQL_SET_CHARSET_NAME) 
+      FAIL_IF(strcmp(char1, char2), "mysql_get_optionv (char) failed");
+  }
+
+  for (i=0; i < 3; i++)
+    mysql_options(mysql, MYSQL_INIT_COMMAND, init_command[i]);
+
+  mysql_get_optionv(mysql, MYSQL_INIT_COMMAND, &command, &elements);
+  FAIL_IF(elements != 3, "expected 3 elements");
+  for (i=0; i < 3; i++)
+    FAIL_IF(strcmp(init_command[i], command[i]), "wrong init command");
+  for (i=0; i < 3; i++)
+    mysql_optionsv(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, attr_key[i], attr_val[i]);
+
+  mysql_get_optionv(mysql, MYSQL_OPT_CONNECT_ATTRS, NULL, NULL, &elements);
+  FAIL_IF(elements != 3, "expected 3 connection attributes");
+
+  key= (char **)malloc(sizeof(char *) * elements);
+  val= (char **)malloc(sizeof(char *) * elements);
+
+  mysql_get_optionv(mysql, MYSQL_OPT_CONNECT_ATTRS, &key, &val, &elements);
+  for (i=0; i < elements; i++)
+  {
+    diag("%s => %s", key[i], val[i]);
+  }
+
+  free(key);
+  free(val);
+
+  mysql_optionsv(mysql, MARIADB_OPT_USERDATA, "my_app", (void *)mysql);
+  mysql_get_optionv(mysql, MARIADB_OPT_USERDATA, (char *)"my_app", &userdata);
+
+  FAIL_IF(mysql != userdata, "wrong userdata");
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_sess_track_db(MYSQL *mysql)
+{
+  int rc;
+  const char *data;
+  size_t len;
+  char tmp_str[512];
+
+
+  if (!(mysql->server_capabilities & CLIENT_SESSION_TRACKING))
+  {
+    diag("Server doesn't support session tracking (cap=%lu)", mysql->server_capabilities);
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "USE mysql");
+  check_mysql_rc(rc, mysql);
+  FAIL_IF(strcmp(mysql->db, "mysql"), "Expected new schema 'mysql'");
+
+  FAIL_IF(mysql_session_track_get_first(mysql, SESSION_TRACK_SCHEMA, &data, &len),
+          "session_track_get_first failed");
+  FAIL_IF(strncmp(data, "mysql", len), "Expected new schema 'mysql'");
+
+  sprintf(tmp_str, "USE %s", schema);
+  rc= mysql_query(mysql, tmp_str);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(tmp_str, "Expected new schema '%s'.", schema);
+
+  FAIL_IF(strcmp(mysql->db, schema), tmp_str);
+
+  FAIL_IF(mysql_session_track_get_first(mysql, SESSION_TRACK_SCHEMA, &data, &len),
+          "session_track_get_first failed");
+  FAIL_IF(strncmp(data, schema, len), tmp_str);
+
+  if (mysql_get_server_version(mysql) >= 100300)
+  {
+    diag("charset: %s", mysql->charset->csname);
+    rc= mysql_query(mysql, "SET NAMES utf8");
+    check_mysql_rc(rc, mysql);
+    if (!mysql_session_track_get_first(mysql, SESSION_TRACK_SYSTEM_VARIABLES, &data, &len))
+    do {
+      printf("# SESSION_TRACK_VARIABLES: %*.*s\n", (int)len, (int)len, data);
+    } while (!mysql_session_track_get_next(mysql, SESSION_TRACK_SYSTEM_VARIABLES, &data, &len));
+
+    diag("charset: %s", mysql->charset->csname);
+    if (mariadb_connection(mysql) && mysql_get_server_version(mysql) >= 100600) {
+      diag("skipping since utf8mb3 isn't handled in 3.1");
+      return SKIP;
+    }
+
+    FAIL_IF(strcmp(mysql->charset->csname, "utf8"), "Expected charset 'utf8'");
+    rc= mysql_query(mysql, "SET NAMES latin1");
+    check_mysql_rc(rc, mysql);
+    FAIL_IF(strcmp(mysql->charset->csname, "latin1"), "Expected charset 'latin1'");
+  }
+  rc= mysql_query(mysql, "CREATE PROCEDURE p1() "
+                         "BEGIN "
+                         "SET @@autocommit=0; "
+                         "SET NAMES utf8; "
+                         "SET session auto_increment_increment=2; "
+                         "END ");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CALL p1()");
+  check_mysql_rc(rc, mysql);
+
+  if (!mysql_session_track_get_first(mysql, SESSION_TRACK_SYSTEM_VARIABLES, &data, &len))
+  do {
+    printf("# SESSION_TRACK_VARIABLES: %*.*s\n", (int)len, (int)len, data);
+  } while (!mysql_session_track_get_next(mysql, SESSION_TRACK_SYSTEM_VARIABLES, &data, &len));
+
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_conc496(MYSQL *mysql)
+{
+  int rc;
+  const char *data;
+  size_t len;
+
+  rc= mysql_query(mysql, "set @@session.session_track_transaction_info=STATE");
+
+  if (rc && mysql_errno(mysql) == ER_UNKNOWN_SYSTEM_VARIABLE)
+  {
+    diag("session_track_transaction_info not supported");
+    return SKIP;
+  }
+
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "BEGIN");
+  check_mysql_rc(rc, mysql);
+  if (!mysql_session_track_get_first(mysql, SESSION_TRACK_TRANSACTION_STATE, &data, &len))
+  do {
+    FAIL_IF(len != 8, "expected 8 bytes");
+    FAIL_IF(data[0] != 'T', "expected transaction");
+  } while (!mysql_session_track_get_next(mysql, SESSION_TRACK_TRANSACTION_STATE, &data, &len));
+
+  rc= mysql_query(mysql, "CREATE TEMPORARY TABLE t1(a int) ENGINE=InnoDB");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "COMMIT");
+  
+  check_mysql_rc(rc, mysql);
+
+  if (!mysql_session_track_get_first(mysql, SESSION_TRACK_TRANSACTION_STATE, &data, &len))
+  do {
+    FAIL_IF(len != 8, "expected 8 bytes");
+    FAIL_IF(data[0] != '_', "expected underscore");
+  } while (!mysql_session_track_get_next(mysql, SESSION_TRACK_TRANSACTION_STATE, &data, &len));
+
+  return OK;
+}
+
+
+static int test_unix_socket_close(MYSQL *unused __attribute__((unused)))
+{
+#ifdef _WIN32
+  diag("test does not run on Windows");
+  return SKIP;
+#else
+  MYSQL *mysql= mysql_init(NULL);
+  FILE *fp;
+  int i;
+
+  SKIP_SKYSQL;
+  SKIP_TRAVIS();
+
+  if (!(fp= fopen("./dummy_sock", "w")))
+  {
+    diag("couldn't create dummy socket");
+    return FAIL;
+  }
+  fclose(fp);
+
+  for (i=0; i < 10000; i++)
+  {
+    my_test_connect(mysql, "localhost", "user", "passwd", NULL, 0, "./dummy_sock", 0);
+    /* check if we run out of sockets */
+    if (mysql_errno(mysql) == 2001)
+    {
+      diag("out of sockets after %d attempts", i);
+      mysql_close(mysql);
+      return FAIL;
+    }
+  }
+  mysql_close(mysql);
+  return OK;
+#endif
+}
+
+
+static int test_reset(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_RES *res;
+
+  if (mysql_get_server_version(mysql) < 100200)
+    return SKIP;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1),(2),(3)");
+  check_mysql_rc(rc, mysql);
+
+  FAIL_IF(mysql_affected_rows(mysql) != 3, "Expected 3 rows");
+
+  rc= mysql_reset_connection(mysql);
+  check_mysql_rc(rc, mysql);
+
+  FAIL_IF(mysql_affected_rows(mysql) != ~(my_ulonglong)0, "Expected 0 rows");
+
+  rc= mysql_query(mysql, "SELECT a FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT 1 FROM DUAL");
+  FAIL_IF(!rc, "Error expected"); 
+
+  rc= mysql_reset_connection(mysql);
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  FAIL_IF(res, "expected no result");
+
+  rc= mysql_query(mysql, "SELECT a FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_use_result(mysql);
+  FAIL_IF(!res, "expected result");
+
+  rc= mysql_reset_connection(mysql);
+  check_mysql_rc(rc, mysql);
+
+  FAIL_IF(mysql_fetch_row(res), "expected error");
+
+  mysql_free_result(res);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_auth256(MYSQL *my)
+{
+  MYSQL *mysql= mysql_init(NULL);
+  int rc;
+  MYSQL_RES *res;
+  my_ulonglong num_rows= 0;
+  char query[1024];
+  SKIP_MAXSCALE;
+
+  if (IS_SKYSQL(hostname))
+    return SKIP;
+
+  if (!mysql_client_find_plugin(mysql, "sha256_password", MYSQL_CLIENT_AUTHENTICATION_PLUGIN))
+  {
+    diag("sha256_password plugin not available");
+    mysql_close(mysql);
+    return SKIP;
+  }
+
+  rc= mysql_query(my, "SELECT * FROM information_schema.plugins where plugin_name='sha256_password'");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(my);
+  num_rows= mysql_num_rows(res);
+  mysql_free_result(res);
+
+  if (!num_rows)
+  {
+    diag("server doesn't support sha256 authentication");
+    mysql_close(mysql);
+    return SKIP;
+  }
+
+  rc= mysql_query(my, "DROP USER IF EXISTS sha256user@localhost");
+  check_mysql_rc(rc, mysql);
+
+  sprintf(query, "CREATE user 'sha256user'@'%s' identified with sha256_password by 'foo'", this_host);
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, my);
+
+  if (!my_test_connect(mysql, hostname, "sha256user", "foo", NULL, port, socketname, 0))
+  {
+    diag("error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+    return FAIL;
+  }
+  mysql_close(mysql);
+
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_SERVER_PUBLIC_KEY, "rsa_public_key.pem");
+  if (!my_test_connect(mysql, hostname, "sha256user", "foo", NULL, port, socketname, 0))
+  {
+    diag("error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+    return FAIL;
+  }
+  mysql_close(mysql);
+  sprintf(query, "DROP USER 'sha256user'@'%s'", this_host);
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_mdev13100(MYSQL *my __attribute__((unused)))
+{
+  MYSQL *mysql= mysql_init(NULL);
+  int rc;
+  FILE *fp;
+
+  if (!(fp= fopen("./mdev13100.cnf", "w")))
+    return FAIL;
+
+   /* [client] group only */
+  fprintf(fp, "[client]\n");
+  fprintf(fp, "default-character-set=latin2\n");
+
+  fclose(fp);
+
+  rc= mysql_options(mysql, MYSQL_READ_DEFAULT_FILE, "./mdev13100.cnf");
+  check_mysql_rc(rc, mysql);
+
+  if (!my_test_connect(mysql, hostname, username,
+                             password, schema, port, socketname, 0))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    return FAIL;
+  }
+  FAIL_IF(strcmp("latin2", mysql_character_set_name(mysql)), "Expected charset latin2");
+  mysql_close(mysql);
+
+  /* value from client-mariadb group */
+  mysql= mysql_init(NULL);
+  if (!(fp= fopen("./mdev13100.cnf", "w")))
+    return FAIL;
+
+  fprintf(fp, "[client]\n");
+  fprintf(fp, "default-character-set=latin1\n");
+  fprintf(fp, "[client-server]\n");
+  fprintf(fp, "default-character-set=latin2\n");
+
+  fclose(fp);
+
+  rc= mysql_options(mysql, MYSQL_READ_DEFAULT_FILE, "./mdev13100.cnf");
+  check_mysql_rc(rc, mysql);
+
+  if (!my_test_connect(mysql, hostname, username,
+                             password, schema, port, socketname, 0))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    return FAIL;
+  }
+  FAIL_IF(strcmp("latin2", mysql_character_set_name(mysql)), "Expected charset latin2");
+  mysql_close(mysql);
+
+/* values from client-mariadb group */
+  mysql= mysql_init(NULL);
+
+if (!(fp= fopen("./mdev13100.cnf", "w")))
+    return FAIL;
+
+  fprintf(fp, "[client]\n");
+  fprintf(fp, "default-character-set=latin1\n");
+  fprintf(fp, "[client-server]\n");
+  fprintf(fp, "default-character-set=utf8\n");
+  fprintf(fp, "[client-mariadb]\n");
+  fprintf(fp, "default-character-set=latin2\n");
+
+  fclose(fp);
+
+  rc= mysql_options(mysql, MYSQL_READ_DEFAULT_FILE, "./mdev13100.cnf");
+  check_mysql_rc(rc, mysql);
+
+  if (!my_test_connect(mysql, hostname, username,
+                             password, schema, port, socketname, 0))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    return FAIL;
+  }
+  FAIL_IF(strcmp("latin2", mysql_character_set_name(mysql)), "Expected charset latin2");
+  mysql_close(mysql);
+
+/* values from mdev-13100 group */
+  mysql= mysql_init(NULL);
+  if (!(fp= fopen("./mdev13100.cnf", "w")))
+    return FAIL;
+
+  fprintf(fp, "[client]\n");
+  fprintf(fp, "default-character-set=latin1\n");
+  fprintf(fp, "[client-server]\n");
+  fprintf(fp, "default-character-set=latin1\n");
+  fprintf(fp, "[client-mariadb]\n");
+  fprintf(fp, "default-character-set=utf8\n");
+  fprintf(fp, "[mdev13100]\n");
+  fprintf(fp, "default-character-set=latin2\n");
+
+  fclose(fp);
+
+  rc= mysql_options(mysql, MYSQL_READ_DEFAULT_FILE, "./mdev13100.cnf");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "mdev13100");
+  check_mysql_rc(rc, mysql);
+
+  if (!my_test_connect(mysql, hostname, username,
+                             password, schema, port, socketname, 0))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    return FAIL;
+  }
+  FAIL_IF(strcmp("latin2", mysql_character_set_name(mysql)), "Expected charset latin2");
+  mysql_close(mysql);
+
+/* values from [programname] group */
+  mysql= mysql_init(NULL);
+  if (!(fp= fopen("./mdev13100.cnf", "w")))
+    return FAIL;
+
+  fprintf(fp, "[client]\n");
+  fprintf(fp, "default-character-set=utf8\n");
+  fprintf(fp, "[client-server]\n");
+  fprintf(fp, "default-character-set=utf8\n");
+  fprintf(fp, "[client-mariadb]\n");
+  fprintf(fp, "default-character-set=latin2\n");
+
+  fclose(fp);
+
+  rc= mysql_options(mysql, MYSQL_READ_DEFAULT_FILE, "./mdev13100.cnf");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "");
+  check_mysql_rc(rc, mysql);
+
+  if (!my_test_connect(mysql, hostname, username,
+                             password, schema, port, socketname, 0))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    return FAIL;
+  }
+  diag("character set: %s", mysql_character_set_name(mysql));
+  FAIL_IF(strcmp("latin2", mysql_character_set_name(mysql)), "Expected charset latin2");
+  mysql_close(mysql);
+
+  remove("./mdev13100.cnf");
+
+  return OK;
+}
+
+static int test_conc276(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql= mysql_init(NULL);
+  int rc;
+  my_bool val= 1;
+
+  mysql_options(mysql, MYSQL_OPT_SSL_ENFORCE, &val);
+  mysql_options(mysql, MYSQL_OPT_RECONNECT, &val);
+
+  if (!my_test_connect(mysql, hostname, username, password, schema, port, socketname, 0))
+  {
+    diag("Connection failed. Error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+    return FAIL;
+  }
+  diag("Cipher in use: %s", mysql_get_ssl_cipher(mysql));
+
+  rc= mariadb_reconnect(mysql);
+  check_mysql_rc(rc, mysql);
+
+  diag("Cipher in use: %s", mysql_get_ssl_cipher(mysql));
+  /* this shouldn't crash anymore */
+  rc= mysql_query(mysql, "SET @a:=1");
+  check_mysql_rc(rc, mysql);
+
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_expired_pw(MYSQL *my)
+{
+  MYSQL *mysql;
+  int rc;
+  char query[512];
+  unsigned char expire= 1;
+
+  if (mariadb_connection(my) ||
+     !(my->server_capabilities & CLIENT_CAN_HANDLE_EXPIRED_PASSWORDS))
+  {
+    diag("Server doesn't support password expiration");
+    return SKIP;
+  }
+  sprintf(query, "DROP USER 'foo'@'%s'", this_host);
+  rc= mysql_query(my, query);
+
+  sprintf(query, "CREATE USER 'foo'@'%s' IDENTIFIED BY 'foo'", this_host);
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, my);
+
+  sprintf(query, "GRANT ALL ON *.* TO 'foo'@'%s'", this_host);
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, my);
+
+  sprintf(query, "ALTER USER 'foo'@'%s' PASSWORD EXPIRE", this_host);
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, my);
+
+  mysql= mysql_init(NULL);
+
+  my_test_connect(mysql, hostname, "foo", "foo", schema,
+                  port, socketname, 0);
+
+  FAIL_IF(!mysql_errno(mysql), "Error expected");
+  mysql_close(mysql);
+
+  mysql= mysql_init(NULL);
+  mysql_optionsv(mysql, MYSQL_OPT_CAN_HANDLE_EXPIRED_PASSWORDS, &expire);
+
+  my_test_connect(mysql, hostname, "foo", "foo", schema,
+                  port, socketname, 0);
+
+  /* we should be in sandbox mode now, only set commands should be allowed */
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  FAIL_IF(!rc, "Error expected (we are in sandbox mode");
+
+  diag("error: %d %s", mysql_errno(mysql), mysql_error(mysql));
+  FAIL_IF(mysql_errno(mysql) != ER_MUST_CHANGE_PASSWORD &&
+          mysql_errno(mysql) != ER_MUST_CHANGE_PASSWORD_LOGIN, "Error 1820/1862 expected");
+
+  mysql_close(mysql);
+
+  sprintf(query, "DROP USER 'foo'@'%s'", this_host);
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, my);
+
+  return OK;
+}
+
+static int test_conc315(MYSQL *mysql)
+{
+  int rc;
+  const char *csname;
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  if (!is_mariadb)
+    return SKIP;
+
+  mysql_get_optionv(mysql, MYSQL_SET_CHARSET_NAME, (void *)&csname);
+  diag("csname=%s", csname);
+  FAIL_UNLESS(strcmp(csname, MARIADB_DEFAULT_CHARSET) == 0, "Wrong default character set");
+
+  rc= mysql_change_user(mysql, username, password, schema);
+  check_mysql_rc(rc, mysql);
+  mysql_get_optionv(mysql, MYSQL_SET_CHARSET_NAME, (void *)&csname);
+  FAIL_UNLESS(strcmp(csname, MARIADB_DEFAULT_CHARSET) == 0, "Wrong default character set");
+  return OK;
+}
+#ifndef WIN32
+static int test_conc317(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+  my_bool reconnect = 0;
+  FILE *fp= NULL;
+  const char *env= getenv("MYSQL_TMP_DIR");
+  char cnf_file1[FN_REFLEN + 1];
+
+  SKIP_SKYSQL;
+
+  if (travis_test)
+    return SKIP;
+
+  if (!env)
+    env= "/tmp";
+
+  setenv("HOME", env, 1);
+
+  snprintf(cnf_file1, FN_REFLEN, "%s%c.my.cnf", env, FN_LIBCHAR);
+
+  FAIL_IF(!access(cnf_file1, R_OK), "access");
+
+  mysql= mysql_init(NULL);
+  fp= fopen(cnf_file1, "w");
+  FAIL_IF(!fp, "fopen");
+
+  fprintf(fp, "[client]\ndefault-character-set = latin2\nreconnect= 1\n");
+  fclose(fp);
+
+  mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "");
+  my_test_connect(mysql, hostname, username, password,
+                  schema, 0, socketname, 0);
+
+  remove(cnf_file1);
+
+  FAIL_IF(strcmp(mysql_character_set_name(mysql), "latin2"), "expected charset latin2");
+  mysql_get_optionv(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_IF(reconnect != 1, "expected reconnect=1");
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_conc327(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+  my_bool reconnect = 0;
+  FILE *fp1= NULL, *fp2= NULL;
+  const char *env= getenv("MYSQL_TMP_DIR");
+  char cnf_file1[FN_REFLEN + 1];
+  char cnf_file2[FN_REFLEN + 1];
+
+  SKIP_SKYSQL;
+
+  if (travis_test)
+    return SKIP;
+
+  if (!env)
+    env= "/tmp";
+
+  setenv("HOME", env, 1);
+
+  snprintf(cnf_file1, FN_REFLEN, "%s%c.my.cnf", env, FN_LIBCHAR);
+  snprintf(cnf_file2, FN_REFLEN, "%s%c.my.tmp", env, FN_LIBCHAR);
+
+  FAIL_IF(!access(cnf_file1, R_OK), "access");
+
+  fp1= fopen(cnf_file1, "w");
+  fp2= fopen(cnf_file2, "w");
+  FAIL_IF(!fp1 || !fp2, "fopen failed");
+
+  fprintf(fp1, "!include %s\n", cnf_file2);
+  
+  fprintf(fp2, "[client]\ndefault-character-set = latin2\nreconnect= 1\n");
+  fclose(fp1);
+  fclose(fp2);
+
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "");
+  my_test_connect(mysql, hostname, username, password,
+                  schema, 0, socketname, 0);
+
+  remove(cnf_file1);
+  remove(cnf_file2);
+
+  FAIL_IF(strcmp(mysql_character_set_name(mysql), "latin2"), "expected charset latin2");
+  mysql_get_optionv(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_IF(reconnect != 1, "expected reconnect=1");
+  mysql_close(mysql);
+
+  snprintf(cnf_file1, FN_REFLEN, "%s%cmy.cnf", env, FN_LIBCHAR);
+  fp1= fopen(cnf_file1, "w");
+  fp2= fopen(cnf_file2, "w");
+  FAIL_IF(!fp1 || !fp2, "fopen failed");
+
+  fprintf(fp2, "!includedir %s\n", env);
+  
+  fprintf(fp1, "[client]\ndefault-character-set = latin2\nreconnect= 1\n");
+  fclose(fp1);
+  fclose(fp2);
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_READ_DEFAULT_FILE, cnf_file2);
+  my_test_connect(mysql, hostname, username, password,
+                  schema, 0, socketname, 0);
+
+  remove(cnf_file1);
+  remove(cnf_file2);
+
+  FAIL_IF(strcmp(mysql_character_set_name(mysql), "latin2"), "expected charset latin2");
+  mysql_get_optionv(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_IF(reconnect != 1, "expected reconnect=1");
+  mysql_close(mysql);
+
+  return OK;
+}
+#endif
+
+static int test_conc332(MYSQL *unused __attribute__((unused)))
+{
+  int rc;
+  MYSQL *mysql= mysql_init(NULL);
+  int server_status1, server_status2;
+
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  mysql_options(mysql, MYSQL_SET_CHARSET_NAME, "utf8mb4");
+
+  my_test_connect(mysql, hostname, username, password, schema,
+                  port, socketname, 0);
+
+  FAIL_IF(mysql_errno(mysql), "Error during connect");
+
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_STATUS, &server_status1);
+  diag("server_status: %d", server_status1);
+
+  if (server_status1 & SERVER_STATUS_AUTOCOMMIT)
+    rc= mysql_query(mysql, "SET autocommit= 0");
+  else
+    rc= mysql_query(mysql, "SET autocommit= 1");
+  check_mysql_rc(rc, mysql);
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_STATUS, &server_status2);
+  diag("server_status after changing autocommit: %d", server_status2);
+
+  rc= mysql_change_user(mysql, username, password, schema);
+  check_mysql_rc(rc, mysql);
+
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_STATUS, &server_status2);
+  diag("server_status after mysql_change_user: %d", server_status2);
+  if (server_status1 != server_status2)
+  {
+    diag("Expected server_status %d instead of %d", server_status1, server_status2);
+    mysql_close(mysql);
+    return FAIL;
+  }
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_conc351(MYSQL *unused __attribute__((unused)))
+{
+  int rc;
+  const char *data;
+  size_t len;
+  MYSQL *mysql= mysql_init(NULL);
+  ulong capabilities= 0;
+
+  my_test_connect(mysql, hostname, username, password, schema,
+                  port, socketname, 0);
+
+  FAIL_IF(mysql_errno(mysql), "Error during connect");
+
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_CAPABILITIES, &capabilities);
+  if (!(capabilities & CLIENT_SESSION_TRACKING))
+  {
+    mysql_close(mysql);
+    diag("Server doesn't support session tracking (cap=%lu)", mysql->server_capabilities);
+    return SKIP;
+  }
+  rc= mysql_query(mysql, "USE mysql");
+  check_mysql_rc(rc, mysql);
+  FAIL_IF(strcmp(mysql->db, "mysql"), "Expected new schema 'mysql'");
+
+  FAIL_IF(mysql_session_track_get_first(mysql, SESSION_TRACK_SCHEMA, &data, &len), "expected session track schema");
+
+  rc= mysql_query(mysql, "SET @a:=1");
+  check_mysql_rc(rc, mysql);
+
+  FAIL_IF(!mysql_session_track_get_first(mysql, SESSION_TRACK_SCHEMA, &data, &len), "expected no schema tracking information");
+
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_conc312(MYSQL *my)
+{
+  int rc;
+  char query[1024];
+  MYSQL *mysql;
+
+  sprintf(query, "DROP USER 'foo'@'%s'", this_host);
+  rc= mysql_query(my, query);
+
+  sprintf(query, "CREATE USER 'foo'@'%s' IDENTIFIED WITH caching_sha2_password BY 'foo'", this_host);
+  rc= mysql_query(my, query);
+
+  if (rc)
+  {
+    diag("caching_sha256_password not supported");
+    return SKIP; 
+  }
+
+  sprintf(query, "GRANT ALL ON %s.* TO 'foo'@'%s'", schema, this_host);
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, my);
+
+  mysql= mysql_init(NULL);
+  if (!my_test_connect(mysql, hostname, "foo", "foo", schema, port, socketname, 0))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    return FAIL;
+  }
+
+  mysql_close(mysql);
+  
+  sprintf(query, "DROP USER 'foo'@'%s'", this_host);
+  rc= mysql_query(my, query);
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_conc366(MYSQL *mysql)
+{
+  char query[1024];
+  int rc;
+  MYSQL *my;
+
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  if (!is_mariadb)
+  {
+    diag("feature not supported by MySQL server");
+    return SKIP;
+  }
+
+  /* check if ed25519 plugin is available */
+  if (!mysql_client_find_plugin(mysql, "client_ed25519", MYSQL_CLIENT_AUTHENTICATION_PLUGIN))
+  {
+    diag("client_ed25519 plugin not available");
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "INSTALL SONAME 'auth_ed25519'");
+  if (rc)
+  {
+    diag("feature not supported, ed25519 plugin not available");
+    return SKIP;
+  }
+
+  if (mysql_get_server_version(mysql) < 100400) {
+    sprintf(query, "CREATE OR REPLACE USER 'ede'@'%s' IDENTIFIED VIA ed25519 USING '6aW9C7ENlasUfymtfMvMZZtnkCVlcb1ssxOLJ0kj/AA'", this_host);
+  } else {
+    sprintf(query, "CREATE OR REPLACE USER 'ede'@'%s' IDENTIFIED VIA ed25519 USING PASSWORD('MySup8%%rPassw@ord')", this_host);
+  }
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(query, "GRANT ALL ON %s.* TO 'ede'@'%s'", schema, this_host);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  my= mysql_init(NULL);
+  if (plugindir)
+    mysql_options(my, MYSQL_PLUGIN_DIR, plugindir);
+  if (!my_test_connect(my, hostname, "ede", "MySup8%rPassw@ord", schema, port, socketname, 0))
+  {
+    diag("Error: %s", mysql_error(my));
+    return FAIL;
+  }
+  mysql_close(my);
+
+  sprintf(query, "DROP USER 'ede'@'%s'", this_host);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  sprintf(query, "UNINSTALL SONAME 'auth_ed25519'");
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_conc392(MYSQL *mysql)
+{
+  int rc;
+  const char *data;
+  size_t len;
+  ulong capabilities= 0;
+
+  SKIP_MYSQL(mysql);
+
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_CAPABILITIES, &capabilities);
+  if (!(capabilities & CLIENT_SESSION_TRACKING))
+  {
+    diag("Server doesn't support session tracking (cap=%lu)", mysql->server_capabilities);
+    return SKIP;
+  }
+  
+  rc= mysql_query(mysql, "set session_track_state_change=1");
+  check_mysql_rc(rc, mysql);
+
+  if (mysql_session_track_get_first(mysql, SESSION_TRACK_STATE_CHANGE, &data, &len))
+  {
+    diag("session_track_get_first failed");
+    return FAIL;
+  }
+  
+  FAIL_IF(len != 1, "Expected length 1");
+  return OK;
+}
+
+static int test_conc443(MYSQL *my __attribute__((unused)))
+{
+  my_bool x= 1;
+  unsigned long thread_id= 0;
+  char query[128];
+  MYSQL_RES *result;
+  MYSQL_ROW row;
+  int rc;
+
+  MYSQL *mysql= mysql_init(NULL);
+
+  SKIP_MAXSCALE;
+
+  mysql_options(mysql, MYSQL_INIT_COMMAND, "set @a:=3");
+  mysql_options(mysql, MYSQL_OPT_RECONNECT, &x);
+
+  if (!my_test_connect(mysql, hostname, username, password, schema, port, socketname, CLIENT_REMEMBER_OPTIONS))
+  {
+    diag("Connection failed. Error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+  }
+
+  thread_id= mysql_thread_id(mysql);
+
+  sprintf(query, "KILL %lu", thread_id);
+  rc= mysql_query(mysql, query);
+
+  sleep(3);
+
+  rc= mysql_ping(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT @a");
+  check_mysql_rc(rc, mysql);
+
+  FAIL_IF(mysql_thread_id(mysql) == thread_id, "Expected different thread id");
+
+  result= mysql_store_result(mysql);
+  if (!result)
+    return FAIL;
+  row= mysql_fetch_row(result);
+  FAIL_IF(strcmp(row[0],"3"), "Wrong result");
+
+  mysql_free_result(result);
+  mysql_close(mysql);
+
+  return OK;
+}
+
+static int test_default_auth(MYSQL *my __attribute__((unused)))
+{
+  MYSQL *mysql;
+
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  if (!is_mariadb)
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_DEFAULT_AUTH, "mysql_clear_password");
+
+  if (!my_test_connect(mysql, hostname, username, password, schema, port, socketname, CLIENT_REMEMBER_OPTIONS))
+  {
+    diag("Connection failed. Error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+    return FAIL;
+  }
+  mysql_close(mysql);
+
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_DEFAULT_AUTH, "caching_sha2_password");
+
+  if (!my_test_connect(mysql, hostname, username, password, schema, port, socketname, CLIENT_REMEMBER_OPTIONS))
+  {
+    diag("Connection failed. Error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+    return FAIL;
+  
+  }
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_gtid(MYSQL *mysql)
+{
+  int rc;
+  const char *data;
+  size_t len;
+
+  if (is_mariadb)
+    return SKIP;
+
+  rc= mysql_query(mysql, "SET @@session.session_track_state_change=1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SET @@session.session_track_gtids=OWN_GTID");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "BEGIN");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  if (!mysql_session_track_get_first(mysql, SESSION_TRACK_GTIDS, &data, &len))
+  do {
+    printf("# SESSION_TRACK_GTIDS: %*.*s\n", (int)len, (int)len, data);
+  } while (!mysql_session_track_get_next(mysql, SESSION_TRACK_GTIDS, &data, &len));
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  if (!mysql_session_track_get_first(mysql, SESSION_TRACK_GTIDS, &data, &len))
+  do {
+    printf("# SESSION_TRACK_GTIDS: %*.*s\n", (int)len, (int)len, data);
+  } while (!mysql_session_track_get_next(mysql, SESSION_TRACK_GTIDS, &data, &len));
+
+  rc= mysql_query(mysql, "COMMIT");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_conc490(MYSQL *my __attribute__((unused)))
+{
+  MYSQL *mysql= mysql_init(NULL);
+
+  if (!my_test_connect(mysql, hostname, username,
+                             password, NULL, port, socketname, CLIENT_CONNECT_WITH_DB))
+  {
+    diag("error: %s\n", mysql_error(mysql));
+    return FAIL;
+  }
+  mysql_close(mysql);
+  return OK;
+}
+
+struct my_tests_st my_tests[] = {
+  {"test_conc490", test_conc490, TEST_CONNECTION_NONE, 0, NULL, NULL},
+  {"test_gtid", test_gtid, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc496", test_conc496, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_default_auth", test_default_auth, TEST_CONNECTION_NONE, 0, NULL, NULL},
+  {"test_conc443", test_conc443, TEST_CONNECTION_NONE, 0, NULL, NULL},
+  {"test_conc366", test_conc366, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc392", test_conc392, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc312", test_conc312, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc351", test_conc351, TEST_CONNECTION_NONE, 0, NULL, NULL},
+  {"test_conc332", test_conc332, TEST_CONNECTION_NONE, 0, NULL, NULL},
+#ifndef WIN32
+  {"test_conc327", test_conc327, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc317", test_conc317, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+#endif
+  {"test_conc315", test_conc315, TEST_CONNECTION_NEW, 0, NULL,  NULL},
+  {"test_expired_pw", test_expired_pw, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+  {"test_conc276", test_conc276, TEST_CONNECTION_NONE, 0, NULL,  NULL},
+  {"test_mdev13100", test_mdev13100, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+  {"test_auth256", test_auth256, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+  {"test_reset", test_reset, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+  {"test_unix_socket_close", test_unix_socket_close, TEST_CONNECTION_NONE, 0, NULL,  NULL},
+  {"test_sess_track_db", test_sess_track_db, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+  {"test_get_options", test_get_options, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+  {"test_wrong_bind_address", test_wrong_bind_address, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+  {"test_bind_address", test_bind_address, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+  {"test_conc118", test_conc118, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+  {"test_conc66", test_conc66, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+  {"test_bug20023", test_bug20023, TEST_CONNECTION_NEW, 0, NULL,  NULL},
+  {"test_bug31669", test_bug31669, TEST_CONNECTION_NEW, 0, NULL,  NULL},
+  {"test_bug33831", test_bug33831, TEST_CONNECTION_NEW, 0, NULL,  NULL},
+  {"test_change_user", test_change_user, TEST_CONNECTION_NEW, 0, NULL,  NULL},
+  {"test_opt_reconnect", test_opt_reconnect, TEST_CONNECTION_NONE, 0, NULL,  NULL},
+  {"test_compress", test_compress, TEST_CONNECTION_NONE, 0, NULL,  NULL},
+  {"test_reconnect", test_reconnect, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc21", test_conc21, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc26", test_conc26, TEST_CONNECTION_NONE, 0, NULL, NULL}, 
+  {"test_connection_timeout", test_connection_timeout, TEST_CONNECTION_NONE, 0, NULL, NULL},
+  {"test_connection_timeout2", test_connection_timeout2, TEST_CONNECTION_NONE, 0, NULL, NULL}, 
+  {"test_connection_timeout3", test_connection_timeout3, TEST_CONNECTION_NONE, 0, NULL, NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/cursor.c b/libmariadb/unittest/libmariadb/cursor.c
new file mode 100644
index 00000000..6378501a
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/cursor.c
@@ -0,0 +1,1841 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+#include "my_test.h"
+
+/* helper functions */
+enum { MAX_COLUMN_LENGTH= 255 };
+
+typedef struct st_stmt_fetch
+{
+  const char *query;
+  unsigned stmt_no;
+  MYSQL_STMT *handle;
+  my_bool is_open;
+  MYSQL_BIND *bind_array;
+  char **out_data;
+  unsigned long *out_data_length;
+  unsigned column_count;
+  unsigned row_count;
+} Stmt_fetch;
+
+MYSQL_STMT *open_cursor(MYSQL *mysql, const char *query)
+{
+  int rc;
+  const ulong type= (ulong)CURSOR_TYPE_READ_ONLY;
+
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  if (rc) {
+    diag("Error: %s", mysql_stmt_error(stmt));
+    return NULL;
+  }
+  mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);
+  return stmt;
+}
+
+/*
+  Create statement handle, prepare it with statement, execute and allocate
+  fetch buffers.
+*/
+
+int stmt_fetch_init(MYSQL *mysql, Stmt_fetch *fetch, unsigned int stmt_no_arg,
+                     const char *query_arg)
+{
+  unsigned long type= CURSOR_TYPE_READ_ONLY;
+  int rc;
+  unsigned int i;
+  MYSQL_RES *metadata;
+
+  /* Save query and statement number for error messages */
+  fetch->stmt_no= stmt_no_arg;
+  fetch->query= query_arg;
+
+  fetch->handle= mysql_stmt_init(mysql);
+
+  rc= mysql_stmt_prepare(fetch->handle, SL(fetch->query));
+  FAIL_IF(rc, mysql_stmt_error(fetch->handle));
+
+  /*
+    The attribute is sent to server on execute and asks to open read-only
+    for result set
+  */
+  mysql_stmt_attr_set(fetch->handle, STMT_ATTR_CURSOR_TYPE,
+                      (const void*) &type);
+
+  rc= mysql_stmt_execute(fetch->handle);
+  FAIL_IF(rc, mysql_stmt_error(fetch->handle));
+
+  /* Find out total number of columns in result set */
+  metadata= mysql_stmt_result_metadata(fetch->handle);
+  fetch->column_count= mysql_num_fields(metadata);
+  mysql_free_result(metadata);
+
+  /*
+    Now allocate bind handles and buffers for output data:
+    calloc memory to reduce number of MYSQL_BIND members we need to
+    set up.
+  */
+
+  fetch->bind_array= (MYSQL_BIND *) calloc(1, sizeof(MYSQL_BIND) *
+                                              fetch->column_count);
+  fetch->out_data= (char**) calloc(1, sizeof(char*) * fetch->column_count);
+  fetch->out_data_length= (ulong*) calloc(1, sizeof(ulong) *
+                                             fetch->column_count);
+  for (i= 0; i < fetch->column_count; ++i)
+  {
+    fetch->out_data[i]= (char*) calloc(1, MAX_COLUMN_LENGTH);
+    fetch->bind_array[i].buffer_type= MYSQL_TYPE_STRING;
+    fetch->bind_array[i].buffer= fetch->out_data[i];
+    fetch->bind_array[i].buffer_length= MAX_COLUMN_LENGTH;
+    fetch->bind_array[i].length= fetch->out_data_length + i;
+  }
+
+  mysql_stmt_bind_result(fetch->handle, fetch->bind_array);
+
+  fetch->row_count= 0;
+  fetch->is_open= TRUE;
+
+  /* Ready for reading rows */
+  return OK;
+}
+
+
+int fill_tables(MYSQL *mysql, const char **query_list, unsigned query_count)
+{
+  int rc;
+  const char **query;
+  for (query= query_list; query < query_list + query_count;
+       ++query)
+  {
+    rc= mysql_query(mysql, *query);
+    check_mysql_rc(rc, mysql);
+  }
+  return OK;
+}
+
+int stmt_fetch_fetch_row(Stmt_fetch *fetch)
+{
+  int rc;
+  unsigned i;
+
+  if ((rc= mysql_stmt_fetch(fetch->handle)) == 0)
+  {
+    ++fetch->row_count;
+    for (i= 0; i < fetch->column_count; ++i)
+    {
+      fetch->out_data[i][fetch->out_data_length[i]]= '\0';
+    }
+  }
+  else
+    fetch->is_open= FALSE;
+
+  return rc;
+}
+
+void stmt_fetch_close(Stmt_fetch *fetch)
+{
+  unsigned i;
+
+  for (i= 0; i < fetch->column_count; ++i)
+    free(fetch->out_data[i]);
+  free(fetch->out_data);
+  free(fetch->out_data_length);
+  free(fetch->bind_array);
+  mysql_stmt_close(fetch->handle);
+}
+
+
+
+enum fetch_type { USE_ROW_BY_ROW_FETCH= 0, USE_STORE_RESULT= 1 };
+
+int fetch_n(MYSQL *mysql, const char **query_list, unsigned query_count,
+                enum fetch_type fetch_type)
+{
+  unsigned open_statements= query_count;
+  int rc, error_count= 0;
+  Stmt_fetch *fetch_array= (Stmt_fetch*) calloc(1, sizeof(Stmt_fetch) *
+                                                  query_count);
+  Stmt_fetch *fetch;
+
+  for (fetch= fetch_array; fetch < fetch_array + query_count; ++fetch)
+  {
+    if (stmt_fetch_init(mysql, fetch, (unsigned int)(fetch - fetch_array),
+                    query_list[fetch - fetch_array]))
+      return FAIL;
+  }
+
+  if (fetch_type == USE_STORE_RESULT)
+  {
+    for (fetch= fetch_array; fetch < fetch_array + query_count; ++fetch)
+    {
+      rc= mysql_stmt_store_result(fetch->handle);
+      FAIL_IF(rc, mysql_stmt_error(fetch->handle));
+    }
+  }
+
+  while (open_statements)
+  {
+    for (fetch= fetch_array; fetch < fetch_array + query_count; ++fetch)
+    {
+      if (fetch->is_open && (rc= stmt_fetch_fetch_row(fetch)))
+      {
+        open_statements--;
+        /*
+          We try to fetch from the rest of the statements in case of
+          error
+        */
+        if (rc != MYSQL_NO_DATA)
+          error_count++;
+      }
+    }
+  }
+  if (!error_count)
+  {
+    unsigned total_row_count= 0;
+    for (fetch= fetch_array; fetch < fetch_array + query_count; ++fetch)
+      total_row_count+= fetch->row_count;
+  }
+  for (fetch= fetch_array; fetch < fetch_array + query_count; ++fetch)
+    stmt_fetch_close(fetch);
+  free(fetch_array);
+
+  return (error_count) ? FAIL:OK;
+}
+
+static int test_basic_cursors(MYSQL *mysql)
+{
+  const char *basic_tables[]=
+  {
+    "DROP TABLE IF EXISTS t1, t2",
+
+    "CREATE TABLE t1 "
+    "(id INTEGER NOT NULL PRIMARY KEY, "
+    " name VARCHAR(20) NOT NULL)",
+
+    "INSERT INTO t1 (id, name) VALUES "
+    "  (2, 'Ja'), (3, 'Ede'), "
+    "  (4, 'Haag'), (5, 'Kabul'), "
+    "  (6, 'Almere'), (7, 'Utrecht'), "
+    "  (8, 'Qandahar'), (9, 'Amsterdam'), "
+    "  (10, 'Amersfoort'), (11, 'Constantine')",
+
+    "CREATE TABLE t2 "
+    "(id INTEGER NOT NULL PRIMARY KEY, "
+    " name VARCHAR(20) NOT NULL)",
+
+    "INSERT INTO t2 (id, name) VALUES "
+    "  (4, 'Guam'), (5, 'Aruba'), "
+    "  (6, 'Angola'), (7, 'Albania'), "
+    "  (8, 'Anguilla'), (9, 'Argentina'), "
+    "  (10, 'Azerbaijan'), (11, 'Afghanistan'), "
+    "  (12, 'Burkina Faso'), (13, 'Faroe Islands')"
+  };
+
+  const char *queries[]=
+  {
+    "SELECT * FROM t1",
+    "SELECT * FROM t2"
+  };
+
+  
+  FAIL_IF(fill_tables(mysql, basic_tables, sizeof(basic_tables)/sizeof(*basic_tables)), "fill_tables failed");
+
+  FAIL_IF(fetch_n(mysql, queries, sizeof(queries)/sizeof(*queries), USE_ROW_BY_ROW_FETCH), "fetch_n failed");
+  FAIL_IF(fetch_n(mysql, queries, sizeof(queries)/sizeof(*queries), USE_STORE_RESULT), "fetch_n failed");
+  return OK;
+}
+
+
+static int test_cursors_with_union(MYSQL *mysql)
+{
+  const char *queries[]=
+  {
+    "SELECT t1.name FROM t1 UNION SELECT t2.name FROM t2",
+    "SELECT t1.id FROM t1 WHERE t1.id < 5"
+  };
+  FAIL_IF(fetch_n(mysql, queries, sizeof(queries)/sizeof(*queries), USE_ROW_BY_ROW_FETCH), "fetch_n failed");
+  FAIL_IF(fetch_n(mysql, queries, sizeof(queries)/sizeof(*queries), USE_STORE_RESULT), "fetch_n failed");
+
+  return OK;
+}
+
+
+static int test_cursors_with_procedure(MYSQL *mysql)
+{
+  const char *queries[]=
+  {
+    "SELECT * FROM t1 procedure analyse()"
+  };
+  SKIP_MYSQL(mysql);
+  FAIL_IF(fetch_n(mysql, queries, sizeof(queries)/sizeof(*queries), USE_ROW_BY_ROW_FETCH), "fetch_n failed");
+  FAIL_IF(fetch_n(mysql, queries, sizeof(queries)/sizeof(*queries), USE_STORE_RESULT), "fetch_n failed");
+
+  return OK;
+}
+
+/*
+  Bug#21206: memory corruption when too many cursors are opened at once
+
+  Memory corruption happens when more than 1024 cursors are open
+  simultaneously.
+*/
+static int test_bug21206(MYSQL *mysql)
+{
+  int retcode= OK;
+
+  const size_t cursor_count= 1025;
+
+  const char *create_table[]=
+  {
+    "DROP TABLE IF EXISTS t1",
+    "CREATE TABLE t1 (i INT)",
+    "INSERT INTO t1 VALUES (1), (2), (3)"
+  };
+  const char *query= "SELECT * FROM t1";
+
+  Stmt_fetch *fetch_array=
+    (Stmt_fetch*) calloc(cursor_count, sizeof(Stmt_fetch));
+
+  Stmt_fetch *fetch;
+
+  FAIL_IF(fill_tables(mysql, create_table, sizeof(create_table) / sizeof(*create_table)), "fill_tables failed");
+
+  for (fetch= fetch_array; fetch < fetch_array + cursor_count; ++fetch)
+  {
+    if ((retcode= stmt_fetch_init(mysql, fetch, (unsigned int)(fetch - fetch_array), query)))
+      break;
+  }
+
+  for (fetch= fetch_array; fetch < fetch_array + cursor_count; ++fetch)
+    stmt_fetch_close(fetch);
+
+  free(fetch_array);
+
+  return retcode;
+}
+
+static int test_bug10729(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  char a[21];
+  int rc;
+  const char *stmt_text;
+  int i= 0;
+  const char *name_array[3]= { "aaa", "bbb", "ccc" };
+  ulong type;
+
+  mysql_query(mysql, "drop table if exists t1");
+  mysql_query(mysql, "create table t1 (id integer not null primary key,"
+                                      "name VARCHAR(20) NOT NULL)");
+  rc= mysql_query(mysql, "insert into t1 (id, name) values "
+                         "(1, 'aaa'), (2, 'bbb'), (3, 'ccc')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  type= (ulong) CURSOR_TYPE_READ_ONLY;
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);
+  check_stmt_rc(rc, stmt);
+  stmt_text= "select name from t1";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void*) a;
+  my_bind[0].buffer_length= sizeof(a);
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  for (i= 0; i < 3; i++)
+  {
+    int row_no= 0;
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    while ((rc= mysql_stmt_fetch(stmt)) == 0)
+    {
+      FAIL_UNLESS(strcmp(a, name_array[row_no]) == 0, "a != name_array[row_no]");
+      ++row_no;
+    }
+    FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+  }
+  rc= mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Bug#10736: cursors and subqueries, memroot management */
+
+static int test_bug10736(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  char a[21];
+  int rc;
+  const char *stmt_text;
+  int i= 0;
+  ulong type;
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (id integer not null primary key,"
+                                      "name VARCHAR(20) NOT NULL)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 (id, name) values "
+                         "(1, 'aaa'), (2, 'bbb'), (3, 'ccc')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+
+  type= (ulong) CURSOR_TYPE_READ_ONLY;
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);
+  check_stmt_rc(rc, stmt);
+  stmt_text= "select name from t1 where name=(select name from t1 where id=2)";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void*) a;
+  my_bind[0].buffer_length= sizeof(a);
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  for (i= 0; i < 3; i++)
+  {
+    int row_no= 0;
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    while ((rc= mysql_stmt_fetch(stmt)) == 0)
+      ++row_no;
+    FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+  }
+  rc= mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Bug#10794: cursors, packets out of order */
+
+static int test_bug10794(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt, *stmt1;
+  MYSQL_BIND my_bind[2];
+  char a[21];
+  int id_val;
+  ulong a_len;
+  int rc;
+  const char *stmt_text;
+  int i= 0;
+  ulong type;
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (id integer not null primary key,"
+                                      "name varchar(20) not null)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "insert into t1 (id, name) values (?, ?)";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void*) &id_val;
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= (void*) a;
+  my_bind[1].length= &a_len;
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+  for (i= 0; i < 42; i++)
+  {
+    id_val= (i+1)*10;
+    sprintf(a, "a%d", i);
+    a_len= (unsigned long)strlen(a); /* safety against broken sprintf */
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+  stmt_text= "select name from t1";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  type= (ulong) CURSOR_TYPE_READ_ONLY;
+  mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+  stmt1= mysql_stmt_init(mysql);
+  mysql_stmt_attr_set(stmt1, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void*) a;
+  my_bind[0].buffer_length= sizeof(a);
+  my_bind[0].length= &a_len;
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  /* Don't optimize: an attribute of the original test case */
+  mysql_stmt_free_result(stmt);
+  mysql_stmt_reset(stmt);
+  stmt_text= "select name from t1 where id=10";
+  rc= mysql_stmt_prepare(stmt1, SL(stmt_text));
+  check_stmt_rc(rc, stmt1);
+  rc= mysql_stmt_bind_result(stmt1, my_bind);
+  check_stmt_rc(rc, stmt1);
+  rc= mysql_stmt_execute(stmt1);
+  check_stmt_rc(rc, stmt1);
+  while (1)
+  {
+    rc= mysql_stmt_fetch(stmt1);
+    if (rc == MYSQL_NO_DATA)
+    {
+      break;
+    }
+    check_stmt_rc(rc, stmt1);
+  }
+  mysql_stmt_close(stmt);
+  mysql_stmt_close(stmt1);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Bug#10760: cursors, crash in a fetch after rollback. */
+
+static int test_bug10760(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  int rc;
+  const char *stmt_text;
+  char id_buf[20];
+  ulong id_len;
+  int i= 0;
+  ulong type;
+
+  rc= mysql_query(mysql, "drop table if exists t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  /* create tables */
+  rc= mysql_query(mysql, "create table t1 (id integer not null primary key)"
+                         " engine=MyISAM");
+  check_mysql_rc(rc, mysql);;
+  for (; i < 42; ++i)
+  {
+    char buf[100];
+    sprintf(buf, "insert into t1 (id) values (%d)", i+1);
+    rc= mysql_query(mysql, buf);
+    check_mysql_rc(rc, mysql);;
+  }
+  mysql_autocommit(mysql, FALSE);
+  /* create statement */
+  stmt= mysql_stmt_init(mysql);
+  type= (ulong) CURSOR_TYPE_READ_ONLY;
+  mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+
+  /*
+    1: check that a deadlock within the same connection
+    is resolved and an error is returned. The deadlock is modelled
+    as follows:
+    con1: open cursor for select * from t1;
+    con1: insert into t1 (id) values (1)
+  */
+  stmt_text= "select id from t1 order by 1";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);;
+  rc= mysql_query(mysql, "update t1 set id=id+100");
+  /*
+    If cursors are not materialized, the update will return an error;
+    we mainly test that it won't deadlock.
+  */
+  /*  FAIL_IF(!rc, "Error expected"); */
+  /*
+    2: check that MyISAM tables used in cursors survive
+    COMMIT/ROLLBACK.
+  */
+  rc= mysql_rollback(mysql);                  /* should not close the cursor */
+  check_mysql_rc(rc, mysql);;
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);;
+
+  /*
+    3: check that cursors to InnoDB tables are closed (for now) by
+    COMMIT/ROLLBACK.
+  */
+  if (check_variable(mysql, "@@have_innodb", "YES"))
+  {
+    stmt_text= "select id from t1 order by 1";
+    rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+    check_stmt_rc(rc, stmt);;
+
+    rc= mysql_query(mysql, "alter table t1 engine=InnoDB");
+    check_mysql_rc(rc, mysql);;
+
+    memset(my_bind, '\0', sizeof(my_bind));
+    my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+    my_bind[0].buffer= (void*) id_buf;
+    my_bind[0].buffer_length= sizeof(id_buf);
+    my_bind[0].length= &id_len;
+    check_stmt_rc(rc, stmt);;
+    mysql_stmt_bind_result(stmt, my_bind);
+
+    rc= mysql_stmt_execute(stmt);
+    rc= mysql_stmt_fetch(stmt);
+    FAIL_UNLESS(rc == 0, "rc != 0");
+    rc= mysql_rollback(mysql);                  /* should close the cursor */
+  }
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_autocommit(mysql, TRUE);                /* restore default */
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Bug#11172: cursors, crash on a fetch from a datetime column */
+
+static int test_bug11172(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind_in[1], bind_out[2];
+  MYSQL_TIME hired;
+  int rc;
+  const char *stmt_text;
+  int i= 0, id;
+  ulong type;
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (id integer not null primary key,"
+                                      "hired date not null)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "insert into t1 (id, hired) values (1, '1933-08-24'), "
+                  "(2, '1965-01-01'), (3, '1949-08-17'), (4, '1945-07-07'), "
+                  "(5, '1941-05-15'), (6, '1978-09-15'), (7, '1936-03-28')");
+  check_mysql_rc(rc, mysql);
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  stmt_text= "SELECT id, hired FROM t1 WHERE hired=?";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  type= (ulong) CURSOR_TYPE_READ_ONLY;
+  mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+
+  memset(bind_in, '\0', sizeof(bind_in));
+  memset(bind_out, '\0', sizeof(bind_out));
+  memset(&hired, '\0', sizeof(hired));
+  hired.year= 1965;
+  hired.month= 1;
+  hired.day= 1;
+  bind_in[0].buffer_type= MYSQL_TYPE_DATE;
+  bind_in[0].buffer= (void*) &hired;
+  bind_in[0].buffer_length= sizeof(hired);
+  bind_out[0].buffer_type= MYSQL_TYPE_LONG;
+  bind_out[0].buffer= (void*) &id;
+  bind_out[1]= bind_in[0];
+
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_bind_param(stmt, bind_in);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_bind_result(stmt, bind_out);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    while ((rc= mysql_stmt_fetch(stmt)) == 0);
+    FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+    if (!mysql_stmt_free_result(stmt))
+      mysql_stmt_reset(stmt);
+  }
+  mysql_stmt_close(stmt);
+  mysql_rollback(mysql);
+  mysql_rollback(mysql);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Bug#11656: cursors, crash on a fetch from a query with distinct. */
+
+static int test_bug11656(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[2];
+  int rc;
+  const char *stmt_text;
+  char buf[2][20];
+  int i= 0;
+  ulong type;
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 ("
+                  "server varchar(40) not null, "
+                  "test_kind varchar(1) not null, "
+                  "test_id varchar(30) not null , "
+                  "primary key (server,test_kind,test_id))");
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "select distinct test_kind, test_id from t1 "
+             "where server in (?, ?)";
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  type= (ulong) CURSOR_TYPE_READ_ONLY;
+  mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  strcpy(buf[0], "pcint502_MY2");
+  strcpy(buf[1], "*");
+  for (i=0; i < 2; i++)
+  {
+    my_bind[i].buffer_type= MYSQL_TYPE_STRING;
+    my_bind[i].buffer= (uchar* *)&buf[i];
+    my_bind[i].buffer_length= (unsigned long)strlen(buf[i]);
+  }
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Cursors: opening a cursor to a compilicated query with ORDER BY */
+
+static int test_bug11901(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[2];
+  int rc;
+  char workdept[20];
+  ulong workdept_len; 
+  uint32 empno; 
+  const ulong type= (ulong)CURSOR_TYPE_READ_ONLY;
+  const char *stmt_text;
+
+
+  stmt_text= "drop table if exists t1, t2";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "create table t1 ("
+    "  empno int(11) not null, firstname varchar(20) not null,"
+    "  midinit varchar(20) not null, lastname varchar(20) not null,"
+    "  workdept varchar(6) not null, salary double not null,"
+    "  bonus float not null, primary key (empno), "
+    " unique key (workdept, empno) "
+    ") default charset=latin1 collate=latin1_bin";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "insert into t1 values "
+     "(10,  'CHRISTINE', 'I', 'HAAS',      'A00', 52750, 1000),"
+     "(20,  'MICHAEL',   'L', 'THOMPSON',  'B01', 41250, 800), "
+     "(30,  'SALLY',     'A', 'KWAN',      'C01', 38250, 800), "
+     "(50,  'JOHN',      'B', 'GEYER',     'E01', 40175, 800), "
+     "(60,  'IRVING',    'F', 'STERN',     'D11', 32250, 500), "
+     "(70,  'EVA',       'D', 'PULASKI',   'D21', 36170, 700), "
+     "(90,  'EILEEN',    'W', 'HENDERSON', 'E11', 29750, 600), "
+     "(100, 'THEODORE',  'Q', 'SPENSER',   'E21', 26150, 500), "
+     "(110, 'VINCENZO',  'G', 'LUCCHESSI', 'A00', 46500, 900), "
+     "(120, 'SEAN',      '',  'O\\'CONNELL', 'A00', 29250, 600), "
+     "(130, 'DOLORES',   'M', 'QUINTANA',  'C01', 23800, 500), "
+     "(140, 'HEATHER',   'A', 'NICHOLLS',  'C01', 28420, 600), "
+     "(150, 'BRUCE',     '',  'ADAMSON',   'D11', 25280, 500), "
+     "(160, 'ELIZABETH', 'R', 'PIANKA',    'D11', 22250, 400), "
+     "(170, 'MASATOSHI', 'J', 'YOSHIMURA', 'D11', 24680, 500), "
+     "(180, 'MARILYN',   'S', 'SCOUTTEN',  'D11', 21340, 500), "
+     "(190, 'JAMES',     'H', 'WALKER',    'D11', 20450, 400), "
+     "(200, 'DAVID',     '',  'BROWN',     'D11', 27740, 600), "
+     "(210, 'WILLIAM',   'T', 'JONES',     'D11', 18270, 400), "
+     "(220, 'JENNIFER',  'K', 'LUTZ',      'D11', 29840, 600), "
+     "(230, 'JAMES',     'J', 'JEFFERSON', 'D21', 22180, 400), "
+     "(240, 'SALVATORE', 'M', 'MARINO',    'D21', 28760, 600), "
+     "(250, 'DANIEL',    'S', 'SMITH',     'D21', 19180, 400), "
+     "(260, 'SYBIL',     'P', 'JOHNSON',   'D21', 17250, 300), "
+     "(270, 'MARIA',     'L', 'PEREZ',     'D21', 27380, 500), "
+     "(280, 'ETHEL',     'R', 'SCHNEIDER', 'E11', 26250, 500), "
+     "(290, 'JOHN',      'R', 'PARKER',    'E11', 15340, 300), "
+     "(300, 'PHILIP',    'X', 'SMITH',     'E11', 17750, 400), "
+     "(310, 'MAUDE',     'F', 'SETRIGHT',  'E11', 15900, 300), "
+     "(320, 'RAMLAL',    'V', 'MEHTA',     'E21', 19950, 400), "
+     "(330, 'WING',      '',  'LEE',       'E21', 25370, 500), "
+     "(340, 'JASON',     'R', 'GOUNOT',    'E21', 23840, 500)";
+
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "create table t2 ("
+    " deptno varchar(6) not null, deptname varchar(20) not null,"
+    " mgrno int(11) not null, location varchar(20) not null,"
+    " admrdept varchar(6) not null, refcntd int(11) not null,"
+    " refcntu int(11) not null, primary key (deptno)"
+    ") default charset=latin1 collate=latin1_bin";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "insert into t2 values "
+    "('A00', 'SPIFFY COMPUTER SERV', 10, '', 'A00', 0, 0), "
+    "('B01', 'PLANNING',             20, '', 'A00', 0, 0), "
+    "('C01', 'INFORMATION CENTER',   30, '', 'A00', 0, 0), "
+    "('D01', 'DEVELOPMENT CENTER',   0,  '', 'A00', 0, 0),"
+    "('D11', 'MANUFACTURING SYSTEM', 60, '', 'D01', 0, 0), "
+    "('D21', 'ADMINISTRATION SYSTE', 70, '', 'D01', 0, 0), "
+    "('E01', 'SUPPORT SERVICES',     50, '', 'A00', 0, 0), "
+    "('E11', 'OPERATIONS',           90, '', 'E01', 0, 0), "
+    "('E21', 'SOFTWARE SUPPORT',     100,'', 'E01', 0, 0)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text=        "select t1.empno, t1.workdept "
+                    "from (t1 left join t2 on t2.deptno = t1.workdept) "
+                    "where t2.deptno in "
+                    "   (select t2.deptno "
+                    "    from (t1 left join t2 on t2.deptno = t1.workdept) "
+                    "    where t1.empno = ?) "
+                    "order by 1";
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);
+  check_stmt_rc(rc, stmt);
+
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= &empno;
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  my_bind[1].buffer_type= MYSQL_TYPE_VAR_STRING;
+  my_bind[1].buffer= (void*) workdept;
+  my_bind[1].buffer_length= sizeof(workdept);
+  my_bind[1].length= &workdept_len;
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  empno= 10;
+
+  /* ERROR: next statement causes a server crash */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Bug#11904: mysql_stmt_attr_set CURSOR_TYPE_READ_ONLY grouping wrong result */
+
+static int test_bug11904(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt1;
+  int rc;
+  const char *stmt_text;
+  const ulong type= (ulong)CURSOR_TYPE_READ_ONLY;
+  MYSQL_BIND my_bind[2];
+  int country_id=0;
+  char row_data[11]= {0};
+
+  /* create tables */
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bug11904b");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE bug11904b (id int, name char(10), primary key(id, name))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO bug11904b VALUES (1, 'sofia'), (1,'plovdiv'),"
+                          " (1,'varna'), (2,'LA'), (2,'new york'), (3,'heidelberg'),"
+                          " (3,'berlin'), (3, 'frankfurt')");
+
+  check_mysql_rc(rc, mysql);
+  mysql_commit(mysql);
+  /* create statement */
+  stmt1= mysql_stmt_init(mysql);
+  mysql_stmt_attr_set(stmt1, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+
+  stmt_text= "SELECT id, MIN(name) FROM bug11904b GROUP BY id ORDER BY id";
+
+  rc= mysql_stmt_prepare(stmt1, SL(stmt_text));
+  check_stmt_rc(rc, stmt1);
+
+  memset(my_bind, 0, sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer=& country_id;
+  my_bind[0].buffer_length= 0;
+  my_bind[0].length= 0;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer=& row_data;
+  my_bind[1].buffer_length= sizeof(row_data) - 1;
+  my_bind[1].length= 0;
+
+  rc= mysql_stmt_bind_result(stmt1, my_bind);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_execute(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_fetch(stmt1);
+  check_stmt_rc(rc, stmt1);
+  FAIL_UNLESS(country_id == 1, "country_id != 1");
+  FAIL_UNLESS(memcmp(row_data, "plovdiv", 7) == 0, "row_data != 'plovdiv'");
+
+  rc= mysql_stmt_fetch(stmt1);
+  check_stmt_rc(rc, stmt1);
+  FAIL_UNLESS(country_id == 2, "country_id != 2");
+  FAIL_UNLESS(memcmp(row_data, "LA", 2) == 0, "row_data != 'LA'");
+
+  rc= mysql_stmt_fetch(stmt1);
+  check_stmt_rc(rc, stmt1);
+  FAIL_UNLESS(country_id == 3, "country_id != 3");
+  FAIL_UNLESS(memcmp(row_data, "berlin", 6) == 0, "row_data != 'Berlin'");
+
+  rc= mysql_stmt_close(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_query(mysql, "drop table bug11904b");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+/* Bug#12243: multiple cursors, crash in a fetch after commit. */
+
+static int test_bug12243(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt1, *stmt2;
+  int rc;
+  const char *stmt_text;
+  ulong type;
+
+  if (!check_variable(mysql, "@@have_innodb", "YES"))
+  {
+    diag("Skip -> Test required InnoDB");
+    return SKIP;
+  }
+
+  /* create tables */
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (a int) engine=InnoDB");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 (a) values (1), (2)");
+  check_mysql_rc(rc, mysql);
+  mysql_autocommit(mysql, FALSE);
+  /* create statement */
+  stmt1= mysql_stmt_init(mysql);
+  stmt2= mysql_stmt_init(mysql);
+  type= (ulong) CURSOR_TYPE_READ_ONLY;
+  rc= mysql_stmt_attr_set(stmt1, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+  check_stmt_rc(rc, stmt1);
+  rc= mysql_stmt_attr_set(stmt2, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+  check_stmt_rc(rc, stmt1);
+
+  stmt_text= "select a from t1";
+
+  rc= mysql_stmt_prepare(stmt1, SL(stmt_text));
+  check_stmt_rc(rc, stmt1);
+  rc= mysql_stmt_execute(stmt1);
+  check_stmt_rc(rc, stmt1);
+  rc= mysql_stmt_fetch(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_prepare(stmt2, SL(stmt_text));
+  check_stmt_rc(rc, stmt2);
+  rc= mysql_stmt_execute(stmt2);
+  check_stmt_rc(rc, stmt2);
+  rc= mysql_stmt_fetch(stmt2);
+  check_stmt_rc(rc, stmt2);
+
+  rc= mysql_stmt_close(stmt1);
+  check_stmt_rc(rc, stmt1);
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+  rc= mysql_stmt_fetch(stmt2);
+  check_stmt_rc(rc, stmt2);
+
+  mysql_stmt_close(stmt2);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  mysql_autocommit(mysql, TRUE);                /* restore default */
+
+  return OK;
+}
+
+/* Bug#11909: wrong metadata if fetching from two cursors */
+
+static int test_bug11909(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt1, *stmt2;
+  MYSQL_BIND my_bind[7];
+  int rc;
+  char firstname[20], midinit[20], lastname[20], workdept[20];
+  ulong firstname_len, midinit_len, lastname_len, workdept_len;
+  uint32 empno;
+  double salary;
+  float bonus;
+  const char *stmt_text;
+  const ulong type= (ulong)CURSOR_TYPE_READ_ONLY;
+
+
+  stmt_text= "drop table if exists t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "create table t1 ("
+    "  empno int(11) not null, firstname varchar(20) not null,"
+    "  midinit varchar(20) not null, lastname varchar(20) not null,"
+    "  workdept varchar(6) not null, salary double not null,"
+    "  bonus float not null, primary key (empno)"
+    ") default charset=latin1 collate=latin1_bin";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "insert into t1 values "
+    "(10, 'CHRISTINE', 'I', 'HAAS',     'A00', 52750, 1000), "
+    "(20, 'MICHAEL',   'L', 'THOMPSON', 'B01', 41250, 800),"
+    "(30, 'SALLY',     'A', 'KWAN',     'C01', 38250, 800),"
+    "(50, 'JOHN',      'B', 'GEYER',    'E01', 40175, 800), "
+    "(60, 'IRVING',    'F', 'STERN',    'D11', 32250, 500)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  /* ****** Begin of trace ****** */
+
+  stmt_text= "SELECT empno, firstname, midinit, lastname,"
+             "workdept, salary, bonus FROM t1 ORDER BY empno";
+  stmt1= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt1, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt1, SL(stmt_text));
+  check_stmt_rc(rc, stmt1);
+  mysql_stmt_attr_set(stmt1, STMT_ATTR_CURSOR_TYPE,
+                      (const void*) &type);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void*) &empno;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_VAR_STRING;
+  my_bind[1].buffer= (void*) firstname;
+  my_bind[1].buffer_length= sizeof(firstname);
+  my_bind[1].length= &firstname_len;
+
+  my_bind[2].buffer_type= MYSQL_TYPE_VAR_STRING;
+  my_bind[2].buffer= (void*) midinit;
+  my_bind[2].buffer_length= sizeof(midinit);
+  my_bind[2].length= &midinit_len;
+
+  my_bind[3].buffer_type= MYSQL_TYPE_VAR_STRING;
+  my_bind[3].buffer= (void*) lastname;
+  my_bind[3].buffer_length= sizeof(lastname);
+  my_bind[3].length= &lastname_len;
+
+  my_bind[4].buffer_type= MYSQL_TYPE_VAR_STRING;
+  my_bind[4].buffer= (void*) workdept;
+  my_bind[4].buffer_length= sizeof(workdept);
+  my_bind[4].length= &workdept_len;
+
+  my_bind[5].buffer_type= MYSQL_TYPE_DOUBLE;
+  my_bind[5].buffer= (void*) &salary;
+
+  my_bind[6].buffer_type= MYSQL_TYPE_FLOAT;
+  my_bind[6].buffer= (void*) &bonus;
+  rc= mysql_stmt_bind_result(stmt1, my_bind);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_execute(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_fetch(stmt1);
+  FAIL_UNLESS(rc == 0, "rc != 0");
+  FAIL_UNLESS(empno == 10, "empno != 10");
+  FAIL_UNLESS(strcmp(firstname, "CHRISTINE""") == 0, "firstname != 'Christine'");
+  FAIL_UNLESS(strcmp(midinit, "I""") == 0, "");
+  FAIL_UNLESS(strcmp(lastname, "HAAS""") == 0, "lastname != 'HAAS'");
+  FAIL_UNLESS(strcmp(workdept, "A00""") == 0, "workdept != 'A00'");
+  FAIL_UNLESS(salary == (double) 52750.0, "salary != 52750");
+  FAIL_UNLESS(bonus == (float) 1000.0, "bonus =! 1000");
+
+  stmt_text = "SELECT empno, firstname FROM t1";
+  stmt2= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt2, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt2, SL(stmt_text));
+  check_stmt_rc(rc, stmt2);
+  mysql_stmt_attr_set(stmt2, STMT_ATTR_CURSOR_TYPE,
+                      (const void*) &type);
+  rc= mysql_stmt_bind_result(stmt2, my_bind);
+  check_stmt_rc(rc, stmt2);
+
+  rc= mysql_stmt_execute(stmt2);
+  check_stmt_rc(rc, stmt2);
+
+  rc= mysql_stmt_fetch(stmt2);
+  FAIL_UNLESS(rc == 0, "rc != 0");
+
+  FAIL_UNLESS(empno == 10, "empno != 10");
+  FAIL_UNLESS(strcmp(firstname, "CHRISTINE""") == 0, "firstname != 'Christine'");
+
+  rc= mysql_stmt_reset(stmt2);
+  check_stmt_rc(rc, stmt2);
+
+  /* ERROR: next statement should return 0 */
+
+  rc= mysql_stmt_fetch(stmt1);
+  FAIL_UNLESS(rc == 0, "rc != 0");
+
+  mysql_stmt_close(stmt1);
+  mysql_stmt_close(stmt2);
+  rc= mysql_rollback(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Bug#13488: wrong column metadata when fetching from cursor */
+
+static int test_bug13488(MYSQL *mysql)
+{
+  MYSQL_BIND my_bind[3];
+  MYSQL_STMT *stmt1;
+  int rc, f1, f2, f3, i;
+  const ulong type= CURSOR_TYPE_READ_ONLY;
+  const char *query= "select f1, f2, f3 from t1 left join t2 on f1=f2 where f1=1";
+
+
+  rc= mysql_query(mysql, "drop table if exists t1, t2");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (f1 int not null primary key)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t2 (f2 int not null primary key, "
+                  "f3 int not null)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 values (1), (2)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t2 values (1,2), (2,4)");
+  check_mysql_rc(rc, mysql);
+
+  memset(my_bind, 0, sizeof(my_bind));
+  for (i= 0; i < 3; i++)
+  {
+    my_bind[i].buffer_type= MYSQL_TYPE_LONG;
+    my_bind[i].buffer_length= 4;
+    my_bind[i].length= 0;
+  }
+  my_bind[0].buffer=&f1;
+  my_bind[1].buffer=&f2;
+  my_bind[2].buffer=&f3;
+
+  stmt1= mysql_stmt_init(mysql);
+  rc= mysql_stmt_attr_set(stmt1,STMT_ATTR_CURSOR_TYPE, (const void *)&type);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_prepare(stmt1, SL(query));
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_execute(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_bind_result(stmt1, my_bind);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_fetch(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_free_result(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_reset(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_close(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  FAIL_UNLESS(f1 == 1, "f1 != 1");
+  FAIL_UNLESS(f2 == 1, "f2 != 1");
+  FAIL_UNLESS(f3 == 2, "f3 != 2");
+  rc= mysql_query(mysql, "drop table t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/*
+  Bug#13524: warnings of a previous command are not reset when fetching
+  from a cursor.
+*/
+
+static int test_bug13524(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  unsigned int warning_count;
+  const ulong type= CURSOR_TYPE_READ_ONLY;
+  const char *query= "select * from t1";
+
+
+  rc= mysql_query(mysql, "drop table if exists t1, t2");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (a int not null primary key)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 values (1), (2), (3), (4)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  warning_count= mysql_warning_count(mysql);
+  FAIL_UNLESS(warning_count == 0, "warning_count != 0");
+
+  /* Check that DROP TABLE produced a warning (no such table) */
+  rc= mysql_query(mysql, "drop table if exists t2");
+  check_mysql_rc(rc, mysql);
+  warning_count= mysql_warning_count(mysql);
+  FAIL_UNLESS(warning_count == 1, "warning_count != 1");
+
+  /*
+    Check that fetch from a cursor cleared the warning from the previous
+    command.
+  */
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  warning_count= mysql_warning_count(mysql);
+  FAIL_UNLESS(warning_count == 0, "warning_count != 0");
+
+  /* Cleanup */
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/*
+  Bug#14845 "mysql_stmt_fetch returns MYSQL_NO_DATA when COUNT(*) is 0"
+*/
+
+static int test_bug14845(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const ulong type= CURSOR_TYPE_READ_ONLY;
+  const char *query= "select count(*) from t1 where 1 = 0";
+
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (id int(11) default null, "
+                         "name varchar(20) default null)"
+                         "engine=MyISAM DEFAULT CHARSET=utf8");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 values (1,'abc'),(2,'def')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == 0, "");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "");
+
+  /* Cleanup */
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/*
+  Bug#14210 "Simple query with > operator on large table gives server
+  crash"
+*/
+
+static int test_bug14210(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  const char *stmt_text;
+  ulong type;
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  /*
+    To trigger the problem the table must be InnoDB, although the problem
+    itself is not InnoDB related. In case the table is MyISAM this test
+    is harmless.
+  */
+  rc= mysql_query(mysql, "create table t1 (a varchar(255)) engine=InnoDB");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 (a) values (repeat('a', 256))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "set @@session.max_heap_table_size=16384");
+
+  /* Create a big enough table (more than max_heap_table_size) */
+  for (i= 0; i < 8; i++)
+  {
+    rc= mysql_query(mysql, "insert into t1 (a) select a from t1");
+    check_mysql_rc(rc, mysql);
+  }
+  /* create statement */
+  stmt= mysql_stmt_init(mysql);
+  type= (ulong) CURSOR_TYPE_READ_ONLY;
+  mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void*) &type);
+
+  stmt_text= "select a from t1";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  while ((rc= mysql_stmt_fetch(stmt)) == 0);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  rc= mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "set @@session.max_heap_table_size=default");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/*
+  Bug#24179 "select b into $var" fails with --cursor_protocol"
+  The failure is correct, check that the returned message is meaningful.
+*/
+
+static int test_bug24179(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+
+  stmt= open_cursor(mysql, "select 1 into @a");
+  rc= mysql_stmt_execute(stmt);
+  FAIL_UNLESS(rc, "Error expected");
+  FAIL_UNLESS(mysql_stmt_errno(stmt) == 1323, "stmt_errno != 1323");
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+/**
+  Bug#32265 Server returns different metadata if prepared statement is used
+*/
+
+static int test_bug32265(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  MYSQL_FIELD *field;
+  MYSQL_RES *metadata;
+
+  if (mysql_get_server_version(mysql) < 50100) {
+    diag("Test requires MySQL Server version 5.1 or above");
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW IF EXISTS v1");
+  rc= mysql_query(mysql, "CREATE  TABLE t1 (a INTEGER)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE VIEW v1 AS SELECT * FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  stmt= open_cursor(mysql, "SELECT * FROM t1");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  metadata= mysql_stmt_result_metadata(stmt);
+  field= mysql_fetch_field(metadata);
+  FAIL_UNLESS(field, "couldn't fetch field");
+  FAIL_UNLESS(strcmp(field->table, "t1") == 0, "table != t1");
+  FAIL_UNLESS(strcmp(field->org_table, "t1") == 0, "org_table != t1");
+  FAIL_UNLESS(strcmp(field->db, schema) == 0, "db != schema");
+  mysql_free_result(metadata);
+  mysql_stmt_close(stmt);
+
+  stmt= open_cursor(mysql, "SELECT a '' FROM t1 ``");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  metadata= mysql_stmt_result_metadata(stmt);
+  field= mysql_fetch_field(metadata);
+  FAIL_UNLESS(strcmp(field->table, "") == 0, "field != ''");
+  FAIL_UNLESS(strcmp(field->org_table, "t1") == 0, "org_table != t1");
+  FAIL_UNLESS(strcmp(field->db, schema) == 0, "db != schema");
+  mysql_free_result(metadata);
+  mysql_stmt_close(stmt);
+
+  stmt= open_cursor(mysql, "SELECT a '' FROM t1 ``");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  metadata= mysql_stmt_result_metadata(stmt);
+  field= mysql_fetch_field(metadata);
+  FAIL_UNLESS(strcmp(field->table, "") == 0, "table != ''");
+  FAIL_UNLESS(strcmp(field->org_table, "t1") == 0, "org_table != t1");
+  FAIL_UNLESS(strcmp(field->db, schema) == 0, "db != schema");
+  mysql_free_result(metadata);
+  mysql_stmt_close(stmt);
+
+  stmt= open_cursor(mysql, "SELECT * FROM v1");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  metadata= mysql_stmt_result_metadata(stmt);
+  field= mysql_fetch_field(metadata);
+  FAIL_UNLESS(strcmp(field->table, "v1") == 0, "table != v1");
+  FAIL_UNLESS(strcmp(field->org_table, "v1") == 0, "org_table != v1");
+  FAIL_UNLESS(strcmp(field->db, schema) == 0, "db != schema");
+  mysql_free_result(metadata);
+  mysql_stmt_close(stmt);
+
+  stmt= open_cursor(mysql, "SELECT * FROM v1 /* SIC */ GROUP BY 1");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  metadata= mysql_stmt_result_metadata(stmt);
+  field= mysql_fetch_field(metadata);
+  FAIL_UNLESS(strcmp(field->table, "v1") == 0, "table != v1");
+  FAIL_UNLESS(strcmp(field->org_table, "v1") == 0, "org_table != v1");
+  FAIL_UNLESS(strcmp(field->db, schema) == 0, "schema != db");
+  mysql_free_result(metadata);
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP VIEW v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/**
+  Bug#38486 Crash when using cursor protocol
+*/
+
+static int test_bug38486(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  const char *stmt_text;
+  int rc;
+  unsigned long type= CURSOR_TYPE_READ_ONLY;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t10");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t10 (a INT)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*)&type);
+  check_stmt_rc(rc, stmt);
+  stmt_text= "INSERT INTO t10 VALUES (1)";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_bug8880(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt_list[2], **stmt;
+  MYSQL_STMT **stmt_list_end= (MYSQL_STMT**) stmt_list + 2;
+  int rc;
+
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (a int not null primary key, b int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 values (1,1)");
+  check_mysql_rc(rc, mysql);
+  /*
+    when inserting 2 rows everything works well
+    mysql_query(mysql, "INSERT INTO t1 VALUES (1,1),(2,2)");
+  */
+  for (stmt= stmt_list; stmt < stmt_list_end; stmt++)
+    *stmt= open_cursor(mysql, "select a from t1");
+  for (stmt= stmt_list; stmt < stmt_list_end; stmt++)
+  {
+    rc= mysql_stmt_execute(*stmt);
+    check_stmt_rc(rc, *stmt);
+  }
+  for (stmt= stmt_list; stmt < stmt_list_end; stmt++)
+    mysql_stmt_close(*stmt);
+  return OK;
+}
+
+static int test_bug9159(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *stmt_text= "select a, b from t1";
+  const unsigned long type= CURSOR_TYPE_READ_ONLY;
+
+
+  mysql_query(mysql, "drop table if exists t1");
+  mysql_query(mysql, "create table t1 (a int not null primary key, b int)");
+  rc= mysql_query(mysql, "insert into t1 values (1,1)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  mysql_stmt_prepare(stmt, SL(stmt_text));
+  mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void *)&type);
+
+  mysql_stmt_execute(stmt);
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/*
+  We can't have more than one cursor open for a prepared statement.
+  Test re-executions of a PS with cursor; mysql_stmt_reset must close
+  the cursor attached to the statement, if there is one.
+*/
+
+static int test_bug9478(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  char a[6];
+  ulong a_len;
+  int rc, i;
+
+  mysql_query(mysql, "drop table if exists t1");
+  mysql_query(mysql, "create table t1 (id integer not null primary key, "
+                     " name varchar(20) not null)");
+  rc= mysql_query(mysql, "insert into t1 (id, name) values "
+                         " (1, 'aaa'), (2, 'bbb'), (3, 'ccc')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= open_cursor(mysql, "select name from t1 where id=2");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (char*) a;
+  my_bind[0].buffer_length= sizeof(a);
+  my_bind[0].length= &a_len;
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  for (i= 0; i < 5; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_fetch(stmt);
+    check_stmt_rc(rc, stmt);
+
+    /*
+      The query above is a one-row result set. Therefore, there is no
+      cursor associated with it, as the server won't bother with opening
+      a cursor for a one-row result set. The first row was read from the
+      server in the fetch above. But there is eof packet pending in the
+      network. mysql_stmt_execute will flush the packet and successfully
+      execute the statement.
+    */
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_fetch(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_fetch(stmt);
+    FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+    {
+      char buff[8];
+      /* Fill in the fetch packet */
+      int4store(buff, stmt->stmt_id);
+      buff[4]= 1;                               /* prefetch rows */
+/*      rc= ((*mysql->methods->advanced_command)(mysql, COM_STMT_FETCH,
+                                               (uchar*) buff,
+                                               sizeof(buff), 0,0,1,NULL) ||
+           (*mysql->methods->read_query_result)(mysql)); */
+      FAIL_UNLESS(rc, "error expected");
+    }
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_fetch(stmt);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_reset(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_fetch(stmt);
+
+    /* mariadb client supports GEOMETRY, so no error will
+       be returned 
+    FAIL_UNLESS(rc && mysql_stmt_errno(stmt), "Error expected");
+    */
+  }
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /* Test the case with a server side cursor */
+  stmt= open_cursor(mysql, "select name from t1");
+
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  for (i= 0; i < 5; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_fetch(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    while (! (rc= mysql_stmt_fetch(stmt)));
+    FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_fetch(stmt);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_reset(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_fetch(stmt);
+    FAIL_UNLESS(rc && mysql_stmt_errno(stmt), "Error expected");
+  }
+
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Crash when opening a cursor to a query with DISTICNT and no key */
+
+static int test_bug9520(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  char a[6];
+  ulong a_len;
+  int rc, row_count= 0;
+
+
+  mysql_query(mysql, "drop table if exists t1");
+  mysql_query(mysql, "create table t1 (a char(5), b char(5), c char(5),"
+                     " primary key (a, b, c))");
+  rc= mysql_query(mysql, "insert into t1 values ('x', 'y', 'z'), "
+                  " ('a', 'b', 'c'), ('k', 'l', 'm')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= open_cursor(mysql, "select distinct b from t1");
+
+  /*
+    Not crashes with:
+    stmt= open_cursor(mysql, "select distinct a from t1");
+  */
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (char*) a;
+  my_bind[0].buffer_length= sizeof(a);
+  my_bind[0].length= &a_len;
+
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  while (!(rc= mysql_stmt_fetch(stmt)))
+    row_count++;
+
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  FAIL_UNLESS(row_count == 3, "row_count != 3");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/*
+  Error message is returned for unsupported features.
+  Test also cursors with non-default PREFETCH_ROWS
+*/
+
+static int test_bug9643(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  int32 a;
+  int rc;
+  const char *stmt_text;
+  int num_rows= 0;
+  ulong type;
+  ulong prefetch_rows= 5;
+
+
+  mysql_query(mysql, "drop table if exists t1");
+  mysql_query(mysql, "create table t1 (id integer not null primary key)");
+  rc= mysql_query(mysql, "insert into t1 (id) values "
+                         " (1), (2), (3), (4), (5), (6), (7), (8), (9)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  /* Not implemented in 5.0 */
+  type= (ulong) CURSOR_TYPE_SCROLLABLE;
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);
+  FAIL_UNLESS(rc, "Error expected");
+
+  type= (ulong) CURSOR_TYPE_READ_ONLY;
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_PREFETCH_ROWS,
+                          (void*) &prefetch_rows);
+  check_stmt_rc(rc, stmt);
+  stmt_text= "select * from t1";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void*) &a;
+  my_bind[0].buffer_length= sizeof(a);
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  while ((rc= mysql_stmt_fetch(stmt)) == 0)
+    ++num_rows;
+  FAIL_UNLESS(num_rows == 9, "num_rows != 9");
+
+  rc= mysql_stmt_close(stmt);
+  FAIL_UNLESS(rc == 0, "");
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+
+struct my_tests_st my_tests[] = {
+  {"test_basic_cursors", test_basic_cursors, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_cursors_with_union", test_cursors_with_union, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_cursors_with_procedure", test_cursors_with_procedure, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug21206", test_bug21206, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug10729", test_bug10729, TEST_CONNECTION_DEFAULT, 0, NULL , NULL}, 
+  {"test_bug10736", test_bug10736, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug10794", test_bug10794, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug10760", test_bug10760, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug11172", test_bug11172, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug11656", test_bug11656, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug11901", test_bug11901, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug11904", test_bug11904, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug12243", test_bug12243, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug11909", test_bug11909, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug13488", test_bug13488, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug13524", test_bug13524, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug14845", test_bug14845, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug14210", test_bug14210, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug24179", test_bug24179, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug32265", test_bug32265, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug38486", test_bug38486, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug8880", test_bug8880, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug9159", test_bug9159, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug9478", test_bug9478, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug9520", test_bug9520, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug9643", test_bug9643, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/data.csv b/libmariadb/unittest/libmariadb/data.csv
new file mode 100644
index 00000000..07471374
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/data.csv
@@ -0,0 +1,100 @@
+00000100,1,60000.000000
+00000101,2,60000.000000
+00000102,3,60000.000000
+00000103,1,60000.000000
+00000104,2,60000.000000
+00000105,3,60000.000000
+00000106,1,60000.000000
+00000107,2,60000.000000
+00000108,3,60000.000000
+00000109,1,60000.000000
+00000110,2,60000.000000
+00000111,3,60000.000000
+00000112,1,60000.000000
+00000113,2,60000.000000
+00000114,3,60000.000000
+00000115,1,60000.000000
+00000116,2,60000.000000
+00000117,3,60000.000000
+00000118,1,60000.000000
+00000119,2,60000.000000
+00000120,3,60000.000000
+00000121,1,60000.000000
+00000122,2,60000.000000
+00000123,3,60000.000000
+00000124,1,60000.000000
+00000125,2,60000.000000
+00000126,3,60000.000000
+00000127,1,60000.000000
+00000128,2,60000.000000
+00000129,3,60000.000000
+00000130,1,60000.000000
+00000131,2,60000.000000
+00000132,3,60000.000000
+00000133,1,60000.000000
+00000134,2,60000.000000
+00000135,3,60000.000000
+00000136,1,60000.000000
+00000137,2,60000.000000
+00000138,3,60000.000000
+00000139,1,60000.000000
+00000140,2,60000.000000
+00000141,3,60000.000000
+00000142,1,60000.000000
+00000143,2,60000.000000
+00000144,3,60000.000000
+00000145,1,60000.000000
+00000146,2,60000.000000
+00000147,3,60000.000000
+00000148,1,60000.000000
+00000149,2,60000.000000
+00000150,3,60000.000000
+00000151,1,60000.000000
+00000152,2,60000.000000
+00000153,3,60000.000000
+00000154,1,60000.000000
+00000155,2,60000.000000
+00000156,3,60000.000000
+00000157,1,60000.000000
+00000158,2,60000.000000
+00000159,3,60000.000000
+00000160,1,60000.000000
+00000161,2,60000.000000
+00000162,3,60000.000000
+00000163,1,60000.000000
+00000164,2,60000.000000
+00000165,3,60000.000000
+00000166,1,60000.000000
+00000167,2,60000.000000
+00000168,3,60000.000000
+00000169,1,60000.000000
+00000170,2,60000.000000
+00000171,3,60000.000000
+00000172,1,60000.000000
+00000173,2,60000.000000
+00000174,3,60000.000000
+00000175,1,60000.000000
+00000176,2,60000.000000
+00000177,3,60000.000000
+00000178,1,60000.000000
+00000179,2,60000.000000
+00000180,3,60000.000000
+00000181,1,60000.000000
+00000182,2,60000.000000
+00000183,3,60000.000000
+00000184,1,60000.000000
+00000185,2,60000.000000
+00000186,3,60000.000000
+00000187,1,60000.000000
+00000188,2,60000.000000
+00000189,3,60000.000000
+00000190,1,60000.000000
+00000191,2,60000.000000
+00000192,3,60000.000000
+00000193,1,60000.000000
+00000194,2,60000.000000
+00000195,3,60000.000000
+00000196,1,60000.000000
+00000197,2,60000.000000
+00000198,3,60000.000000
+00000199,1,60000.000000
diff --git a/libmariadb/unittest/libmariadb/dyncol.c b/libmariadb/unittest/libmariadb/dyncol.c
new file mode 100644
index 00000000..8edb20a8
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/dyncol.c
@@ -0,0 +1,323 @@
+/*
+Copyright (c) 2013 Monty Program AB. All rights reserved.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+#include "my_test.h"
+#include "mariadb_dyncol.h"
+
+static int create_dyncol_named(MYSQL *mysql)
+{
+  DYNAMIC_COLUMN dyncol;
+  DYNAMIC_COLUMN_VALUE *vals;
+  uint i, column_count= 6;
+  int rc;
+  const char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5", "Val6"};
+  MYSQL_LEX_STRING keys1[]= {{(char *)"key1", 4}, {(char *)"key2", 4},
+                             {(char *)"key3", 4}, {(char *)"key4", 4},
+                             {(char *)"key5", 4}, {(char *)"key6", 4}},
+
+                   keys2[]= {{(char *)"key1", 4}, {(char *)"key1", 4},
+                             {(char *)"key3", 4}, {(char *)"key4", 4},
+                             {(char *)"key5", 4}, {(char *)"key6", 4}},
+
+                   keys3[]= {{(char *)"\x70\x61\x72\x61\x00\x30", 6}, 
+                             {(char *)"\x70\x61\x72\x61\x00\x31", 6},
+                             {(char *)"\x70\x61\x72\x61\x00\x32", 6},
+                             {(char *)"\x70\x61\x72\x61\x00\x33", 6},
+                             {(char *)"\x70\x61\x72\x61\x00\x34", 6},
+                             {(char *)"\x70\x61\x72\x61\x00\x35", 6}};
+  MYSQL_LEX_STRING *my_keys;
+  uint my_count;
+
+  vals= (DYNAMIC_COLUMN_VALUE *)malloc(column_count * sizeof(DYNAMIC_COLUMN_VALUE));
+
+  for (i=0; i < column_count; i++)
+  {
+    vals[i].type= DYN_COL_STRING;
+    vals[i].x.string.value.str= (char *)strval[i];
+    vals[i].x.string.value.length= strlen(strval[i]);
+    vals[i].x.string.charset= (MARIADB_CHARSET_INFO *)mysql->charset;
+    diag("%s", keys3[i].str);
+  }
+
+  mariadb_dyncol_init(&dyncol);
+  rc= mariadb_dyncol_create_many_named(&dyncol, column_count, keys1, vals, 0); 
+  mariadb_dyncol_free(&dyncol);
+  FAIL_IF(mariadb_dyncol_create_many_named(&dyncol, column_count, keys1, vals, 1) < 0, "Error");
+  column_count= 0;
+  FAIL_IF(mariadb_dyncol_column_count(&dyncol, &column_count) < 0, "Error");
+
+  FAIL_IF(column_count != 6, "6 columns expected");
+  mariadb_dyncol_free(&dyncol);
+
+  rc= mariadb_dyncol_create_many_named(&dyncol, column_count, keys3, vals, 1);
+  if (rc < 0) {
+    diag("Error!!: %d", rc);
+    return FAIL;
+  } 
+  column_count= 0;
+  FAIL_IF(mariadb_dyncol_column_count(&dyncol, &column_count) < 0, "Error");
+
+  FAIL_IF(column_count != 6, "6 columns expected");
+
+  mariadb_dyncol_free(&dyncol);
+
+  /* Now try to add a duplicate key */
+
+  FAIL_IF(mariadb_dyncol_create_many_named(&dyncol, column_count, keys2, vals, 1) >=0, "Error expected");
+  mariadb_dyncol_free(&dyncol);
+
+  /* binary keys */
+  rc= mariadb_dyncol_create_many_named(&dyncol, column_count, keys3, vals, 1);
+  FAIL_IF(rc < 0, "binary keys failed");
+
+  /* get keys*/
+  rc= mariadb_dyncol_list_named(&dyncol, &my_count, &my_keys);
+  FAIL_IF(rc < 0, "list named failed");
+
+  for (i=0; i < my_count; i++)
+  {
+    if (memcmp(my_keys[i].str, keys3[i].str, keys3[i].length) != 0)
+      diag("error key %d", i);
+    vals[i].type=DYN_COL_NULL;
+  }
+  rc= mariadb_dyncol_update_many_named(&dyncol, column_count, keys3, vals);
+  FAIL_IF(rc < 0, "update failed");
+  mariadb_dyncol_free(&dyncol);
+
+  keys3[0].str= (char *)"test";
+  for (i=0; i < column_count; i++)
+    diag("%s", my_keys[i].str);
+
+  free(vals);
+  free(my_keys);
+  return OK; 
+}
+
+static int mdev_4994(MYSQL *unused __attribute__((unused)))
+{
+  DYNAMIC_COLUMN dyncol;
+  uint key= 1;
+  DYNAMIC_COLUMN_VALUE val;
+  int rc;
+  
+
+  val.type= DYN_COL_NULL;
+
+  mariadb_dyncol_init(&dyncol);
+  rc= mariadb_dyncol_create_many_num(&dyncol, 1, &key, &val, 0); 
+  FAIL_IF(rc < 0, "Unexpected error");
+  mariadb_dyncol_free(&dyncol);
+  return OK;
+}
+
+static int create_dyncol_num(MYSQL *mysql)
+{
+  DYNAMIC_COLUMN dyncol;
+  DYNAMIC_COLUMN_VALUE vals[5];
+  uint i, column_count= 5;
+  uint my_count;
+  MYSQL_LEX_STRING *my_keys;
+  DYNAMIC_COLUMN_VALUE *my_vals;
+  int rc;
+  const char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5"};
+
+  uint keys1[5]= {1,2,3,4,5},
+       keys2[5]= {1,2,2,4,5};
+  MYSQL_LEX_STRING key1= {(char *)"1",1};
+
+  for (i=0; i < column_count; i++)
+  {
+    vals[i].type= DYN_COL_STRING;
+    vals[i].x.string.value.str= (char *)strval[i];
+    vals[i].x.string.value.length= strlen(strval[i]);
+    vals[i].x.string.charset= (MARIADB_CHARSET_INFO *)mysql->charset;
+  }
+  FAIL_IF(mariadb_dyncol_create_many_num(&dyncol, column_count, keys1, vals, 1) <0, "Error (keys1)");
+
+  vals[0].x.string.value.str= (char *)strval[1];
+  rc= mariadb_dyncol_update_many_named(&dyncol,1, &key1, vals);
+  diag("update: %d", rc);
+
+  rc= mariadb_dyncol_unpack(&dyncol, &my_count, &my_keys, &my_vals);
+  diag("unpack: %d %d", rc, my_count);
+
+  free(my_keys);
+  free(my_vals);
+
+  FAIL_IF(mariadb_dyncol_column_count(&dyncol, &column_count) < 0, "Error");
+  FAIL_IF(column_count != 5, "5 columns expected");
+  mariadb_dyncol_free(&dyncol);
+  FAIL_IF(mariadb_dyncol_create_many_num(&dyncol, column_count, keys2, vals, 1) >=0, "Error expected (keys2)");
+  mariadb_dyncol_free(&dyncol);
+  return OK;
+}
+
+static int mdev_x1(MYSQL *mysql)
+{
+  int rc;
+  uint i;
+  uint num_keys[5]= {1,2,3,4,5};
+  const char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5"};
+  DYNAMIC_COLUMN_VALUE vals[5];
+  DYNAMIC_COLUMN dynstr;
+  MYSQL_LEX_STRING my_key= {(char *)"1", 2};
+  uint unpack_columns;
+  MYSQL_LEX_STRING *unpack_keys;
+  DYNAMIC_COLUMN_VALUE *unpack_vals;
+
+  for (i=0; i < 5; i++)
+  {
+    vals[i].type= DYN_COL_STRING;
+    vals[i].x.string.value.str= (char *)strval[i];
+    vals[i].x.string.value.length= strlen(strval[i]);
+    vals[i].x.string.charset= (MARIADB_CHARSET_INFO *)mysql->charset;
+  }
+
+  mariadb_dyncol_init(&dynstr);
+
+  /* create numeric */
+  rc= mariadb_dyncol_create_many_num(&dynstr, 5, num_keys, vals, 1);
+  if (rc < 0)
+  {
+    diag("Error: %d", rc);
+    return FAIL;
+  }
+
+  /* unpack and print values */
+  rc= mariadb_dyncol_unpack(&dynstr, &unpack_columns, &unpack_keys, &unpack_vals);
+  if (rc < 0)
+  {
+    diag("Error: %d", rc);
+    return FAIL;
+  }
+
+  for (i=0; i < unpack_columns; i++)
+    if (memcmp(unpack_vals[i].x.string.value.str, vals[i].x.string.value.str, vals[i].x.string.value.length))
+      diag("Error1: key: %1s val: %s %s", unpack_keys[i].str, unpack_vals[i].x.string.value.str, vals[i].x.string.value.str);
+
+  free(unpack_keys);
+  free(unpack_vals);
+
+  /* change one value and update with named key */
+/*  vals[0].x.string.value.str= strval[1]; */
+  rc= mariadb_dyncol_update_many_named(&dynstr, 1, &my_key, vals);
+  if (rc < 0)
+  {
+    diag("Error: %d", rc);
+    return FAIL;
+  }
+
+  /* unpack and print values */
+  rc= mariadb_dyncol_unpack(&dynstr, &unpack_columns, &unpack_keys, &unpack_vals);
+  if (rc < 0)
+  {
+    diag("Error: %d", rc);
+    return FAIL;
+  }
+  diag("Columns: %d", unpack_columns);
+
+  for (i=0; i < unpack_columns; i++)
+    diag("Key: %s Len: %lu", unpack_keys[i].str, (unsigned long)unpack_keys[i].length);
+
+
+  free(unpack_keys);
+  free(unpack_vals);
+
+  mariadb_dyncol_free(&dynstr);
+  return OK;
+}
+
+static int dyncol_column_count(MYSQL *unused __attribute__((unused)))
+{
+  DYNAMIC_COLUMN dyncol;
+  uint column_count= 5;
+  int rc;
+
+  mariadb_dyncol_init(&dyncol); /* memset(&dyncol, 0, sizeof(DYNAMIC_COLUMN)) */
+  rc= mariadb_dyncol_column_count(&dyncol, &column_count);
+  diag("rc=%d", rc);
+  FAIL_IF(rc < 0, "unexpected error");
+  FAIL_IF(column_count > 0, "Expected column_count=0");  
+  return OK;
+}
+
+static int dyncol_nested(MYSQL *mysql __attribute__((unused)))
+{
+  DYNAMIC_COLUMN col1, col2;
+  DYNAMIC_COLUMN_VALUE value[2];
+  MYSQL_LEX_STRING cols[2]= {{(char *)"0",1},{(char *)"1",1}};
+  DYNAMIC_STRING s;
+
+  mariadb_dyncol_init(&col1);
+  mariadb_dyncol_init(&col2);
+
+  memset(&value, 0, sizeof(DYNAMIC_COLUMN_VALUE));
+
+  value[0].type= DYN_COL_UINT;
+  value[0].x.ulong_value = 17;
+
+  mariadb_dyncol_create_many_named(&col1, 1, cols, value, 0);
+  if (mariadb_dyncol_check(&col1) != ER_DYNCOL_OK)
+  {
+    diag("Error while creating col1");
+    return FAIL;
+  }
+
+  value[1].type= DYN_COL_DYNCOL;
+  value[1].x.string.value.str= col1.str;
+  value[1].x.string.value.length= col1.length;
+ 
+  mariadb_dyncol_create_many_named(&col2, 2, cols, value, 0);
+  if (mariadb_dyncol_check(&col2) != ER_DYNCOL_OK)
+  {
+    diag("Error while creating col1");
+    return FAIL;
+  }
+  mariadb_dyncol_json(&col2, &s);
+  if (strcmp(s.str, "{\"0\":17,\"1\":{\"0\":17}}") != 0)
+  {
+    diag("%s != %s", s.str, "{\"0\":17,\"1\":{\"0\":17}}");
+    return FAIL;
+  }
+  ma_dynstr_free(&s);
+  mariadb_dyncol_free(&col1);
+  mariadb_dyncol_free(&col2);
+  return OK;
+}
+
+struct my_tests_st my_tests[] = {
+  {"mdev_x1", mdev_x1, TEST_CONNECTION_NEW, 0, NULL, NULL}, 
+  {"mdev_4994", mdev_4994, TEST_CONNECTION_NEW, 0, NULL, NULL}, 
+  {"create_dyncol_named", create_dyncol_named, TEST_CONNECTION_NEW, 0, NULL, NULL}, 
+  {"create_dyncol_num", create_dyncol_num, TEST_CONNECTION_NEW, 0, NULL, NULL}, 
+  {"dyncol_column_count", dyncol_column_count, TEST_CONNECTION_NEW, 0, NULL, NULL}, 
+  {"dyncol_nested", dyncol_nested, TEST_CONNECTION_NEW, 0, NULL, NULL}, 
+  {NULL, NULL, 0, 0, NULL, 0}
+};
+
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+   get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/errors.c b/libmariadb/unittest/libmariadb/errors.c
new file mode 100644
index 00000000..79060a50
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/errors.c
@@ -0,0 +1,290 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+#include "my_test.h"
+
+/* Test warnings */
+
+static int test_client_warnings(MYSQL *mysql)
+{
+  int        rc;
+
+  rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
+  check_mysql_rc(rc, mysql); 
+  rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
+  check_mysql_rc(rc, mysql); 
+
+  FAIL_IF(!mysql_warning_count(mysql), "Warning expected");
+
+  return OK;
+}
+
+
+static int test_ps_client_warnings(MYSQL *mysql)
+{
+  int        rc;
+  MYSQL_STMT *stmt;
+  const char *query= "DROP TABLE IF EXISTS test_non_exists";
+
+  rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
+  check_mysql_rc(rc, mysql); 
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  FAIL_IF(rc, mysql_stmt_error(stmt));
+
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(rc, mysql_stmt_error(stmt));
+
+  FAIL_IF(!mysql_warning_count(mysql), "Warning expected");
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_server_warnings(MYSQL *mysql)
+{
+  int        rc;
+  MYSQL_RES  *result;
+
+  rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
+  check_mysql_rc(rc, mysql); 
+  rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
+  check_mysql_rc(rc, mysql); 
+
+  rc= mysql_query(mysql, "SHOW WARNINGS");
+  check_mysql_rc(rc, mysql); 
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, mysql_error(mysql));
+  FAIL_IF(!mysql_num_rows(result), "Empty resultset");
+
+  mysql_free_result(result);
+
+  return OK;
+}
+
+
+/* Test errors */
+
+static int test_client_errors(MYSQL *mysql)
+{
+  int        rc;
+
+  rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
+  check_mysql_rc(rc, mysql); 
+
+  rc= mysql_query(mysql, "DROP TABLE test_non_exists");
+  FAIL_IF(!rc, "Error expected"); 
+
+  FAIL_IF(!mysql_errno(mysql), "Error expected");
+  FAIL_IF(!strlen(mysql_error(mysql)), "Empty errormsg");
+  FAIL_IF(strcmp(mysql_sqlstate(mysql), "00000") == 0, "Invalid SQLstate");
+
+  return OK;
+}
+
+static int test_ps_client_errors(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  const char *query= "DROP TABLE test_non_exists";
+
+  rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  FAIL_IF(rc, mysql_stmt_error(stmt));
+
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(!rc, mysql_stmt_error(stmt));
+
+  FAIL_IF(!mysql_stmt_errno(stmt), "Error expected");
+  FAIL_IF(!strlen(mysql_stmt_error(stmt)), "Empty errormsg");
+  FAIL_IF(strcmp(mysql_stmt_sqlstate(stmt), "00000") == 0, "Invalid SQLstate");
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_server_errors(MYSQL *mysql)
+{
+  int        rc;
+  MYSQL_RES  *result;
+
+  rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
+  check_mysql_rc(rc, mysql); 
+
+  rc= mysql_query(mysql, "DROP TABLE test_non_exists");
+  check_mysql_rc(rc, mysql); 
+
+  rc= mysql_query(mysql, "SHOW ERRORS");
+  check_mysql_rc(rc, mysql); 
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, mysql_error(mysql));
+  FAIL_IF(!mysql_num_rows(result), "Empty resultset");
+  mysql_free_result(result);
+
+  return OK;
+}
+
+/* Bug #16143: mysql_stmt_sqlstate returns an empty string instead of '00000' */
+
+static int test_bug16143(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  /* Check mysql_stmt_sqlstate return "no error" */
+  FAIL_UNLESS(strcmp(mysql_stmt_sqlstate(stmt), "00000") == 0, "Expected SQLstate 000000");
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+/* Test warnings for cuted rows */
+
+static int test_cuted_rows(MYSQL *mysql)
+{
+  int        rc, count;
+  MYSQL_RES  *result;
+
+  if (!is_mariadb)
+    return SKIP;
+
+  rc= mysql_query(mysql, "DROP TABLE if exists t1");
+  check_mysql_rc(rc, mysql);
+  mysql_query(mysql, "DROP TABLE if exists t2");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1(c1 tinyint)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t2(c1 int not null)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "FLUSH TABLES");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "START TRANSACTION");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 values(10), (NULL), (NULL)");
+  check_mysql_rc(rc, mysql);
+
+  count= mysql_warning_count(mysql);
+  FAIL_UNLESS(count == 0, "warnings != 0");
+
+  rc= mysql_query(mysql, "INSERT INTO t2 SELECT * FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  count= mysql_warning_count(mysql);
+  FAIL_UNLESS(count == 2, "warnings != 2");
+
+  rc= mysql_query(mysql, "SHOW WARNINGS");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS(rc == 2, "rowcount != 2");
+  mysql_free_result(result);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES('junk'), (876789)");
+  check_mysql_rc(rc, mysql);
+
+  count= mysql_warning_count(mysql);
+  FAIL_UNLESS(count == 2, "warnings != 2");
+
+  rc= mysql_query(mysql, "SHOW WARNINGS");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS(rc == 2, "rowcount != 2");
+  mysql_free_result(result);
+
+  rc= mysql_query(mysql, "DROP TABLE t1, t2");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_parse_error_and_bad_length(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  char stmt_str[128];
+
+  /* check that we get 4 syntax errors over the 4 calls */
+
+  rc= mysql_query(mysql, "SHOW DATABAAAA");
+  FAIL_UNLESS(rc, "Error expected");
+  rc= mysql_real_query(mysql, SL_BIN("SHOW DATABASES\0AAA"));
+  FAIL_UNLESS(rc, "Error expected");
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SHOW DATABAAAA"));
+  FAIL_IF(!rc, "Error expected");
+  mysql_stmt_close(stmt);
+  stmt= mysql_stmt_init(mysql);
+  FAIL_UNLESS(stmt, "");
+  memset(stmt_str, 0, 100);
+  strcpy(stmt_str, "SHOW DATABASES");
+  rc= mysql_stmt_prepare(stmt, stmt_str, 99);
+  FAIL_IF(!rc, "Error expected");
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+
+struct my_tests_st my_tests[] = {
+  {"test_client_warnings", test_client_warnings, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_ps_client_warnings", test_ps_client_warnings, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_server_warnings", test_server_warnings, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_client_errors", test_client_errors, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_ps_client_errors", test_ps_client_errors, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_server_errors", test_server_errors, TEST_CONNECTION_DEFAULT, 0, NULL , "Open bug: #42364"},
+  {"test_bug16143", test_bug16143, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_cuted_rows", test_cuted_rows, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_parse_error_and_bad_length", test_parse_error_and_bad_length, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/features-10_2.c b/libmariadb/unittest/libmariadb/features-10_2.c
new file mode 100644
index 00000000..e09db5aa
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/features-10_2.c
@@ -0,0 +1,249 @@
+/*
+*/
+
+#include "my_test.h"
+
+static int execute_direct(MYSQL *mysql)
+{
+  int rc= 0;
+  long i= 0;
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind;
+  unsigned int param_count= 1;
+  MYSQL_RES *res= NULL;
+
+  stmt= mysql_stmt_init(mysql);
+
+  rc= mariadb_stmt_execute_direct(stmt, "DROP TABLE IF EXISTS t1", -1);
+  check_stmt_rc(rc, stmt);
+
+  rc= mariadb_stmt_execute_direct(stmt, "SELECT 1", -1);
+  check_stmt_rc(rc, stmt);
+
+  while (!mysql_stmt_fetch(stmt));
+
+  rc= mariadb_stmt_execute_direct(stmt, "SELECT 1", -1);
+  check_stmt_rc(rc, stmt);
+
+  rc= mariadb_stmt_execute_direct(stmt, "CREATE TABLE t1 (a int)", -1);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "FLUSH TABLES");
+  check_mysql_rc(rc, mysql);
+
+  memset(&bind, 0, sizeof(MYSQL_BIND));
+
+  bind.buffer= &i;
+  bind.buffer_type= MYSQL_TYPE_LONG;
+  bind.buffer_length= sizeof(long);
+
+  mysql_stmt_close(stmt);
+  stmt= mysql_stmt_init(mysql);
+  mysql_stmt_attr_set(stmt, STMT_ATTR_PREBIND_PARAMS, &param_count);
+
+  rc= mysql_stmt_bind_param(stmt, &bind);
+  check_stmt_rc(rc, stmt);
+  rc= mariadb_stmt_execute_direct(stmt, "INSERT INTO t1 VALUES (?)", -1);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "START TRANSACTION");
+  check_mysql_rc(rc, mysql);
+
+  for (i=1; i < 1000; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+  rc= mysql_stmt_close(stmt);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT * FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  FAIL_IF(mysql_num_rows(res) != 1000, "Expected 1000 rows");
+
+  mysql_free_result(res);
+  rc= mysql_query(mysql, "COMMIT");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int execute_direct_example(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_BIND bind[2];
+  int intval= 1;
+  int param_count= 2;
+  int rc;
+  const char *strval= "execute_direct_example1";
+
+  /* Direct execution without parameters */
+  rc= mariadb_stmt_execute_direct(stmt, "DROP TABLE IF EXISTS execute_direct", -1);
+  check_stmt_rc(rc, stmt);
+  rc= mariadb_stmt_execute_direct(stmt, "CREATE TABLE execute_direct (a int, b varchar(20))", -1);
+  rc= mysql_stmt_close(stmt);
+  stmt= mysql_stmt_init(mysql);
+  check_stmt_rc(rc, stmt);
+  memset(bind, 0, sizeof(MYSQL_BIND) * 2);
+  bind[0].buffer_type= MYSQL_TYPE_SHORT;
+  bind[0].buffer= &intval;
+  bind[1].buffer_type= MYSQL_TYPE_STRING;
+  bind[1].buffer= (char *)strval;
+  bind[1].buffer_length= (unsigned long)strlen(strval);
+
+  /* set number of parameters */
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_PREBIND_PARAMS, &param_count);
+  check_stmt_rc(rc, stmt);
+
+  /* bind parameters */
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mariadb_stmt_execute_direct(stmt, "INSERT INTO execute_direct VALUES (?,?)", -1);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE execute_direct");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int conc_213(MYSQL *mysql)
+{
+  MYSQL_BIND bind;
+  unsigned int param_count= 1;
+  long id= 1234;
+  MYSQL_STMT *stmt;
+
+  stmt = mysql_stmt_init(mysql);
+
+  memset(&bind, '\0', sizeof(bind));
+
+  bind.buffer_type = MYSQL_TYPE_LONG;
+  bind.buffer = (void *)&id;
+  bind.buffer_length = sizeof(long);
+/*  bind.is_null = &is_null;
+  bind.length = &length;
+  bind.error = &error; */
+
+  mysql_stmt_attr_set(stmt, STMT_ATTR_PREBIND_PARAMS, &param_count);
+  check_stmt_rc(mysql_stmt_bind_param(stmt, &bind), stmt);
+  check_stmt_rc(mariadb_stmt_execute_direct(stmt, "SELECT ?", -1), stmt);
+  check_stmt_rc(mysql_stmt_store_result(stmt), stmt);
+  check_stmt_rc(mysql_stmt_free_result(stmt), stmt);
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int conc_212(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+
+  rc= mariadb_stmt_execute_direct(stmt, "SELECT 1, 2", -1);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_store_result(stmt);
+  mysql_stmt_free_result(stmt);
+
+  rc= mariadb_stmt_execute_direct(stmt, "SELECT 1, 2", -1);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_store_result(stmt);
+  mysql_stmt_free_result(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc,mysql);
+
+
+  rc= mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int conc_218(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_BIND bind[2];
+  int id=1;
+  my_bool is_null= 0, error= 0;
+  unsigned int param_count= 1;
+
+  memset(bind, 0, 2 * sizeof(MYSQL_BIND));
+  bind[0].buffer_type = MYSQL_TYPE_LONG;
+  bind[0].buffer = (void *)&id;
+  bind[0].buffer_length = 4;
+  bind[0].is_null = &is_null;
+  bind[0].error = &error;
+
+  mysql_stmt_attr_set(stmt, STMT_ATTR_PREBIND_PARAMS, &param_count);
+  check_stmt_rc(mysql_stmt_bind_param(stmt, bind), stmt);
+  check_stmt_rc(mariadb_stmt_execute_direct(stmt, "SELECT ?", -1), stmt);
+  check_stmt_rc(mysql_stmt_store_result(stmt), stmt);
+
+  check_stmt_rc(mysql_stmt_free_result(stmt), stmt);
+
+  param_count= 1;
+  mysql_stmt_attr_set(stmt, STMT_ATTR_PREBIND_PARAMS, &param_count);
+  check_stmt_rc(mysql_stmt_bind_param(stmt, bind), stmt);
+  check_stmt_rc(mariadb_stmt_execute_direct(stmt, "SELECT ?", -1), stmt);
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_cursor(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  unsigned long prefetch_rows= 1;
+  unsigned long cursor_type= CURSOR_TYPE_READ_ONLY;
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, &cursor_type);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_PREFETCH_ROWS, &prefetch_rows);
+  check_stmt_rc(rc, stmt);
+  rc= mariadb_stmt_execute_direct(stmt, "SELECT 1 FROM DUAL UNION SELECT 2 FROM DUAL", -1);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mariadb_stmt_execute_direct(stmt, "SELECT 1 FROM DUAL UNION SELECT 2 FROM DUAL", -1);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+
+struct my_tests_st my_tests[] = {
+  {"test_cursor", test_cursor, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"conc_218", conc_218, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"conc_212", conc_212, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"conc_213", conc_213, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"execute_direct", execute_direct, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"execute_direct_example", execute_direct_example, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+
+int main(int argc, char **argv)
+{
+
+  mysql_library_init(0,0,NULL);
+
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  mysql_server_end();
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/fetch.c b/libmariadb/unittest/libmariadb/fetch.c
new file mode 100644
index 00000000..6394e51d
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/fetch.c
@@ -0,0 +1,1003 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+#include "my_test.h"
+
+/* Generalized fetch conversion routine for all basic types */
+
+static int bind_fetch(MYSQL *mysql, int row_count)
+{
+  MYSQL_STMT   *stmt;
+  int          rc, i, count= row_count;
+  int32        data[10];
+  int8         i8_data;
+  int16        i16_data;
+  int          i32_data;
+  longlong     i64_data;
+  float        f_data;
+  double       d_data;
+  char         s_data[10];
+  ulong        length[10];
+  MYSQL_BIND   my_bind[7];
+  my_bool      is_null[7];
+  char         query[MAX_TEST_QUERY_LENGTH];
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  strcpy(query, "INSERT INTO test_bind_fetch VALUES (?, ?, ?, ?, ?, ?, ?)");
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc,stmt);
+
+  FAIL_UNLESS(mysql_stmt_param_count(stmt) == 7, "ParamCount != 7");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  for (i= 0; i < (int) array_elements(my_bind); i++)
+  {
+    my_bind[i].buffer_type= MYSQL_TYPE_LONG;
+    my_bind[i].buffer= (void *) &data[i];
+  }
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc,stmt);
+
+  while (count--)
+  {
+    rc= 10+count;
+    for (i= 0; i < (int) array_elements(my_bind); i++)
+    {
+      data[i]= rc+i;
+      rc+= 12;
+    }
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc,stmt);
+  }
+
+  rc= mysql_commit(mysql);
+  check_stmt_rc(rc,stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= my_stmt_result(mysql, "SELECT * FROM test_bind_fetch");
+  FAIL_UNLESS(row_count == rc, "Wrong number of rows");
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  strcpy(query, "SELECT * FROM test_bind_fetch");
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc,stmt);
+
+  for (i= 0; i < (int) array_elements(my_bind); i++)
+  {
+    my_bind[i].buffer= (void *) &data[i];
+    my_bind[i].length= &length[i];
+    my_bind[i].is_null= &is_null[i];
+  }
+
+  my_bind[0].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[0].buffer= (void *)&i8_data;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[1].buffer= (void *)&i16_data;
+
+  my_bind[2].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[2].buffer= (void *)&i32_data;
+
+  my_bind[3].buffer_type= MYSQL_TYPE_LONGLONG;
+  my_bind[3].buffer= (void *)&i64_data;
+
+  my_bind[4].buffer_type= MYSQL_TYPE_FLOAT;
+  my_bind[4].buffer= (void *)&f_data;
+
+  my_bind[5].buffer_type= MYSQL_TYPE_DOUBLE;
+  my_bind[5].buffer= (void *)&d_data;
+
+  my_bind[6].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[6].buffer= (void *)&s_data;
+  my_bind[6].buffer_length= sizeof(s_data);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc,stmt);
+
+  while (row_count--)
+  {
+    rc= mysql_stmt_fetch(stmt);
+    check_stmt_rc(rc,stmt);
+
+    rc= 10+row_count;
+
+    /* TINY */
+    FAIL_UNLESS((int) i8_data == rc, "Invalid value for i8_data");
+    FAIL_UNLESS(length[0] == 1, "Invalid length");
+    rc+= 13;
+
+    /* SHORT */
+    FAIL_UNLESS((int) i16_data == rc, "Invalid value for i16_data");
+    FAIL_UNLESS(length[1] == 2, "Invalid length");
+    rc+= 13;
+
+    /* LONG */
+    FAIL_UNLESS((int) i32_data == rc, "Invalid value for i32_data");
+    FAIL_UNLESS(length[2] == 4, "Invalid length");
+    rc+= 13;
+
+    /* LONGLONG */
+    FAIL_UNLESS((int) i64_data == rc, "Invalid value for i64_data");
+    FAIL_UNLESS(length[3] == 8, "Invalid length");
+    rc+= 13;
+
+    /* FLOAT */
+    FAIL_UNLESS((int)f_data == rc, "Invalid value for f_data");
+    FAIL_UNLESS(length[4] == 4, "Invalid length");
+    rc+= 13;
+
+    /* DOUBLE */
+    FAIL_UNLESS((int)d_data == rc, "Invalid value for d_data");
+    FAIL_UNLESS(length[5] == 8, "Invalid length");
+    rc+= 13;
+
+    /* CHAR */
+    {
+      char buff[20];
+      long len= sprintf(buff, "%d", rc);
+      FAIL_UNLESS(strcmp(s_data, buff) == 0, "Invalid value for s_data");
+      FAIL_UNLESS(length[6] == (ulong) len, "Invalid length");
+    }
+  }
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "Expected MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+
+static int test_fetch_seek(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[3];
+  MYSQL_ROW_OFFSET row;
+  int        rc;
+  int32      c1;
+  char       c2[11], c3[20];
+  const char *query = "SELECT * FROM t1";
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1(c1 int primary key auto_increment, c2 char(10), c3 timestamp)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1(c2) values('venu'), ('mysql'), ('open'), ('source')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc,stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&c1;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= (void *)c2;
+  my_bind[1].buffer_length= sizeof(c2);
+
+  my_bind[2]= my_bind[1];
+  my_bind[2].buffer= (void *)c3;
+  my_bind[2].buffer_length= sizeof(c3);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc,stmt);
+
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+
+  row= mysql_stmt_row_tell(stmt);
+
+  row= mysql_stmt_row_seek(stmt, row);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+
+  row= mysql_stmt_row_seek(stmt, row);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+
+  mysql_stmt_data_seek(stmt, 0);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(rc != MYSQL_NO_DATA, "Expected MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Test mysql_stmt_fetch_column() with offset */
+
+static int test_fetch_offset(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[2];
+  char       data[11], chunk[5];
+  ulong      length[2];
+  int        rc;
+  my_bool    is_null[2];
+  const char *query = "SELECT * FROM t1";
+
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1(a char(10), b mediumblob)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 values('abcdefghij', 'klmnopqrstzy'), (null, null)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc,stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)data;
+  my_bind[0].buffer_length= 11;
+  my_bind[0].is_null= &is_null[0];
+  my_bind[0].length= &length[0];
+
+  my_bind[1].buffer_type= MYSQL_TYPE_MEDIUM_BLOB;
+  my_bind[1].buffer= NULL;
+  my_bind[1].buffer_length= 0;
+  my_bind[1].is_null= &is_null[1];
+  my_bind[1].length= &length[1];
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 0, 0);
+  FAIL_IF(!rc, "Error expected");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc,stmt);
+diag("truncation: %d", mysql->options.report_data_truncation);
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_DATA_TRUNCATED, "rc != MYSQL_DATA_TRUNCATED");
+
+  data[0]= '\0';
+  rc= mysql_stmt_fetch_column(stmt, &my_bind[0], 0, 0);
+  check_stmt_rc(rc,stmt);
+
+
+  FAIL_IF(!(strncmp(data, "abcdefghij", 11) == 0 && length[0] == 10), "Wrong value");
+  FAIL_IF(my_bind[0].error_value, "No truncation, but error is set");
+
+  rc= mysql_stmt_fetch_column(stmt, &my_bind[0], 0, 5);
+  check_stmt_rc(rc,stmt);
+  FAIL_IF(!(strncmp(data, "fghij", 6) == 0 && length[0] == 10), "Wrong value");
+  FAIL_IF(my_bind[0].error_value, "No truncation, but error is set");
+
+  rc= mysql_stmt_fetch_column(stmt, &my_bind[0], 0, 9);
+  check_stmt_rc(rc,stmt);
+  FAIL_IF(!(strncmp(data, "j", 2) == 0 && length[0] == 10), "Wrong value");
+  FAIL_IF(my_bind[0].error_value, "No truncation, but error is set");
+
+  /* Now blob field */
+  my_bind[1].buffer= chunk;
+  my_bind[1].buffer_length= sizeof(chunk);
+
+  rc= mysql_stmt_fetch_column(stmt, &my_bind[1], 1, 0);
+  check_stmt_rc(rc,stmt);
+
+  FAIL_IF(!(strncmp(chunk, "klmno", 5) == 0 && length[1] == 12), "Wrong value");
+  FAIL_IF(my_bind[1].error_value == '\0', "Truncation, but error is not set");
+
+  rc= mysql_stmt_fetch_column(stmt, &my_bind[1], 1, 5);
+  check_stmt_rc(rc,stmt);
+  FAIL_IF(!(strncmp(chunk, "pqrst", 5) == 0 && length[1] == 12), "Wrong value");
+  FAIL_IF(my_bind[1].error_value == '\0', "Truncation, but error is not set");
+
+  rc= mysql_stmt_fetch_column(stmt, &my_bind[1], 1, 10);
+  check_stmt_rc(rc,stmt);
+  FAIL_IF(!(strncmp(chunk, "zy", 2) == 0 && length[1] == 12), "Wrong value");
+  FAIL_IF(my_bind[1].error_value, "No truncation, but error is set");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+
+  memset(is_null, 0, sizeof(is_null));
+
+  rc= mysql_stmt_fetch_column(stmt, &my_bind[0], 0, 0);
+  check_stmt_rc(rc,stmt);
+
+  FAIL_IF(is_null[0] != 1, "Null flag not set");
+
+  rc= mysql_stmt_fetch_column(stmt, &my_bind[1], 1, 0);
+  check_stmt_rc(rc,stmt);
+
+  FAIL_IF(is_null[1] != 1, "Null flag not set");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(rc != MYSQL_NO_DATA, "Expected MYSQL_NO_DATA");
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 1, 0);
+  FAIL_IF(!rc, "Error expected");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Test mysql_stmt_fetch_column() */
+
+static int test_fetch_column(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[2];
+  char       c2[20], bc2[20];
+  ulong      l1, l2, bl1, bl2;
+  int        rc, c1, bc1;
+  const char *query= "SELECT * FROM t1 ORDER BY c2 DESC";
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1(c1 int primary key auto_increment, c2 char(10))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1(c2) values('venu'), ('mysql')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc,stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&bc1;
+  my_bind[0].buffer_length= 0;
+  my_bind[0].is_null= 0;
+  my_bind[0].length= &bl1;
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= (void *)bc2;
+  my_bind[1].buffer_length= 7;
+  my_bind[1].is_null= 0;
+  my_bind[1].length= &bl2;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc,stmt);
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 1, 0); /* No-op at this point */
+  FAIL_IF(!rc, "Error expected");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+
+  c2[0]= '\0'; l2= 0;
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)c2;
+  my_bind[0].buffer_length= 7;
+  my_bind[0].is_null= 0;
+  my_bind[0].length= &l2;
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 1, 0);
+  check_stmt_rc(rc,stmt);
+  FAIL_IF(!(strncmp(c2, "venu", 4) == 0 && l2 == 4), "Expected c2='venu'");
+
+  c2[0]= '\0'; l2= 0;
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 1, 0);
+  check_stmt_rc(rc,stmt);
+  FAIL_IF(!(strcmp(c2, "venu") == 0 && l2 == 4), "Expected c2='venu'");
+
+  c1= 0;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&c1;
+  my_bind[0].buffer_length= 0;
+  my_bind[0].is_null= 0;
+  my_bind[0].length= &l1;
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 0, 0);
+  check_stmt_rc(rc,stmt);
+  FAIL_IF(!(c1 == 1 && l1 == 4), "Expected c1=1");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+
+  c2[0]= '\0'; l2= 0;
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)c2;
+  my_bind[0].buffer_length= 7;
+  my_bind[0].is_null= 0;
+  my_bind[0].length= &l2;
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 1, 0);
+  check_stmt_rc(rc,stmt);
+  FAIL_IF(!(strncmp(c2, "mysq", 4) == 0 && l2 == 5), "Expected c2='mysql'");
+
+  c2[0]= '\0'; l2= 0;
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 1, 0);
+  check_stmt_rc(rc,stmt);
+  FAIL_IF(!(strcmp(c2, "mysql") == 0 && l2 == 5), "Expected c2='mysql'");
+
+  c1= 0;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&c1;
+  my_bind[0].buffer_length= 0;
+  my_bind[0].is_null= 0;
+  my_bind[0].length= &l1;
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 0, 0);
+  check_stmt_rc(rc,stmt);
+  FAIL_IF(!(c1 == 2 && l1 == 4), "Expected c2=2");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(rc!=MYSQL_NO_DATA, "Expected MYSQL_NO_DATA");
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 1, 0);
+  FAIL_IF(!rc, "Error expected");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Test fetch without prior bound buffers */
+
+static int test_fetch_nobuffs(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[4];
+  char       str[4][50];
+  int        rc;
+  const char  *query = "SELECT DATABASE(), CURRENT_USER(), \
+                       CURRENT_DATE(), CURRENT_TIME()";
+
+  stmt = mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+
+  FAIL_IF(rc != 1, "Expected 1 row");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)str[0];
+  my_bind[0].buffer_length= sizeof(str[0]);
+  my_bind[1]= my_bind[2]= my_bind[3]= my_bind[0];
+  my_bind[1].buffer= (void *)str[1];
+  my_bind[2].buffer= (void *)str[2];
+  my_bind[3].buffer= (void *)str[3];
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+  {
+    rc++;
+  }
+  FAIL_IF(rc != 1, "Expected 1 row");
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+/* Test fetch null */
+
+static int test_fetch_null(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  int        i;
+  int        nData= 0;
+  MYSQL_BIND my_bind[11];
+  ulong      length[11];
+  my_bool    is_null[11];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_fetch_null");
+  check_mysql_rc(rc, mysql);
+
+  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))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_fetch_null (col11) "
+                    "VALUES (1000), (88), (389789)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  FAIL_IF(rc, mysql_error(mysql));
+
+  /* fetch */
+  memset(my_bind, '\0', sizeof(my_bind));
+  for (i= 0; i < (int) array_elements(my_bind); i++)
+  {
+    my_bind[i].buffer_type= MYSQL_TYPE_LONG;
+    my_bind[i].is_null= &is_null[i];
+    my_bind[i].length= &length[i];
+  }
+  my_bind[i-1].buffer= (void *)&nData;              /* Last column is not null */
+
+  strcpy((char *)query , "SELECT * FROM test_fetch_null");
+
+  rc= my_stmt_result(mysql, query);
+  FAIL_UNLESS(rc == 3, "Exoected 3 rows");
+
+  stmt = mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+  {
+    rc++;
+    for (i= 0; i < 10; i++)
+    {
+      FAIL_IF(!is_null[i], "Expected is_null");
+    }
+    FAIL_UNLESS(nData == 1000 || nData == 88 || nData == 389789, "Wrong value for nData");
+    FAIL_UNLESS(is_null[i] == 0, "Exoected !is_null");
+    FAIL_UNLESS(length[i] == 4, "Expected length=4");
+  }
+  FAIL_UNLESS(rc == 3, "Expected 3 rows");
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE test_fetch_null");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Test fetching of date, time and ts */
+
+static int test_fetch_date(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  uint       i;
+  int        rc;
+  long       year;
+  char       date[25], my_time[25], ts[25], ts_4[25], ts_6[20], dt[20];
+  ulong      d_length, t_length, ts_length, ts4_length, ts6_length,
+             dt_length, y_length;
+  MYSQL_BIND my_bind[8];
+  my_bool    is_null[8];
+  ulong      length[8];
+  const char *query= "SELECT * FROM test_bind_result";
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_result");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_bind_result(c1 date, c2 time, \
+                                                        c3 timestamp, \
+                                                        c4 year, \
+                                                        c5 datetime, \
+                                                        c6 timestamp, \
+                                                        c7 timestamp)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SET SQL_MODE=''");
+  check_mysql_rc(rc, mysql);
+  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')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  FAIL_IF(rc, mysql_error(mysql));
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  for (i= 0; i < array_elements(my_bind); i++)
+  {
+    my_bind[i].is_null= &is_null[i];
+    my_bind[i].length= &length[i];
+  }
+
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1]= my_bind[2]= my_bind[0];
+
+  my_bind[0].buffer= (void *)&date;
+  my_bind[0].buffer_length= sizeof(date);
+  my_bind[0].length= &d_length;
+
+  my_bind[1].buffer= (void *)&my_time;
+  my_bind[1].buffer_length= sizeof(my_time);
+  my_bind[1].length= &t_length;
+
+  my_bind[2].buffer= (void *)&ts;
+  my_bind[2].buffer_length= sizeof(ts);
+  my_bind[2].length= &ts_length;
+
+  my_bind[3].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[3].buffer= (void *)&year;
+  my_bind[3].length= &y_length;
+
+  my_bind[4].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[4].buffer= (void *)&dt;
+  my_bind[4].buffer_length= sizeof(dt);
+  my_bind[4].length= &dt_length;
+
+  my_bind[5].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[5].buffer= (void *)&ts_4;
+  my_bind[5].buffer_length= sizeof(ts_4);
+  my_bind[5].length= &ts4_length;
+
+  my_bind[6].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[6].buffer= (void *)&ts_6;
+  my_bind[6].buffer_length= sizeof(ts_6);
+  my_bind[6].length= &ts6_length;
+
+  rc= my_stmt_result(mysql, "SELECT * FROM test_bind_result");
+  FAIL_UNLESS(rc == 1, "Expected 1 row");
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  ts_4[0]= '\0';
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(strcmp(date, "2002-01-02") == 0, "date != '2002-01-02'");
+  FAIL_UNLESS(d_length == 10, "d_length != 10");
+
+  FAIL_UNLESS(strcmp(my_time, "12:49:00") == 0, "mytime != '12:49:00'");
+  FAIL_UNLESS(t_length == 8, "t_length != 8");
+
+  FAIL_UNLESS(strcmp(ts, "2002-01-02 17:46:59") == 0, "ts != '2002-01-02 17:46:59'");
+  FAIL_UNLESS(ts_length == 19, "ts_length != 19");
+
+  FAIL_UNLESS(strcmp(dt, "2010-07-10 00:00:00") == 0, "dt != 2010-07-10 00:00:00");
+  FAIL_UNLESS(dt_length == 19, "dt_length != 19");
+
+  FAIL_UNLESS(strcmp(ts_4, "0000-00-00 00:00:00") == 0, "ts4 != '0000-00-00 00:00:00'");
+  FAIL_UNLESS(ts4_length == strlen("0000-00-00 00:00:00"), "ts4_length != 19");
+
+  FAIL_UNLESS(strcmp(ts_6, "1999-12-29 00:00:00") == 0, "ts_6 != '1999-12-29 00:00:00'");
+  FAIL_UNLESS(ts6_length == 19, "ts6_length != 19");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_result");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Test fetching of str to all types */
+
+static int test_fetch_str(MYSQL *mysql)
+{
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_bind_fetch(c1 char(10), \
+                                                     c2 char(10), \
+                                                     c3 char(20), \
+                                                     c4 char(20), \
+                                                     c5 char(30), \
+                                                     c6 char(40), \
+                                                     c7 char(20))");
+  check_mysql_rc(rc, mysql);
+
+  rc= bind_fetch(mysql, 3);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  return rc;
+}
+
+/* Test fetching of long to all types */
+
+static int test_fetch_long(MYSQL *mysql)
+{
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE test_bind_fetch(c1 int unsigned, \
+                                                     c2 int unsigned, \
+                                                     c3 int, \
+                                                     c4 int, \
+                                                     c5 int, \
+                                                     c6 int unsigned, \
+                                                     c7 int)");
+  check_mysql_rc(rc, mysql);
+  rc= bind_fetch(mysql, 4);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  return rc;
+}
+
+
+/* Test fetching of short to all types */
+
+static int test_fetch_short(MYSQL *mysql)
+{
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE test_bind_fetch(c1 smallint unsigned, \
+                                                     c2 smallint, \
+                                                     c3 smallint unsigned, \
+                                                     c4 smallint, \
+                                                     c5 smallint, \
+                                                     c6 smallint, \
+                                                     c7 smallint unsigned)");
+  check_mysql_rc(rc, mysql);
+  rc= bind_fetch(mysql, 5);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  return rc;
+}
+
+
+/* Test fetching of tiny to all types */
+
+static int test_fetch_tiny(MYSQL *mysql)
+{
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_bind_fetch(c1 tinyint unsigned, \
+                                                     c2 tinyint, \
+                                                     c3 tinyint unsigned, \
+                                                     c4 tinyint, \
+                                                     c5 tinyint, \
+                                                     c6 tinyint, \
+                                                     c7 tinyint unsigned)");
+  check_mysql_rc(rc, mysql);
+  rc= bind_fetch(mysql, 3);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  return rc;
+}
+
+
+/* Test fetching of longlong to all types */
+
+static int test_fetch_bigint(MYSQL *mysql)
+{
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_bind_fetch(c1 bigint, \
+                                                   c2 bigint, \
+                                                   c3 bigint unsigned, \
+                                                   c4 bigint unsigned, \
+                                                   c5 bigint unsigned, \
+                                                   c6 bigint unsigned, \
+                                                   c7 bigint unsigned)");
+  check_mysql_rc(rc, mysql);
+  rc= bind_fetch(mysql, 2);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  return rc;
+}
+
+
+/* Test fetching of float to all types */
+
+static int test_fetch_float(MYSQL *mysql)
+{
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_bind_fetch(c1 float(3), \
+                                                   c2 float, \
+                                                   c3 float unsigned, \
+                                                   c4 float, \
+                                                   c5 float, \
+                                                   c6 float, \
+                                                   c7 float(10) unsigned)");
+  check_mysql_rc(rc, mysql);
+
+  rc= bind_fetch(mysql, 2);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  return rc;
+}
+
+
+/* Test fetching of double to all types */
+
+static int test_fetch_double(MYSQL *mysql)
+{
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE test_bind_fetch(c1 double(5, 2), "
+                     "c2 double unsigned, c3 double unsigned, "
+                     "c4 double unsigned, c5 double unsigned, "
+                     "c6 double unsigned, c7 double unsigned)");
+  check_mysql_rc(rc, mysql);
+  rc= bind_fetch(mysql, 3);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_fetch");
+  return rc;
+}
+
+static int test_conc281(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_BIND bind[2];
+  unsigned long length= 0;
+  char buffer[2048];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc282");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE conc282 (a blob, b varchar(1000), c int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO conc282 VALUES (REPEAT('A',2000), REPEAT('B', 999),3)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, "SELECT a, b FROM conc282", -1);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 2);
+
+  bind[0].buffer_type= MYSQL_TYPE_BLOB;
+  bind[0].buffer= buffer;
+  bind[0].buffer_length= 2048;
+  bind[0].length= &length;
+
+  rc= mysql_stmt_fetch_column(stmt, &bind[0], 0, 0);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(length != 2000, "Expected length= 2000");
+  FAIL_IF(buffer[0] != 'A' || buffer[1999] != 'A', "Wrong result");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE conc282");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+
+}
+
+struct my_tests_st my_tests[] = {
+  {"test_conc281", test_conc281, 1, 0, NULL, NULL},
+  {"test_fetch_seek", test_fetch_seek, 1, 0, NULL , NULL},
+  {"test_fetch_offset", test_fetch_offset, 1, 0, NULL , NULL},
+  {"test_fetch_column", test_fetch_column, 1, 0, NULL , NULL},
+  {"test_fetch_nobuffs", test_fetch_nobuffs, 1, 0, NULL , NULL},
+  {"test_fetch_null", test_fetch_null, 1, 0, NULL , NULL},
+  {"test_fetch_date", test_fetch_date, 1, 0, NULL , NULL},
+  {"test_fetch_str", test_fetch_str, 1, 0, NULL , NULL},
+  {"test_fetch_long", test_fetch_long, 1, 0, NULL , NULL},
+  {"test_fetch_short", test_fetch_short, 1, 0, NULL , NULL},
+  {"test_fetch_tiny", test_fetch_tiny, 1, 0, NULL , NULL},
+  {"test_fetch_bigint", test_fetch_bigint, 1, 0, NULL , NULL},
+  {"test_fetch_float", test_fetch_float, 1, 0, NULL , NULL},
+  {"test_fetch_double", test_fetch_double, 1, 0, NULL , NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/fingerprint.list.in b/libmariadb/unittest/libmariadb/fingerprint.list.in
new file mode 100644
index 00000000..06f2be28
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/fingerprint.list.in
@@ -0,0 +1,4 @@
+86DD6D764C0CA47C5014E1E7802674BFDB674ED3
+@SSL_CERT_FINGER_PRINT@
+73F1FEC1FE041473563BFF2D624B88F6CFCFE626
+
diff --git a/libmariadb/unittest/libmariadb/getopt.c b/libmariadb/unittest/libmariadb/getopt.c
new file mode 100644
index 00000000..50debeff
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/getopt.c
@@ -0,0 +1,742 @@
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
+   before changing it!
+
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94
+	Free Software Foundation, Inc.
+
+Changes by monty:
+- Added include of string.h when necessary.
+- Removed two warnings from gcc.
+
+This file is part of the GNU C Library.  Its master source is NOT part of
+the C library, however.  The master source lives in /gd/gnu/lib.
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
+   Ditto for AIX 3.2 and <stdlib.h>.  */
+#ifndef _NO_PROTO
+#define _NO_PROTO
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#if (!defined (__STDC__) || !__STDC__) && !defined(MSDOS) && !defined(OS2)
+/* This is a separate conditional since some stdc systems
+   reject `defined (const)'.  */
+#ifndef const
+#define const
+#endif
+#endif
+
+#include <ma_global.h>				/* Changes for mysys */
+#include <ma_string.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.	Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
+
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef	__GNU_LIBRARY__
+/* Don't include stdlib.h for non-GNU C libraries because some of them
+   contain conflicting prototypes for getopt.  */
+#include <stdlib.h>
+#endif	/* GNU C library.  */
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+#include "ma_getopt.h"
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+char *optarg = NULL;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+/* XXX 1003.2 says this must be 1 before any call.  */
+int optind = 1;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+   for unrecognized options.  */
+
+int opterr = 1;
+
+/* Set to an option character which was unrecognized.
+   This must be initialized on some systems to avoid linking in the
+   system's own getopt implementation.	*/
+
+int optopt = '?';
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect options and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.	In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
+
+static enum
+{
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+static char *posixly_correct;
+
+#ifdef	__GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
+#include <string.h>
+#define my_index	strchr
+#else
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+static char *
+my_index (const char *str, int chr)
+{
+  while (*str)
+    {
+      if (*str == chr)
+	return (char *) str;
+      str++;
+    }
+  return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+   If not using GCC, it is ok not to declare it.  */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+   That was relevant to code that was here before.  */
+#if !defined (__STDC__) || !__STDC__
+/* gcc with -traditional declares the built-in strlen to return int,
+   and has done so at least since version 2.4.5. -- rms.  */
+extern int strlen (const char *);
+#endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,optind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+static void
+exchange (char **argv)
+{
+  int bottom = first_nonopt;
+  int middle = last_nonopt;
+  int top = optind;
+  char *tem;
+
+  /* Exchange the shorter segment with the far end of the longer segment.
+     That puts the shorter segment into the right place.
+     It leaves the longer segment in the right place overall,
+     but it consists of two parts that need to be swapped next.  */
+
+  while (top > middle && middle > bottom)
+    {
+      if (top - middle > middle - bottom)
+	{
+	  /* Bottom segment is the short one.  */
+	  int len = middle - bottom;
+	  register int i;
+
+	  /* Swap it with the top part of the top segment.  */
+	  for (i = 0; i < len; i++)
+	    {
+	      tem = argv[bottom + i];
+	      argv[bottom + i] = argv[top - (middle - bottom) + i];
+	      argv[top - (middle - bottom) + i] = tem;
+	    }
+	  /* Exclude the moved bottom segment from further swapping.  */
+	  top -= len;
+	}
+      else
+	{
+	  /* Top segment is the short one.  */
+	  int len = top - middle;
+	  register int i;
+
+	  /* Swap it with the bottom part of the bottom segment.  */
+	  for (i = 0; i < len; i++)
+	    {
+	      tem = argv[bottom + i];
+	      argv[bottom + i] = argv[middle + i];
+	      argv[middle + i] = tem;
+	    }
+	  /* Exclude the moved top segment from further swapping.  */
+	  bottom += len;
+	}
+    }
+
+  /* Update records for the slots the non-options now occupy.  */
+
+  first_nonopt += (optind - last_nonopt);
+  last_nonopt = optind;
+}
+
+/* Initialize the internal data when the first call is made.  */
+
+static const char *
+_getopt_initialize (const char *optstring)
+{
+  /* Start processing options with ARGV-element 1 (since ARGV-element 0
+     is the program name); the sequence of previously skipped
+     non-option ARGV-elements is empty.  */
+
+  first_nonopt = last_nonopt = optind = 1;
+
+  nextchar = NULL;
+
+  posixly_correct = getenv ("POSIXLY_CORRECT");
+
+  /* Determine how to handle the ordering of options and nonoptions.  */
+
+  if (optstring[0] == '-')
+    {
+      ordering = RETURN_IN_ORDER;
+      ++optstring;
+    }
+  else if (optstring[0] == '+')
+    {
+      ordering = REQUIRE_ORDER;
+      ++optstring;
+    }
+  else if (posixly_correct != NULL)
+    ordering = REQUIRE_ORDER;
+  else
+    ordering = PERMUTE;
+
+  return optstring;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.	If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `optind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns `EOF'.
+   Then `optind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.	If you set `opterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `optarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `optarg', otherwise `optarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct option' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.	*/
+
+int
+_getopt_internal (int argc, char *const *argv, const char *optstring, const struct option *longopts, int *longind, int long_only)
+{
+  optarg = NULL;
+
+  if (optind == 0)
+    optstring = _getopt_initialize (optstring);
+
+  if (nextchar == NULL || *nextchar == '\0')
+    {
+      /* Advance to the next ARGV-element.  */
+
+      if (ordering == PERMUTE)
+	{
+	  /* If we have just processed some options following some non-options,
+	     exchange them so that the options come first.  */
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (last_nonopt != optind)
+	    first_nonopt = optind;
+
+	  /* Skip any additional non-options
+	     and extend the range of non-options previously skipped.  */
+
+	  while (optind < argc
+		 && (argv[optind][0] != '-' || argv[optind][1] == '\0'))
+	    optind++;
+	  last_nonopt = optind;
+	}
+
+      /* The special ARGV-element `--' means premature end of options.
+	 Skip it like a null option,
+	 then exchange with previous non-options as if it were an option,
+	 then skip everything else like a non-option.  */
+
+      if (optind != argc && !strcmp (argv[optind], "--"))
+	{
+	  optind++;
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (first_nonopt == last_nonopt)
+	    first_nonopt = optind;
+	  last_nonopt = argc;
+
+	  optind = argc;
+	}
+
+      /* If we have done all the ARGV-elements, stop the scan
+	 and back over any non-options that we skipped and permuted.  */
+
+      if (optind == argc)
+	{
+	  /* Set the next-arg-index to point at the non-options
+	     that we previously skipped, so the caller will digest them.  */
+	  if (first_nonopt != last_nonopt)
+	    optind = first_nonopt;
+	  return EOF;
+	}
+
+      /* If we have come to a non-option and did not permute it,
+	 either stop the scan or describe it to the caller and pass it by.  */
+
+      if ((argv[optind][0] != '-' || argv[optind][1] == '\0'))
+	{
+	  if (ordering == REQUIRE_ORDER)
+	    return EOF;
+	  optarg = argv[optind++];
+	  return 1;
+	}
+
+      /* We have found another option-ARGV-element.
+	 Skip the initial punctuation.	*/
+
+      nextchar = (argv[optind] + 1
+		  + (longopts != NULL && argv[optind][1] == '-'));
+    }
+
+  /* Decode the current option-ARGV-element.  */
+
+  /* Check whether the ARGV-element is a long option.
+
+     If long_only and the ARGV-element has the form "-f", where f is
+     a valid short option, don't consider it an abbreviated form of
+     a long option that starts with f.	Otherwise there would be no
+     way to give the -f short option.
+
+     On the other hand, if there's a long option "fubar" and
+     the ARGV-element is "-fu", do consider that an abbreviation of
+     the long option, just like "--fu", and not "-f" with arg "u".
+
+     This distinction seems to be the most useful approach.  */
+
+  if (longopts != NULL
+      && (argv[optind][1] == '-'
+	  || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+    {
+      char *nameend;
+      const struct option *p;
+      const struct option *pfound = NULL;
+      int exact = 0;
+      int ambig = 0;
+      int indfound=0;				/* Keep gcc happy */
+      int option_index;
+
+      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+	/* Do nothing.	*/ ;
+
+      /* Test all long options for either exact match
+	 or abbreviated matches.  */
+      for (p = longopts, option_index = 0; p->name; p++, option_index++)
+	if (!strncmp (p->name, nextchar, nameend - nextchar))
+	  {
+	    if ((size_t) (nameend - nextchar) == (size_t) strlen (p->name))
+	      {
+		/* Exact match found.  */
+		pfound = p;
+		indfound = option_index;
+		exact = 1;
+		break;
+	      }
+	    else if (pfound == NULL)
+	      {
+		/* First nonexact match found.	*/
+		pfound = p;
+		indfound = option_index;
+	      }
+	    else
+	      /* Second or later nonexact match found.	*/
+	      ambig = 1;
+	  }
+
+      if (ambig && !exact)
+	{
+	  if (opterr)
+	    fprintf (stderr, "%s: option `%s' is ambiguous\n",
+		     argv[0], argv[optind]);
+	  nextchar += strlen (nextchar);
+	  optind++;
+	  return '?';
+	}
+
+      if (pfound != NULL)
+	{
+	  option_index = indfound;
+	  optind++;
+	  if (*nameend)
+	    {
+	      /* Don't test has_arg with >, because some C compilers don't
+		 allow it to be used on enums.	*/
+	      if (pfound->has_arg)
+		optarg = nameend + 1;
+	      else
+		{
+		  if (opterr)
+		    {
+		      if (argv[optind - 1][1] == '-')
+			/* --option */
+			fprintf (stderr,
+				 "%s: option `--%s' doesn't allow an argument\n",
+				 argv[0], pfound->name);
+		      else
+			/* +option or -option */
+			fprintf (stderr,
+			     "%s: option `%c%s' doesn't allow an argument\n",
+			     argv[0], argv[optind - 1][0], pfound->name);
+		    }
+		  nextchar += strlen (nextchar);
+		  return '?';
+		}
+	    }
+	  else if (pfound->has_arg == 1)
+	    {
+	      if (optind < argc)
+		optarg = argv[optind++];
+	      else
+		{
+		  if (opterr)
+		    fprintf (stderr, "%s: option `%s' requires an argument\n",
+			     argv[0], argv[optind - 1]);
+		  nextchar += strlen (nextchar);
+		  return optstring[0] == ':' ? ':' : '?';
+		}
+	    }
+	  nextchar += strlen (nextchar);
+	  if (longind != NULL)
+	    *longind = option_index;
+	  if (pfound->flag)
+	    {
+	      *(pfound->flag) = pfound->val;
+	      return 0;
+	    }
+	  return pfound->val;
+	}
+
+      /* Can't find it as a long option.  If this is not getopt_long_only,
+	 or the option starts with '--' or is not a valid short
+	 option, then it's an error.
+	 Otherwise interpret it as a short option.  */
+      if (!long_only || argv[optind][1] == '-'
+	  || my_index (optstring, *nextchar) == NULL)
+	{
+	  if (opterr)
+	    {
+	      if (argv[optind][1] == '-')
+		/* --option */
+		fprintf (stderr, "%s: unrecognized option `--%s'\n",
+			 argv[0], nextchar);
+	      else
+		/* +option or -option */
+		fprintf (stderr, "%s: unrecognized option `%c%s'\n",
+			 argv[0], argv[optind][0], nextchar);
+	    }
+	  nextchar = (char *) "";
+	  optind++;
+	  return '?';
+	}
+    }
+
+  /* Look at and handle the next short option-character.  */
+
+  {
+    char c = *nextchar++;
+    char *temp = my_index (optstring, c);
+
+    /* Increment `optind' when we start to process its last character.	*/
+    if (*nextchar == '\0')
+      ++optind;
+
+    if (temp == NULL || c == ':')
+      {
+	if (opterr)
+	  {
+	    if (posixly_correct)
+	      /* 1003.2 specifies the format of this message.  */
+	      fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
+	    else
+	      fprintf (stderr, "%s: invalid option -- %c\n", argv[0], c);
+	  }
+	optopt = c;
+	return '?';
+      }
+    if (temp[1] == ':')
+      {
+	if (temp[2] == ':')
+	  {
+	    /* This is an option that accepts an argument optionally.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		optind++;
+	      }
+	    else
+	      optarg = NULL;
+	    nextchar = NULL;
+	  }
+	else
+	  {
+	    /* This is an option that requires an argument.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		/* If we end this ARGV-element by taking the rest as an arg,
+		   we must advance to the next element now.  */
+		optind++;
+	      }
+	    else if (optind == argc)
+	      {
+		if (opterr)
+		  {
+		    /* 1003.2 specifies the format of this message.  */
+		    fprintf (stderr, "%s: option requires an argument -- %c\n",
+			     argv[0], c);
+		  }
+		optopt = c;
+		if (optstring[0] == ':')
+		  c = ':';
+		else
+		  c = '?';
+	      }
+	    else
+	      /* We already incremented `optind' once;
+		 increment it again when taking next ARGV-elt as argument.  */
+	      optarg = argv[optind++];
+	    nextchar = NULL;
+	  }
+      }
+    return c;
+  }
+}
+
+int
+getopt (int argc, char *const *argv, const char *optstring)
+{
+  return _getopt_internal (argc, argv, optstring,
+			   (const struct option *) 0,
+			   (int *) 0,
+			   0);
+}
+
+#endif	/* _LIBC or not __GNU_LIBRARY__.  */
+
+#ifdef TEST
+
+/* Compile with -DTEST to make an executable for use in testing
+   the above definition of `getopt'.  */
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c;
+  int digit_optind = 0;
+
+  while (1)
+    {
+      int this_option_optind = optind ? optind : 1;
+
+      c = getopt (argc, argv, "abc:d:0123456789");
+      if (c == EOF)
+	break;
+
+      switch (c)
+	{
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	  if (digit_optind != 0 && digit_optind != this_option_optind)
+	    printf ("digits occur in two different argv-elements.\n");
+	  digit_optind = this_option_optind;
+	  printf ("option %c\n", c);
+	  break;
+
+	case 'a':
+	  printf ("option a\n");
+	  break;
+
+	case 'b':
+	  printf ("option b\n");
+	  break;
+
+	case 'c':
+	  printf ("option c with value `%s'\n", optarg);
+	  break;
+
+	case '?':
+	  break;
+
+	default:
+	  printf ("?? getopt returned character code 0%o ??\n", c);
+	}
+    }
+
+  if (optind < argc)
+    {
+      printf ("non-option ARGV-elements: ");
+      while (optind < argc)
+	printf ("%s ", argv[optind++]);
+      printf ("\n");
+    }
+
+  exit (0);
+}
+
+#endif /* TEST */
diff --git a/libmariadb/unittest/libmariadb/logs.c b/libmariadb/unittest/libmariadb/logs.c
new file mode 100644
index 00000000..e66144cf
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/logs.c
@@ -0,0 +1,217 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+#include "my_test.h"
+
+#ifdef ENABLE_IF_IN_USE
+static int enable_general_log(MYSQL *mysql, int truncate)
+{
+  int rc;
+
+  rc= mysql_query(mysql, "set @save_global_general_log=@@global.general_log");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "set @@global.general_log=on");
+  check_mysql_rc(rc, mysql);
+
+  if (truncate)
+  {
+    rc= mysql_query(mysql, "truncate mysql.general_log");
+    check_mysql_rc(rc, mysql);
+  }
+
+  return OK;
+}
+
+
+static int restore_general_log(MYSQL *mysql)
+{
+  int rc;
+  rc= mysql_query(mysql, "set @@global.general_log=@save_global_general_log");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+#endif
+
+/* Test update/binary logs */
+
+static int test_logs(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[2];
+  char       data[255];
+  size_t     length;
+  int        rc;
+  short      id;
+
+  rc= mysql_query(mysql, "SET session sql_mode=''");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_logs");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_logs(id smallint, name varchar(20))");
+  check_mysql_rc(rc, mysql);
+
+  strcpy((char *)data, "INSERT INTO test_logs VALUES(?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL(data));
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[0].buffer= (void *)&id;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= (void *)&data;
+  my_bind[1].buffer_length= 255;
+  my_bind[1].length= (unsigned long *)&length;
+
+  id= 9876;
+  strcpy((char *)data, "MySQL - Open Source Database");
+  length= strlen(data);
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  strcpy((char *)data, "'");
+  length= 1;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  strcpy((char *)data, "\"");
+  length= 1;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  strcpy((char *)data, "my\'sql\'");
+  length= strlen(data);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  strcpy((char *)data, "my\"sql\"");
+  length= strlen(data);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  strcpy((char *)data, "INSERT INTO test_logs VALUES(20, 'mysql')");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL(data));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  strcpy((char *)data, "SELECT * FROM test_logs WHERE id=?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL(data));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  my_bind[1].buffer_length= 255;
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(id == 9876, "id != 9876");
+  FAIL_UNLESS(length == 19 || length == 20, "Invalid Length"); /* Due to VARCHAR(20) */
+  FAIL_UNLESS(strncmp(data, "MySQL - Open Source", 19) == 0, "data != 'MySQL - Open Source'");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(length == 1, "length != 1");
+  FAIL_UNLESS(strcmp(data, "'") == 0, "data != '''");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(length == 1, "length != 1");
+  FAIL_UNLESS(strcmp(data, "\"") == 0, "data != '\"'");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(length == 7, "length != 7");
+  FAIL_UNLESS(strcmp(data, "my\'sql\'") == 0, "data != my'sql'");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(length == 7, "length != 7");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE test_logs");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+struct my_tests_st my_tests[] = {
+  {"test_logs", test_logs, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/ma_getopt.c b/libmariadb/unittest/libmariadb/ma_getopt.c
new file mode 100644
index 00000000..186cdcd5
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/ma_getopt.c
@@ -0,0 +1,741 @@
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
+   before changing it!
+
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94
+	Free Software Foundation, Inc.
+
+Changes by monty:
+- Added include of string.h when necessary.
+- Removed two warnings from gcc.
+
+This file is part of the GNU C Library.  Its master source is NOT part of
+the C library, however.  The master source lives in /gd/gnu/lib.
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
+   Ditto for AIX 3.2 and <stdlib.h>.  */
+#ifndef _NO_PROTO
+#define _NO_PROTO
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#if (!defined (__STDC__) || !__STDC__) && !defined(MSDOS) && !defined(OS2)
+/* This is a separate conditional since some stdc systems
+   reject `defined (const)'.  */
+#ifndef const
+#define const
+#endif
+#endif
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.	Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
+
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef	__GNU_LIBRARY__
+/* Don't include stdlib.h for non-GNU C libraries because some of them
+   contain conflicting prototypes for getopt.  */
+#include <stdlib.h>
+#endif	/* GNU C library.  */
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+#include "ma_getopt.h"
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+char *optarg = NULL;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+/* XXX 1003.2 says this must be 1 before any call.  */
+int optind = 1;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+   for unrecognized options.  */
+
+int opterr = 1;
+
+/* Set to an option character which was unrecognized.
+   This must be initialized on some systems to avoid linking in the
+   system's own getopt implementation.	*/
+
+int optopt = '?';
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect options and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.	In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
+
+static enum
+{
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+static char *posixly_correct;
+
+#ifdef	__GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
+#include <string.h>
+#define my_index	strchr
+#else
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+static char *
+my_index (const char *str, int chr)
+{
+  while (*str)
+    {
+      if (*str == chr)
+	return (char *) str;
+      str++;
+    }
+  return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+   If not using GCC, it is ok not to declare it.  */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+   That was relevant to code that was here before.  */
+#if !defined (__STDC__) || !__STDC__
+/* gcc with -traditional declares the built-in strlen to return int,
+   and has done so at least since version 2.4.5. -- rms.  */
+extern int strlen (const char *);
+#endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,optind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+static void
+exchange (char **argv)
+{
+  int bottom = first_nonopt;
+  int middle = last_nonopt;
+  int top = optind;
+  char *tem;
+
+  /* Exchange the shorter segment with the far end of the longer segment.
+     That puts the shorter segment into the right place.
+     It leaves the longer segment in the right place overall,
+     but it consists of two parts that need to be swapped next.  */
+
+  while (top > middle && middle > bottom)
+    {
+      if (top - middle > middle - bottom)
+	{
+	  /* Bottom segment is the short one.  */
+	  int len = middle - bottom;
+	  register int i;
+
+	  /* Swap it with the top part of the top segment.  */
+	  for (i = 0; i < len; i++)
+	    {
+	      tem = argv[bottom + i];
+	      argv[bottom + i] = argv[top - (middle - bottom) + i];
+	      argv[top - (middle - bottom) + i] = tem;
+	    }
+	  /* Exclude the moved bottom segment from further swapping.  */
+	  top -= len;
+	}
+      else
+	{
+	  /* Top segment is the short one.  */
+	  int len = top - middle;
+	  register int i;
+
+	  /* Swap it with the bottom part of the bottom segment.  */
+	  for (i = 0; i < len; i++)
+	    {
+	      tem = argv[bottom + i];
+	      argv[bottom + i] = argv[middle + i];
+	      argv[middle + i] = tem;
+	    }
+	  /* Exclude the moved top segment from further swapping.  */
+	  bottom += len;
+	}
+    }
+
+  /* Update records for the slots the non-options now occupy.  */
+
+  first_nonopt += (optind - last_nonopt);
+  last_nonopt = optind;
+}
+
+/* Initialize the internal data when the first call is made.  */
+
+static const char *
+_getopt_initialize (const char *optstring)
+{
+  /* Start processing options with ARGV-element 1 (since ARGV-element 0
+     is the program name); the sequence of previously skipped
+     non-option ARGV-elements is empty.  */
+
+  first_nonopt = last_nonopt = optind = 1;
+
+  nextchar = NULL;
+
+  posixly_correct = getenv ("POSIXLY_CORRECT");
+
+  /* Determine how to handle the ordering of options and nonoptions.  */
+
+  if (optstring[0] == '-')
+    {
+      ordering = RETURN_IN_ORDER;
+      ++optstring;
+    }
+  else if (optstring[0] == '+')
+    {
+      ordering = REQUIRE_ORDER;
+      ++optstring;
+    }
+  else if (posixly_correct != NULL)
+    ordering = REQUIRE_ORDER;
+  else
+    ordering = PERMUTE;
+
+  return optstring;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.	If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `optind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns `EOF'.
+   Then `optind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.	If you set `opterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `optarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `optarg', otherwise `optarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct option' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.	*/
+
+int
+_getopt_internal (int argc, char *const *argv, const char *optstring, const struct option *longopts, int *longind, int long_only)
+{
+  optarg = NULL;
+
+  if (optind == 0)
+    optstring = _getopt_initialize (optstring);
+
+  if (nextchar == NULL || *nextchar == '\0')
+    {
+      /* Advance to the next ARGV-element.  */
+
+      if (ordering == PERMUTE)
+	{
+	  /* If we have just processed some options following some non-options,
+	     exchange them so that the options come first.  */
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (last_nonopt != optind)
+	    first_nonopt = optind;
+
+	  /* Skip any additional non-options
+	     and extend the range of non-options previously skipped.  */
+
+	  while (optind < argc
+		 && (argv[optind][0] != '-' || argv[optind][1] == '\0'))
+	    optind++;
+	  last_nonopt = optind;
+	}
+
+      /* The special ARGV-element `--' means premature end of options.
+	 Skip it like a null option,
+	 then exchange with previous non-options as if it were an option,
+	 then skip everything else like a non-option.  */
+
+      if (optind != argc && !strcmp (argv[optind], "--"))
+	{
+	  optind++;
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (first_nonopt == last_nonopt)
+	    first_nonopt = optind;
+	  last_nonopt = argc;
+
+	  optind = argc;
+	}
+
+      /* If we have done all the ARGV-elements, stop the scan
+	 and back over any non-options that we skipped and permuted.  */
+
+      if (optind == argc)
+	{
+	  /* Set the next-arg-index to point at the non-options
+	     that we previously skipped, so the caller will digest them.  */
+	  if (first_nonopt != last_nonopt)
+	    optind = first_nonopt;
+	  return EOF;
+	}
+
+      /* If we have come to a non-option and did not permute it,
+	 either stop the scan or describe it to the caller and pass it by.  */
+
+      if ((argv[optind][0] != '-' || argv[optind][1] == '\0'))
+	{
+	  if (ordering == REQUIRE_ORDER)
+	    return EOF;
+	  optarg = argv[optind++];
+	  return 1;
+	}
+
+      /* We have found another option-ARGV-element.
+	 Skip the initial punctuation.	*/
+
+      nextchar = (argv[optind] + 1
+		  + (longopts != NULL && argv[optind][1] == '-'));
+    }
+
+  /* Decode the current option-ARGV-element.  */
+
+  /* Check whether the ARGV-element is a long option.
+
+     If long_only and the ARGV-element has the form "-f", where f is
+     a valid short option, don't consider it an abbreviated form of
+     a long option that starts with f.	Otherwise there would be no
+     way to give the -f short option.
+
+     On the other hand, if there's a long option "fubar" and
+     the ARGV-element is "-fu", do consider that an abbreviation of
+     the long option, just like "--fu", and not "-f" with arg "u".
+
+     This distinction seems to be the most useful approach.  */
+
+  if (longopts != NULL
+      && (argv[optind][1] == '-'
+	  || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+    {
+      char *nameend;
+      const struct option *p;
+      const struct option *pfound = NULL;
+      int exact = 0;
+      int ambig = 0;
+      int indfound=0;				/* Keep gcc happy */
+      int option_index;
+
+      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+	/* Do nothing.	*/ ;
+
+      /* Test all long options for either exact match
+	 or abbreviated matches.  */
+      for (p = longopts, option_index = 0; p->name; p++, option_index++)
+	if (!strncmp (p->name, nextchar, nameend - nextchar))
+	  {
+	    if ((size_t) (nameend - nextchar) == (size_t) strlen (p->name))
+	      {
+		/* Exact match found.  */
+		pfound = p;
+		indfound = option_index;
+		exact = 1;
+		break;
+	      }
+	    else if (pfound == NULL)
+	      {
+		/* First nonexact match found.	*/
+		pfound = p;
+		indfound = option_index;
+	      }
+	    else
+	      /* Second or later nonexact match found.	*/
+	      ambig = 1;
+	  }
+
+      if (ambig && !exact)
+	{
+	  if (opterr)
+	    fprintf (stderr, "%s: option `%s' is ambiguous\n",
+		     argv[0], argv[optind]);
+	  nextchar += strlen (nextchar);
+	  optind++;
+	  return '?';
+	}
+
+      if (pfound != NULL)
+	{
+	  option_index = indfound;
+	  optind++;
+	  if (*nameend)
+	    {
+	      /* Don't test has_arg with >, because some C compilers don't
+		 allow it to be used on enums.	*/
+	      if (pfound->has_arg)
+		optarg = nameend + 1;
+	      else
+		{
+		  if (opterr)
+		    {
+		      if (argv[optind - 1][1] == '-')
+			/* --option */
+			fprintf (stderr,
+				 "%s: option `--%s' doesn't allow an argument\n",
+				 argv[0], pfound->name);
+		      else
+			/* +option or -option */
+			fprintf (stderr,
+			     "%s: option `%c%s' doesn't allow an argument\n",
+			     argv[0], argv[optind - 1][0], pfound->name);
+		    }
+		  nextchar += strlen (nextchar);
+		  return '?';
+		}
+	    }
+	  else if (pfound->has_arg == 1)
+	    {
+	      if (optind < argc)
+		optarg = argv[optind++];
+	      else
+		{
+		  if (opterr)
+		    fprintf (stderr, "%s: option `%s' requires an argument\n",
+			     argv[0], argv[optind - 1]);
+		  nextchar += strlen (nextchar);
+		  return optstring[0] == ':' ? ':' : '?';
+		}
+	    }
+	  nextchar += strlen (nextchar);
+	  if (longind != NULL)
+	    *longind = option_index;
+	  if (pfound->flag)
+	    {
+	      *(pfound->flag) = pfound->val;
+	      return 0;
+	    }
+	  return pfound->val;
+	}
+
+      /* Can't find it as a long option.  If this is not getopt_long_only,
+	 or the option starts with '--' or is not a valid short
+	 option, then it's an error.
+	 Otherwise interpret it as a short option.  */
+      if (!long_only || argv[optind][1] == '-'
+	  || my_index (optstring, *nextchar) == NULL)
+	{
+	  if (opterr)
+	    {
+	      if (argv[optind][1] == '-')
+		/* --option */
+		fprintf (stderr, "%s: unrecognized option `--%s'\n",
+			 argv[0], nextchar);
+	      else
+		/* +option or -option */
+		fprintf (stderr, "%s: unrecognized option `%c%s'\n",
+			 argv[0], argv[optind][0], nextchar);
+	    }
+	  nextchar = (char *) "";
+	  optind++;
+	  return '?';
+	}
+    }
+
+  /* Look at and handle the next short option-character.  */
+
+  {
+    char c = *nextchar++;
+    char *temp = my_index (optstring, c);
+
+    /* Increment `optind' when we start to process its last character.	*/
+    if (*nextchar == '\0')
+      ++optind;
+
+    if (temp == NULL || c == ':')
+      {
+	if (opterr)
+	  {
+	    if (posixly_correct)
+	      /* 1003.2 specifies the format of this message.  */
+	      fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
+	    else
+	      fprintf (stderr, "%s: invalid option -- %c\n", argv[0], c);
+	  }
+	optopt = c;
+	return '?';
+      }
+    if (temp[1] == ':')
+      {
+	if (temp[2] == ':')
+	  {
+	    /* This is an option that accepts an argument optionally.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		optind++;
+	      }
+	    else
+	      optarg = NULL;
+	    nextchar = NULL;
+	  }
+	else
+	  {
+	    /* This is an option that requires an argument.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		/* If we end this ARGV-element by taking the rest as an arg,
+		   we must advance to the next element now.  */
+		optind++;
+	      }
+	    else if (optind == argc)
+	      {
+		if (opterr)
+		  {
+		    /* 1003.2 specifies the format of this message.  */
+		    fprintf (stderr, "%s: option requires an argument -- %c\n",
+			     argv[0], c);
+		  }
+		optopt = c;
+		if (optstring[0] == ':')
+		  c = ':';
+		else
+		  c = '?';
+	      }
+	    else
+	      /* We already incremented `optind' once;
+		 increment it again when taking next ARGV-elt as argument.  */
+	      optarg = argv[optind++];
+	    nextchar = NULL;
+	  }
+      }
+    return c;
+  }
+}
+
+int
+getopt (int argc, char *const *argv, const char *optstring)
+{
+  return _getopt_internal (argc, argv, optstring,
+			   (const struct option *) 0,
+			   (int *) 0,
+			   0);
+}
+
+#endif	/* _LIBC or not __GNU_LIBRARY__.  */
+
+#ifdef TEST
+
+/* Compile with -DTEST to make an executable for use in testing
+   the above definition of `getopt'.  */
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c;
+  int digit_optind = 0;
+
+  while (1)
+    {
+      int this_option_optind = optind ? optind : 1;
+
+      c = getopt (argc, argv, "abc:d:0123456789");
+      if (c == EOF)
+	break;
+
+      switch (c)
+	{
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	  if (digit_optind != 0 && digit_optind != this_option_optind)
+	    printf ("digits occur in two different argv-elements.\n");
+	  digit_optind = this_option_optind;
+	  printf ("option %c\n", c);
+	  break;
+
+	case 'a':
+	  printf ("option a\n");
+	  break;
+
+	case 'b':
+	  printf ("option b\n");
+	  break;
+
+	case 'c':
+	  printf ("option c with value `%s'\n", optarg);
+	  break;
+
+	case '?':
+	  break;
+
+	default:
+	  printf ("?? getopt returned character code 0%o ??\n", c);
+	}
+    }
+
+  if (optind < argc)
+    {
+      printf ("non-option ARGV-elements: ");
+      while (optind < argc)
+	printf ("%s ", argv[optind++]);
+      printf ("\n");
+    }
+
+  exit (0);
+}
+
+#endif /* TEST */
diff --git a/libmariadb/unittest/libmariadb/ma_getopt.h b/libmariadb/unittest/libmariadb/ma_getopt.h
new file mode 100644
index 00000000..790915b9
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/ma_getopt.h
@@ -0,0 +1,135 @@
+/* Declarations for getopt.
+   Copyright (C) 1989, 90, 91, 92, 93, 94 Free Software Foundation, Inc.
+
+This file is part of the GNU C Library.  Its master source is NOT part of
+the C library, however.  The master source lives in /gd/gnu/lib.
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef _GETOPT_H
+#define _GETOPT_H 1
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+extern char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+extern int optind;
+
+/* Callers store zero here to inhibit the error message `getopt' prints
+   for unrecognized options.  */
+
+extern int opterr;
+
+/* Set to an option character which was unrecognized.  */
+
+extern int optopt;
+
+/* Describe the long-named options requested by the application.
+   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+   of `struct option' terminated by an element containing a name which is
+   zero.
+
+   The field `has_arg' is:
+   no_argument		(or 0) if the option does not take an argument,
+   required_argument	(or 1) if the option requires an argument,
+   optional_argument	(or 2) if the option takes an optional argument.
+
+   If the field `flag' is not NULL, it points to a variable that is set
+   to the value given in the field `val' when the option is found, but
+   left unchanged if the option is not found.
+
+   To have a long-named option do something other than set an `int' to
+   a compiled-in constant, such as set a value from `optarg', set the
+   option's `flag' field to zero and its `val' field to a nonzero
+   value (the equivalent single-letter option character, if there is
+   one).  For long options that have a zero `flag' field, `getopt'
+   returns the contents of the `val' field.  */
+
+struct option
+{
+#if defined (__STDC__) && __STDC__ || defined(__cplusplus)
+  const char *name;
+#else
+  char *name;
+#endif
+  /* has_arg can't be an enum because some compilers complain about
+     type mismatches in all the code that assumes it is an int.  */
+  int has_arg;
+  int *flag;
+  int val;
+};
+
+/* Names for the values of the `has_arg' field of `struct option'.  */
+
+#define no_argument		0
+#define required_argument	1
+#define optional_argument	2
+
+#if ( defined (__STDC__) && __STDC__ ) || defined(__cplusplus) || defined(MSDOS)
+#ifdef __EMX__
+int getopt (int, char **, __const__ char *);
+#elif defined( __GNU_LIBRARY__)
+/* Many other libraries have conflicting prototypes for getopt, with
+   differences in the consts, in stdlib.h.  To avoid compilation
+   errors, only prototype getopt for the GNU C library.  */
+extern int getopt (int argc, char *const *argv, const char *shortopts);
+#else /* not __GNU_LIBRARY__ */
+extern int getopt (int argc, char *const *argv, const char *optstring);
+#endif /* __GNU_LIBRARY__ */
+extern int getopt_long (int argc, char *const *argv, const char *shortopts,
+			const struct option *longopts, int *longind);
+extern int getopt_long_only (int argc, char *const *argv,
+			     const char *shortopts,
+			     const struct option *longopts, int *longind);
+
+/* Internal only.  Users should not call this directly.  */
+extern int _getopt_internal (int argc, char *const *argv,
+			     const char *shortopts,
+			     const struct option *longopts, int *longind,
+			     int long_only);
+#else /* not __STDC__ */
+extern int getopt ();
+extern int getopt_long ();
+extern int getopt_long_only ();
+
+extern int _getopt_internal ();
+#endif /* __STDC__ */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _GETOPT_H */
diff --git a/libmariadb/unittest/libmariadb/misc.c b/libmariadb/unittest/libmariadb/misc.c
new file mode 100644
index 00000000..201a981b
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/misc.c
@@ -0,0 +1,1571 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+#include "my_test.h"
+#include "ma_common.h"
+
+#include <mysql/client_plugin.h>
+
+
+/*
+  Bug#28075 "COM_DEBUG crashes mysqld"
+*/
+#ifdef _WIN32
+#define R_OK 4
+#endif
+
+static int test_bug28075(MYSQL *mysql)
+{
+  int rc;
+
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  rc= mysql_dump_debug_info(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_ping(mysql);
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/*
+  Bug#28505: mysql_affected_rows() returns wrong value if CLIENT_FOUND_ROWS
+  flag is set.
+*/
+
+static int test_bug28505(MYSQL *mysql)
+{
+  unsigned long long res;
+  int rc;
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1(f1 int primary key)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 values(1)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 values(1) on duplicate key update f1=1");
+  check_mysql_rc(rc, mysql);
+  res= mysql_affected_rows(mysql);
+  FAIL_UNLESS(!res, "res != 0");
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/*
+  Bug #29692  	Single row inserts can incorrectly report a huge number of 
+  row insertions
+*/
+
+static int test_bug29692(MYSQL *mysql)
+{
+  int rc;
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1(f1 int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 values(1)");
+  check_mysql_rc(rc, mysql);
+  FAIL_UNLESS(1 == mysql_affected_rows(mysql), "affected_rows != 1");
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int bug31418_impl()
+{
+  my_bool is_null;
+  MYSQL *mysql;
+  int rc;
+
+
+  /* Create a new connection. */
+
+  mysql= test_connect(NULL);
+  if (!mysql)
+    return FAIL;
+
+  /***********************************************************************
+    Check that lock is free:
+      - IS_FREE_LOCK() should return 1;
+      - IS_USED_LOCK() should return NULL;
+  ***********************************************************************/
+
+  is_null= query_int_variable(mysql,
+                              "IS_FREE_LOCK('bug31418')",
+                              &rc);
+  FAIL_UNLESS(!is_null && rc, "rc = 0");
+
+  is_null= query_int_variable(mysql,
+                              "IS_USED_LOCK('bug31418')",
+                              &rc);
+  FAIL_UNLESS(is_null, "rc = 0");
+
+  /***********************************************************************
+    Acquire lock and check the lock status (the lock must be in use):
+      - IS_FREE_LOCK() should return 0;
+      - IS_USED_LOCK() should return non-zero thread id;
+  ***********************************************************************/
+
+  query_int_variable(mysql, "GET_LOCK('bug31418', 1)", &rc);
+  FAIL_UNLESS(rc, "rc = 0");
+
+  is_null= query_int_variable(mysql,
+                              "IS_FREE_LOCK('bug31418')",
+                              &rc);
+  FAIL_UNLESS(!is_null && !rc, "rc = 0");
+
+  is_null= query_int_variable(mysql,
+                              "IS_USED_LOCK('bug31418')",
+                              &rc);
+  FAIL_UNLESS(!is_null && rc, "rc = 0");
+
+  /***********************************************************************
+    Issue COM_CHANGE_USER command and check the lock status
+    (the lock must be free):
+      - IS_FREE_LOCK() should return 1;
+      - IS_USED_LOCK() should return NULL;
+  **********************************************************************/
+
+  rc= mysql_change_user(mysql, username, password, schema ? schema : "test");
+  check_mysql_rc(rc, mysql);
+
+  is_null= query_int_variable(mysql,
+                              "IS_FREE_LOCK('bug31418')",
+                              &rc);
+  FAIL_UNLESS(!is_null && rc, "rc = 0");
+
+  is_null= query_int_variable(mysql,
+                              "IS_USED_LOCK('bug31418')",
+                              &rc);
+  FAIL_UNLESS(is_null, "rc = 0");
+
+  /***********************************************************************
+   That's it. Cleanup.
+  ***********************************************************************/
+
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_bug31418(MYSQL *unused __attribute__((unused)))
+{
+  int i;
+  SKIP_MAXSCALE;
+
+  if (!is_mariadb)
+    return SKIP;
+  /* Run test case for BUG#31418 for three different connections. */
+
+  for (i=0; i < 3; i++)
+    if (bug31418_impl())
+      return FAIL;
+
+  return OK;
+}
+
+/* Query processing */
+
+static int test_debug_example(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_RES *result;
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_debug_example");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_debug_example("
+                         "id INT PRIMARY KEY AUTO_INCREMENT, "
+                         "name VARCHAR(20), xxx INT)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_debug_example (name) "
+                         "VALUES ('mysql')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "UPDATE test_debug_example SET name='updated' "
+                         "WHERE name='deleted'");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT * FROM test_debug_example where name='mysql'");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_use_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  while (mysql_fetch_row(result));
+  mysql_free_result(result);
+
+  rc= mysql_query(mysql, "DROP TABLE test_debug_example");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/*
+  Test a crash when invalid/corrupted .frm is used in the
+  SHOW TABLE STATUS
+  bug #93 (reported by serg@mysql.com).
+*/
+
+static int test_frm_bug(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[2];
+  MYSQL_RES  *result;
+  MYSQL_ROW  row;
+  FILE       *test_file;
+  char       data_dir[FN_REFLEN];
+  char       test_frm[1024];
+  int        rc;
+
+  mysql_autocommit(mysql, TRUE);
+
+  rc= mysql_query(mysql, "drop table if exists test_frm_bug");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "flush tables");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("show variables like 'datadir'"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= data_dir;
+  my_bind[0].buffer_length= FN_REFLEN;
+  my_bind[1]= my_bind[0];
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  snprintf(test_frm, sizeof(test_frm)-1, "%s/%s/test_frm_bug.frm", data_dir, schema);
+
+  if (!(test_file= fopen(test_frm, "w")))
+  {
+    mysql_stmt_close(stmt);
+    diag("Can't write to file %s -> SKIP", test_frm);
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "SHOW TABLE STATUS like 'test_frm_bug'");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");/* It can't be NULL */
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 0");
+
+  mysql_data_seek(result, 0);
+
+  row= mysql_fetch_row(result);
+  FAIL_IF(!row, "couldn't fetch row");
+
+  FAIL_UNLESS(row[17] != 0, "row[17] != 0");
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+
+  fclose(test_file);
+  mysql_query(mysql, "drop table if exists test_frm_bug");
+  unlink(test_frm);
+  return OK;
+}
+
+static int test_wl4166_1(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        int_data;
+  char       str_data[50];
+  char       tiny_data;
+  short      small_data;
+  longlong   big_data;
+  float      real_data;
+  double     double_data;
+  ulong      length[7];
+  my_bool    is_null[7];
+  MYSQL_BIND my_bind[7];
+  const char *query;
+  int rc;
+  int i;
+
+  if (mysql_get_server_version(mysql) < 50100) {
+    diag("Test requires MySQL Server version 5.1 or above");
+    return SKIP;
+  }
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS table_4166");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE table_4166(col1 tinyint NOT NULL, "
+                         "col2 varchar(15), col3 int, "
+                         "col4 smallint, col5 bigint, "
+                         "col6 float, col7 double, "
+                         "colX varchar(10) default NULL)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  query= "INSERT INTO table_4166(col1, col2, col3, col4, col5, col6, col7) "
+          "VALUES(?, ?, ?, ?, ?, ?, ?)";
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 7, "param_count != 7");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  /* tinyint */
+  my_bind[0].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[0].buffer= (void *)&tiny_data;
+  /* string */
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= (void *)str_data;
+  my_bind[1].buffer_length= 1000;                  /* Max string length */
+  /* integer */
+  my_bind[2].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[2].buffer= (void *)&int_data;
+  /* short */
+  my_bind[3].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[3].buffer= (void *)&small_data;
+  /* bigint */
+  my_bind[4].buffer_type= MYSQL_TYPE_LONGLONG;
+  my_bind[4].buffer= (void *)&big_data;
+  /* float */
+  my_bind[5].buffer_type= MYSQL_TYPE_FLOAT;
+  my_bind[5].buffer= (void *)&real_data;
+  /* double */
+  my_bind[6].buffer_type= MYSQL_TYPE_DOUBLE;
+  my_bind[6].buffer= (void *)&double_data;
+
+  for (i= 0; i < (int) array_elements(my_bind); i++)
+  {
+    my_bind[i].length= &length[i];
+    my_bind[i].is_null= &is_null[i];
+    is_null[i]= 0;
+  }
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  int_data= 320;
+  small_data= 1867;
+  big_data= 1000;
+  real_data= 2;
+  double_data= 6578.001;
+
+  /* now, execute the prepared statement to insert 10 records.. */
+  for (tiny_data= 0; tiny_data < 10; tiny_data++)
+  {
+    length[1]= sprintf(str_data, "MySQL%d", int_data);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    int_data += 25;
+    small_data += 10;
+    big_data += 100;
+    real_data += 1;
+    double_data += 10.09;
+  }
+
+  /* force a re-prepare with some DDL */
+
+  rc= mysql_query(mysql,
+    "ALTER TABLE table_4166 change colX colX varchar(20) default NULL");
+  check_mysql_rc(rc, mysql);
+
+  /*
+    execute the prepared statement again,
+    without changing the types of parameters already bound.
+  */
+
+  for (tiny_data= 50; tiny_data < 60; tiny_data++)
+  {
+    length[1]= sprintf(str_data, "MySQL%d", int_data);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    int_data += 25;
+    small_data += 10;
+    big_data += 100;
+    real_data += 1;
+    double_data += 10.09;
+  }
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE table_4166");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+
+static int test_wl4166_2(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        c_int;
+  MYSQL_TIME d_date;
+  MYSQL_BIND bind_out[2];
+  int rc;
+
+  if (mysql_get_server_version(mysql) < 50100) {
+    diag("Test requires MySQL Server version 5.1 or above");
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (c_int int, d_date date)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "insert into t1 (c_int, d_date) values (42, '1948-05-15')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("select * from t1"));
+  check_stmt_rc(rc, stmt);
+
+  memset(bind_out, '\0', sizeof(bind_out));
+  bind_out[0].buffer_type= MYSQL_TYPE_LONG;
+  bind_out[0].buffer= (void*) &c_int;
+
+  bind_out[1].buffer_type= MYSQL_TYPE_DATE;
+  bind_out[1].buffer= (void*) &d_date;
+
+  rc= mysql_stmt_bind_result(stmt, bind_out);
+  check_stmt_rc(rc, stmt);
+
+  /* int -> varchar transition */
+
+  rc= mysql_query(mysql,
+                  "alter table t1 change column c_int c_int varchar(11)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "FLUSH TABLES");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(c_int == 42, "c_int != 42");
+  FAIL_UNLESS(d_date.year == 1948, "y!=1948");
+  FAIL_UNLESS(d_date.month == 5, "m != 5");
+  FAIL_UNLESS(d_date.day == 15, "d != 15");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  /* varchar to int retrieval with truncation */
+
+  rc= mysql_query(mysql, "update t1 set c_int='abcde'");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(!rc, "Error expected");
+
+  FAIL_UNLESS(c_int == 0, "c != 0");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  /* alter table and increase the number of columns */
+  rc= mysql_query(mysql, "alter table t1 add column d_int int");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "FLUSH TABLES");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(!rc, "Error expected");
+
+  rc= mysql_stmt_reset(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /* decrease the number of columns */
+  rc= mysql_query(mysql, "alter table t1 drop d_date, drop d_int");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_stmt_execute(stmt);
+  diag("rc=%d error: %d\n", rc, mysql_stmt_errno(stmt));
+  FAIL_IF(!rc, "Error expected");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+/**
+  Test how warnings generated during assignment of parameters
+  are (currently not) preserve in case of reprepare.
+*/
+
+static int test_wl4166_3(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  MYSQL_TIME tm[1];
+
+  if (mysql_get_server_version(mysql) < 50100) {
+    diag("Test requires MySQL Server version 5.1 or above");
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 (year datetime)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("insert into t1 (year) values (?)"));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 1, "param_count != 1");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_DATETIME;
+  my_bind[0].buffer= &tm[0];
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  tm[0].year= 2014;
+  tm[0].month= 1; tm[0].day= 1;
+  tm[0].hour= 1; tm[0].minute= 1; tm[0].second= 1;
+  tm[0].second_part= 0; tm[0].neg= 0;
+
+  /* Cause a statement reprepare */
+  rc= mysql_query(mysql, "alter table t1 add column c int");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  diag("rc=%d %s", rc, mysql_stmt_error(stmt));
+  check_stmt_rc(rc, stmt);
+
+  if (verify_col_data(mysql, "t1", "year", "2014-01-01 01:01:01")) {
+    mysql_stmt_close(stmt);
+    rc= mysql_query(mysql, "drop table t1");
+    return FAIL;
+  }
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+
+/**
+  Test that long data parameters, as well as parameters
+  that were originally in a different character set, are
+  preserved in case of reprepare.
+*/
+
+static int test_wl4166_4(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *stmt_text;
+  MYSQL_BIND bind_array[2];
+
+  /* Represented as numbers to keep UTF8 tools from clobbering them. */
+  const char *koi8= "\xee\xd5\x2c\x20\xda\xc1\x20\xd2\xd9\xc2\xc1\xcc\xcb\xd5";
+  const char *cp1251= "\xcd\xf3\x2c\x20\xe7\xe0\x20\xf0\xfb\xe1\xe0\xeb\xea\xf3";
+  char buf1[16], buf2[16];
+  ulong buf1_len, buf2_len;
+
+  if (mysql_get_server_version(mysql) < 50100) {
+    diag("Test requires MySQL Server version 5.1 or above");
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+
+  /*
+    Create table with binary columns, set session character set to cp1251,
+    client character set to koi8, and make sure that there is conversion
+    on insert and no conversion on select
+  */
+  rc= mysql_query(mysql,
+                  "create table t1 (c1 varbinary(255), c2 varbinary(255))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "set character_set_client=koi8r, "
+                         "character_set_connection=cp1251, "
+                         "character_set_results=koi8r");
+  check_mysql_rc(rc, mysql);
+
+  memset(bind_array, '\0', sizeof(bind_array));
+
+  bind_array[0].buffer_type= MYSQL_TYPE_STRING;
+
+  bind_array[1].buffer_type= MYSQL_TYPE_STRING;
+  bind_array[1].buffer= (void *) koi8;
+  bind_array[1].buffer_length= (unsigned long)strlen(koi8);
+
+  stmt= mysql_stmt_init(mysql);
+  check_stmt_rc(rc, stmt);
+
+  stmt_text= "insert into t1 (c1, c2) values (?, ?)";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_bind_param(stmt, bind_array);
+
+  mysql_stmt_send_long_data(stmt, 0, koi8, (unsigned long)strlen(koi8));
+
+  /* Cause a reprepare at statement execute */
+  rc= mysql_query(mysql, "alter table t1 add column d int");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  stmt_text= "select c1, c2 from t1";
+
+  /* c1 and c2 are binary so no conversion will be done on select */
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  bind_array[0].buffer= buf1;
+  bind_array[0].buffer_length= sizeof(buf1);
+  bind_array[0].length= &buf1_len;
+
+  bind_array[1].buffer= buf2;
+  bind_array[1].buffer_length= sizeof(buf2);
+  bind_array[1].length= &buf2_len;
+
+  mysql_stmt_bind_result(stmt, bind_array);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(buf1_len == strlen(cp1251), "");
+  FAIL_UNLESS(buf2_len == strlen(cp1251), "");
+  FAIL_UNLESS(!memcmp(buf1, cp1251, buf1_len), "");
+  FAIL_UNLESS(!memcmp(buf2, cp1251, buf1_len), "");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "set names default");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/**
+  Test that COM_REFRESH issues a implicit commit.
+*/
+
+static int test_wl4284_1(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_ROW row;
+  MYSQL_RES *result;
+
+  diag("Test temporarily disabled");
+  return SKIP;
+
+  if (mysql_get_server_version(mysql) < 60000) {
+    diag("Test requires MySQL Server version 6.0 or above");
+    return SKIP;
+  }
+
+  /* set AUTOCOMMIT to OFF */
+  rc= mysql_autocommit(mysql, FALSE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS trans");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE trans (a INT) ENGINE=InnoDB");
+
+  if (mysql_errno(mysql) == ER_UNKNOWN_STORAGE_ENGINE)
+  {
+    diag("InnoDB not configured or available");
+    return SKIP;
+  }
+
+  check_mysql_rc(rc, mysql);
+
+
+  rc= mysql_query(mysql, "INSERT INTO trans VALUES(1)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_refresh(mysql, REFRESH_GRANT | REFRESH_TABLES);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_rollback(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT * FROM trans");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_use_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  row= mysql_fetch_row(result);
+  FAIL_IF(!row, "Can't fetch row");
+
+  mysql_free_result(result);
+
+  /* set AUTOCOMMIT to OFF */
+  rc= mysql_autocommit(mysql, FALSE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE trans");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug49694(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  int i;
+  FILE *fp;
+
+  diag("Load local infile server : %ld", (mysql->server_capabilities & CLIENT_LOCAL_FILES));
+  diag("Load local infile client : %ld", (mysql->client_flag & CLIENT_LOCAL_FILES));
+
+  SKIP_LOAD_INFILE_DISABLE;
+  SKIP_SKYSQL;
+
+  rc= mysql_query(mysql, "select @@LOCAL_INFILE");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+  if (atol(row[0]) == 0) {
+      diag("Load local infile disable");
+      return SKIP;
+  }
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS enclist");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE `enclist` ("
+                         "  `pat_id` int(11) NOT NULL,"
+                         "  `episode_id` int(11) NOT NULL,"
+                         "  `enc_id` double NOT NULL,"
+                         "  PRIMARY KEY (`pat_id`,`episode_id`,`enc_id`)"
+                         ") ENGINE=MyISAM DEFAULT CHARSET=latin1");
+  check_mysql_rc(rc, mysql);
+
+  fp= fopen("data.csv", "w");
+  FAIL_IF(!fp, "Can't open data.csv");
+
+  for (i=0; i < 100; i++)
+    fprintf (fp, "%.08d,%d,%f\r\n", 100 + i, i % 3 + 1, 60000.0 + i/100);
+  fclose(fp);
+
+  rc= mysql_query(mysql, "LOAD DATA LOCAL INFILE 'data.csv' INTO TABLE enclist "
+                         "FIELDS TERMINATED BY '.' LINES TERMINATED BY '\r\n'");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DELETE FROM enclist");
+  check_mysql_rc(rc, mysql);
+
+  FAIL_IF(mysql_affected_rows(mysql) != 100, "Import failure. Expected 2 imported rows");
+
+  rc= mysql_query(mysql, "DROP TABLE enclist");
+  check_mysql_rc(rc, mysql);
+  mysql_free_result(res);
+  return OK;
+}
+
+static int test_conc49(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+
+  int i;
+  FILE *fp;
+
+  SKIP_LOAD_INFILE_DISABLE;
+  SKIP_SKYSQL;
+
+  rc= mysql_query(mysql, "select @@LOCAL_INFILE");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+
+  i= !atol(row[0]);
+  mysql_free_result(res);
+  if (i) {
+      diag("Load local infile disable");
+      return SKIP;
+  }
+
+  fp= fopen("./sample.csv", "w");
+  for (i=1; i < 4; i++)
+    fprintf(fp, "\"%d\", \"%d\", \"%d\"\r\n", i, i, i);
+  fclose(fp);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc49");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE conc49 (a int, b int, c int) Engine=InnoDB DEFAULT CHARSET=latin1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "LOAD DATA LOCAL INFILE './sample.csv' INTO TABLE conc49 FIELDS ESCAPED BY ' ' TERMINATED BY ',' ENCLOSED BY '\"' LINES TERMINATED BY '\r\n'");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT a FROM conc49");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  rc= (int)mysql_num_rows(res);
+  mysql_free_result(res);
+  FAIL_IF(rc != 3, "3 rows expected");
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc49");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_ldi_path(MYSQL *mysql)
+{
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "FLUSH TABLES");
+  check_mysql_rc(rc, mysql);
+
+#ifdef _WIN32
+  rc= mysql_query(mysql, "LOAD DATA LOCAL INFILE 'X:/non_existing_path/data.csv' INTO TABLE t1 "
+                         "FIELDS TERMINATED BY '.' LINES TERMINATED BY '\r\n'");
+#else
+  rc= mysql_query(mysql, "LOAD DATA LOCAL INFILE '/non_existing_path/data.csv' INTO TABLE t1 "
+                         "FIELDS TERMINATED BY '.' LINES TERMINATED BY '\r\n'");
+#endif
+  FAIL_IF(rc== 0, "Error expected");
+  diag("Error: %d", mysql_errno(mysql));
+  FAIL_IF(mysql_errno(mysql) == 0, "Error expected");
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+#if _WIN32
+static int test_conc44(MYSQL *mysql)
+{
+  char query[1024];
+  char *a_filename= "æøå.csv";
+  int rc;
+  int i;
+  FILE *fp;
+
+  rc= mysql_set_character_set(mysql, "latin1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS enclist");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE `enclist` ("
+                         "  `pat_id` int(11) NOT NULL,"
+                         "  `episode_id` int(11) NOT NULL,"
+                         "  `enc_id` double NOT NULL,"
+                         "  PRIMARY KEY (`pat_id`,`episode_id`,`enc_id`)"
+                         ") ENGINE=MyISAM DEFAULT CHARSET=latin1");
+  check_mysql_rc(rc, mysql);
+
+  fp= fopen(a_filename, "w");
+  FAIL_IF(!fp, "Can't open file");
+
+  for (i=0; i < 100; i++)
+    fprintf (fp, "%.08d,%d,%f\r\n", 100 + i, i % 3 + 1, 60000.0 + i/100);
+  fclose(fp);
+
+  sprintf(query, "LOAD DATA LOCAL INFILE '%s' INTO TABLE enclist "
+                         "FIELDS TERMINATED BY '.' LINES TERMINATED BY '\r\n'", a_filename);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DELETE FROM enclist");
+  check_mysql_rc(rc, mysql);
+
+  FAIL_IF(mysql_affected_rows(mysql) != 100, "Import failure. Expected 2 imported rows");
+
+  rc= mysql_query(mysql, "DROP TABLE enclist");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+#endif
+
+static int test_connect_attrs(MYSQL *my)
+{
+  MYSQL *mysql;
+  MYSQL_RES *result;
+  int rc, len;
+
+  rc= mysql_query(my, "SELECT * FROM performance_schema.session_connect_attrs LIMIT 1");
+  if (rc != 0)
+  {
+    diag("Server doesn't support connection attributes");
+    return SKIP;
+  }
+
+  result= mysql_store_result(my);
+  /* MariaDB Connector/C already sent connection attrs after handshake. So if the table is
+     empty, it indicates that the performance schema is disabled */
+  if (!mysql_num_rows(result))
+  {
+    diag("skip: performance_schema not enabled");
+    mysql_free_result(result);
+    return SKIP;
+  }
+  mysql_free_result(result);
+
+  mysql= mysql_init(NULL);
+
+  mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "foo0", "bar0");
+  mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "foo1", "bar1");
+  mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "foo2", "bar2");
+
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(my));
+
+  if (!(mysql->server_capabilities & CLIENT_CONNECT_ATTRS))
+  {
+    diag("Server doesn't support connection attributes");
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "SELECT * FROM performance_schema.session_connect_attrs where attr_name like 'foo%'");
+  check_mysql_rc(rc, mysql);
+  result= mysql_store_result(mysql);
+  rc= (int)mysql_num_rows(result);
+  mysql_free_result(result);
+
+  mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_RESET, NULL);
+  mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "foo0", "bar0");
+  mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "foo1", "bar1");
+  mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "foo2", "bar2");
+  mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_DELETE, "foo0");
+  mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_DELETE, "foo1");
+  mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_DELETE, "foo2");
+
+  len= (int)mysql->options.extension->connect_attrs_len;
+
+  mysql_close(mysql);
+
+  FAIL_IF(rc < 3, "Expected 3 or more rows");
+  FAIL_IF(len != 0, "Expected connection_attr_len=0");
+
+  return OK;
+}
+
+static int test_conc_114(MYSQL *mysql)
+{
+  if (mysql_client_find_plugin(mysql, "foo", 0))
+  {
+    diag("Null pointer expected");
+    return FAIL;
+  }
+  diag("Error: %s", mysql_error(mysql));
+  return OK;
+}
+
+/* run with valgrind */
+static int test_conc117(MYSQL *unused __attribute__((unused)))
+{
+  my_bool reconnect= 1;
+  MYSQL *my= mysql_init(NULL);
+  SKIP_MAXSCALE;
+  FAIL_IF(!my_test_connect(my, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(my));
+  
+  mysql_kill(my, mysql_thread_id(my));
+
+  mysql_options(my, MYSQL_OPT_RECONNECT, &reconnect);
+
+  mysql_query(my, "SET @a:=1");
+  mysql_close(my);
+
+  return OK;
+}
+
+static int test_read_timeout(MYSQL *unused __attribute__((unused)))
+{
+  int timeout= 5, rc;
+  MYSQL *my= mysql_init(NULL);
+  SKIP_MAXSCALE;
+  mysql_options(my, MYSQL_OPT_READ_TIMEOUT, &timeout);
+  FAIL_IF(!my_test_connect(my, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(my));
+ 
+  rc= mysql_query(my, "SELECT SLEEP(50)");
+
+  FAIL_IF(rc == 0, "error expected");
+  diag("error: %s", mysql_error(my));
+  
+  mysql_close(my);
+
+  return OK;
+}
+
+#ifdef HAVE_REMOTEIO
+void *remote_plugin;
+static int test_remote1(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  SKIP_SKYSQL;
+
+  remote_plugin= (void *)mysql_client_find_plugin(mysql, "remote_io", MARIADB_CLIENT_REMOTEIO_PLUGIN);
+  if (!remote_plugin)
+  {
+    diag("skip - no remote io plugin available");
+    diag("error: %s", mysql_error(mysql));
+    return SKIP;
+  }
+
+  SKIP_LOAD_INFILE_DISABLE;
+
+  rc= mysql_query(mysql, "select @@LOCAL_INFILE");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+  if (atol(row[0]) == 0) {
+      diag("Load local infile disable");
+      return SKIP;
+  }
+  mysql_free_result(res);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a text)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "LOAD DATA LOCAL INFILE 'http://www.example.com' INTO TABLE t1");
+  if (rc && mysql_errno(mysql) == 2058)
+  {
+    diag("remote_io plugin not available");
+    return SKIP;
+  }
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_remote2(MYSQL *my)
+{
+  MYSQL *mysql;
+
+  if (!remote_plugin)
+  {
+    diag("skip - no remote io plugin available");
+    return SKIP;
+  }
+  mysql= mysql_init(NULL);
+
+  mysql_options(mysql, MYSQL_READ_DEFAULT_FILE, "http://localhost/test.cnf");
+  mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "test");
+  my_test_connect(mysql, hostname, username, password, schema,
+                         0, socketname, 0), mysql_error(my);
+  diag("port: %d", mysql->port);
+  mysql_close(mysql);
+  return OK;
+}
+#endif
+
+#ifndef _WIN32
+static int test_mdev12965(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+  my_bool reconnect = 0;
+  FILE *fp= NULL;
+  const char *env= getenv("MYSQL_TMP_DIR");
+  char cnf_file1[FN_REFLEN + 1];
+
+  SKIP_SKYSQL;
+  if (travis_test)
+    return SKIP;
+
+  if (!env)
+    env= "/tmp";
+
+  setenv("HOME", env, 1);
+
+  snprintf(cnf_file1, FN_REFLEN, "%s%c.my.cnf", env, FN_LIBCHAR);
+
+  diag("Config file: %s", cnf_file1);
+
+  FAIL_IF(!access(cnf_file1, R_OK), "access");
+
+  mysql= mysql_init(NULL);
+  fp= fopen(cnf_file1, "w");
+  FAIL_IF(!fp, "fopen");
+
+  fprintf(fp, "[client]\ndefault-character-set=latin2\nreconnect=1\n");
+  fclose(fp);
+
+  mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "");
+  my_test_connect(mysql, hostname, username, password,
+                  schema, 0, socketname, 0);
+
+  remove(cnf_file1);
+
+  FAIL_IF(strcmp(mysql_character_set_name(mysql), "latin2"), "expected charset latin2");
+  mysql_get_optionv(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_IF(reconnect != 1, "expected reconnect=1");
+  mysql_close(mysql);
+  return OK;
+}
+#endif
+
+static int test_get_info(MYSQL *mysql)
+{
+  size_t sval;
+  unsigned int ival;
+  char *cval;
+  int rc;
+  MY_CHARSET_INFO cs;
+  MARIADB_CHARSET_INFO *ci;
+  char **errors;
+   
+  rc= mariadb_get_infov(mysql, MARIADB_MAX_ALLOWED_PACKET, &sval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("max_allowed_packet: %lu", (unsigned long)sval);
+  rc= mariadb_get_infov(mysql, MARIADB_NET_BUFFER_LENGTH, &sval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("net_buffer_length: %lu", (unsigned long)sval);
+  rc= mariadb_get_infov(mysql, MARIADB_CLIENT_VERSION_ID, &sval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("client_version_id: %lu", (unsigned long)sval);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_VERSION_ID, &sval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("server_version_id: %lu", (unsigned long)sval);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_MARIADB_CHARSET_INFO, &cs);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("charset name: %s", cs.csname);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_PVIO_TYPE, &ival);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("connection type: %d", ival);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_PROTOCOL_VERSION_ID, &ival);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("protocol_version: %d", ival);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_TYPE, &cval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("server_type: %s", cval);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_VERSION, &cval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("server_version: %s", cval);
+  rc= mariadb_get_infov(mysql, MARIADB_CLIENT_VERSION, &cval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("client_version: %s", cval);
+  rc= mariadb_get_infov(mysql, MARIADB_CHARSET_NAME, &ci, "utf8");
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("charset_name: %s", ci->csname);
+  diag("charset_nr: %d", ci->nr);
+  rc= mariadb_get_infov(mysql, MARIADB_CHARSET_ID, &ci, 63);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("charset_name: %s", ci->csname);
+  rc= mariadb_get_infov(mysql, MARIADB_CLIENT_ERRORS, &errors);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("error[0]: %s", errors[0]);
+  rc= mysql_query(mysql, "DROP TABLE IF exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1),(2)");
+  check_mysql_rc(rc, mysql);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_INFO, &cval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("mariadb_info: %s", cval);
+  return OK;
+}
+
+static int test_zerofill(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_ROW row;
+  MYSQL_RES *res;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int(10) zerofill)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT a FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  if ((res= mysql_store_result(mysql)))
+  {
+    row= mysql_fetch_row(res);
+    diag("zerofill: %s", row[0]);
+    mysql_free_result(res);
+  }
+  return OK;
+}
+
+static int test_server_status(MYSQL *mysql)
+{
+  int rc;
+  unsigned int server_status;
+//  MYSQL_STMT *stmt;
+
+  if (mysql_get_server_version(mysql) < 100200)
+    return SKIP;
+
+//  stmt= mysql_stmt_init(mysql);
+
+  rc= mysql_autocommit(mysql, 1);
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_STATUS, &server_status);
+  FAIL_IF(!(server_status & SERVER_STATUS_AUTOCOMMIT),
+          "autocommit flag not set");
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int, b int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 (a) VALUES (1),(2),(3),(4),(5)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "UPDATE t1 SET a=9 WHERE a=8");
+  check_mysql_rc(rc, mysql);
+
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_STATUS, &server_status);
+  FAIL_IF(!(server_status & SERVER_QUERY_NO_INDEX_USED), "autocommit flag not set");
+
+  rc= mysql_query(mysql, "CREATE SCHEMA test_tmp");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_select_db(mysql, "test_tmp");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP SCHEMA test_tmp");
+  check_mysql_rc(rc, mysql);
+
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_STATUS, &server_status);
+  FAIL_IF(!(server_status & SERVER_STATUS_DB_DROPPED),
+          "DB_DROP flag not set");
+
+  FAIL_IF(!(server_status & SERVER_SESSION_STATE_CHANGED),
+          "SESSION_STATE_CHANGED flag not set");
+
+  rc= mysql_select_db(mysql, schema);
+  check_mysql_rc(rc, mysql);
+
+//  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_wl6797(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  const char *stmt_text;
+  my_ulonglong res;
+
+  if (mysql_get_server_version(mysql) < 50703 ||
+      (mariadb_connection(mysql) && mysql_get_server_version(mysql) < 100203))
+  {
+    diag("Skipping test_wl6797: "
+            "tested feature does not exist in versions before MySQL 5.7.3 and MariaDB 10.2\n");
+    return OK;
+  }
+  /* clean up the session */
+  rc= mysql_reset_connection(mysql);
+  FAIL_UNLESS(rc == 0, "");
+
+  /* do prepare of a query */
+  mysql_query(mysql, "use test");
+  mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  mysql_query(mysql, "CREATE TABLE t1 (a int)");
+
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "INSERT INTO t1 VALUES (1), (2)";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  /* Execute the insert statement */
+  rc= mysql_stmt_execute(stmt);
+  check_mysql_rc(rc, mysql);
+
+  /*
+   clean the session this should remove the prepare statement
+   from the cache.
+  */
+  rc= mysql_reset_connection(mysql);
+  FAIL_UNLESS(rc == 0, "");
+
+  /* this below stmt should report error */
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(rc == 0, "");
+
+  /*
+   bug#17653288: MYSQL_RESET_CONNECTION DOES NOT RESET LAST_INSERT_ID
+  */
+
+  mysql_query(mysql, "DROP TABLE IF EXISTS t2");
+  rc= mysql_query(mysql, "CREATE TABLE t2 (a int NOT NULL PRIMARY KEY"\
+                         " auto_increment)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t2 VALUES (null)");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 1, "");
+  rc= mysql_reset_connection(mysql);
+  FAIL_UNLESS(rc == 0, "");
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+
+  rc= mysql_query(mysql, "INSERT INTO t2 VALUES (last_insert_id(100))");
+  check_mysql_rc(rc, mysql);
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 100, "");
+  rc= mysql_reset_connection(mysql);
+  FAIL_UNLESS(rc == 0, "");
+  res= mysql_insert_id(mysql);
+  FAIL_UNLESS(res == 0, "");
+
+  mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  mysql_query(mysql, "DROP TABLE IF EXISTS t2");
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_conc384(MYSQL *my __attribute__((unused)))
+{
+  char value[1000];
+  int len;
+  MYSQL *mysql= mysql_init(NULL);
+
+  memset(&value, 'A', 999);
+  value[999]= 0;
+
+  mysql_optionsv(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "foo", value);
+  len= (int)mysql->options.extension->connect_attrs_len;
+  /* Length: 1 (=len) + 3 (="foo") + 3 (=len) + 999 (="AAA...") = 1006 */
+  FAIL_IF(len != 1006, "Wrong length");
+  mysql_optionsv(mysql, MYSQL_OPT_CONNECT_ATTR_DELETE, "foo");
+  len= (int)mysql->options.extension->connect_attrs_len;
+  /* Length should be zero after deleting the connection attribute */
+  FAIL_IF(len != 0, "Wrong length");
+  mysql_close(mysql);
+  return OK;
+}
+
+#ifndef _WIN32
+static int test_conc395(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+  FILE *fp= NULL;
+  const char *env= getenv("MYSQL_TMP_DIR");
+  char cnf_file1[FN_REFLEN + 1];
+
+  SKIP_SKYSQL;
+  if (travis_test)
+    return SKIP;
+
+  if (!env)
+    env= "/tmp";
+
+  setenv("HOME", env, 1);
+
+  snprintf(cnf_file1, FN_REFLEN, "%s%c.my.cnf", env, FN_LIBCHAR);
+
+  FAIL_IF(!access(cnf_file1, R_OK), "access");
+
+  mysql= mysql_init(NULL);
+  fp= fopen(cnf_file1, "w");
+  FAIL_IF(!fp, "fopen");
+
+  /* Mix dash and underscore */
+  fprintf(fp, "[client]\ndefault_character-set=latin2\n");
+  fclose(fp);
+
+  mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "");
+  my_test_connect(mysql, hostname, username, password,
+                  schema, 0, socketname, 0);
+
+  remove(cnf_file1);
+
+  FAIL_IF(strcmp(mysql_character_set_name(mysql), "latin2"), "expected charset latin2");
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_sslenforce(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+  FILE *fp= NULL;
+  const char *env= getenv("MYSQL_TMP_DIR");
+  char cnf_file1[FN_REFLEN + 1];
+
+  SKIP_NOTLS;
+  SKIP_SKYSQL;
+
+  if (travis_test)
+    return SKIP;
+
+  if (!env)
+    env= "/tmp";
+  setenv("HOME", env, 1);
+
+  snprintf(cnf_file1, FN_REFLEN, "%s%c.my.cnf", env, FN_LIBCHAR);
+
+  FAIL_IF(!access(cnf_file1, R_OK), "access");
+
+  mysql= mysql_init(NULL);
+  fp= fopen(cnf_file1, "w");
+  FAIL_IF(!fp, "fopen");
+
+  /* Mix dash and underscore */
+  fprintf(fp, "[client]\nssl_enforce=1\n");
+  fclose(fp);
+
+  mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "");
+  my_test_connect(mysql, hostname, username, password,
+                  schema, 0, socketname, 0);
+
+  remove(cnf_file1);
+
+  FAIL_IF(!mysql_get_ssl_cipher(mysql), "no secure connection");
+  mysql_close(mysql);
+  return OK;
+}
+#endif
+
+static int test_conc457(MYSQL *mysql)
+{
+  MYSQL_RES *result;
+
+  SKIP_MYSQL(mysql);
+
+  result= mysql_list_processes(mysql);
+
+  FAIL_IF(mysql_field_count(mysql) != 9, "expected 9 columns");
+  mysql_free_result(result);
+  return OK;
+}
+
+static int test_conc458(MYSQL *my __attribute__((unused)))
+{
+  MYSQL *mysql= mysql_init(NULL);
+  FAIL_IF(mysql_get_timeout_value(mysql) != 0, "expected timeout 0");
+  mysql_close(mysql);
+  return OK;
+}
+
+
+struct my_tests_st my_tests[] = {
+  {"test_conc458", test_conc458, TEST_CONNECTION_NONE, 0, NULL, NULL},
+  {"test_conc457", test_conc457, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc384", test_conc384, TEST_CONNECTION_NONE, 0, NULL, NULL},
+#ifndef _WIN32
+  {"test_mdev12965", test_mdev12965, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc395", test_conc395, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_sslenforce", test_sslenforce, TEST_CONNECTION_NONE, 0, NULL, NULL},
+#endif
+  {"test_wl6797", test_wl6797, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_server_status", test_server_status, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_read_timeout", test_read_timeout, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_zerofill", test_zerofill, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+#ifdef HAVE_REMOTEIO
+  {"test_remote1", test_remote1, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_remote2", test_remote2, TEST_CONNECTION_NEW, 0, NULL, NULL},
+#endif
+  {"test_get_info", test_get_info, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_conc117", test_conc117, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_conc_114", test_conc_114, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_connect_attrs", test_connect_attrs, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_conc49", test_conc49, TEST_CONNECTION_NEW, 0,  NULL, NULL},
+  {"test_bug28075", test_bug28075, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_bug28505", test_bug28505, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_debug_example", test_debug_example, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_bug29692", test_bug29692, TEST_CONNECTION_NEW, CLIENT_FOUND_ROWS,  NULL, NULL},
+  {"test_bug31418", test_bug31418, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
+  {"test_frm_bug", test_frm_bug, TEST_CONNECTION_NEW, 0,  NULL, NULL},
+  {"test_wl4166_1", test_wl4166_1, TEST_CONNECTION_NEW, 0,  NULL, NULL},
+  {"test_wl4166_2", test_wl4166_2, TEST_CONNECTION_NEW, 0,  NULL, NULL},
+  {"test_wl4166_3", test_wl4166_3, TEST_CONNECTION_NEW, 0,  NULL, NULL},
+  {"test_wl4166_4", test_wl4166_4, TEST_CONNECTION_NEW, 0,  NULL, NULL},
+  {"test_wl4284_1", test_wl4284_1, TEST_CONNECTION_NEW, 0,  NULL, NULL},
+  {"test_bug49694", test_bug49694, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_ldi_path", test_ldi_path, TEST_CONNECTION_NEW, 0, NULL, NULL},
+#ifdef _WIN32
+  {"test_conc44", test_conc44, TEST_CONNECTION_NEW, 0, NULL, NULL},
+#endif 
+  {NULL, NULL, 0, 0, NULL, 0}
+};
+
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/my_test.h b/libmariadb/unittest/libmariadb/my_test.h
new file mode 100644
index 00000000..ca9fed77
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/my_test.h
@@ -0,0 +1,712 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+#include <ma_global.h>
+#include <ma_sys.h>
+#include <mysql.h>
+#include <tap.h>
+#include "ma_getopt.h"
+#include <memory.h>
+#include <string.h>
+#include <errmsg.h>
+#include <stdlib.h>
+#include <ma_server_error.h>
+#include <mysql/client_plugin.h>
+
+#ifndef WIN32
+#include <pthread.h>
+#else
+#include <io.h>
+#endif
+
+#ifndef OK
+# define OK 0
+#endif
+#ifndef FAIL
+# define FAIL 1
+#endif
+#ifndef SKIP
+# define SKIP -1
+#endif
+#ifndef FALSE
+# define FALSE 0
+#endif
+#ifndef TRUE
+# define TRUE 1
+#endif
+
+#define IS_SKYSQL(a) ((a) && strstr((a), "db.skysql.net"))
+#define SKIP_SKYSQL \
+if (IS_SKYSQL(hostname)) \
+{ \
+  diag("Not supported by SkySQL"); \
+  return SKIP; \
+}
+
+#ifndef HAVE_SSL
+#define SKIP_NOTLS \
+{ \
+  diag("TLS not supported"); \
+  return SKIP;\
+}
+#else
+#define SKIP_NOTLS
+#endif
+
+#define IS_MAXSCALE() (getenv("srv")!=NULL && (strcmp(getenv("srv"), "maxscale") == 0 || strcmp(getenv("srv"), "skysql-ha") == 0))
+#define SKIP_MAXSCALE \
+if (IS_MAXSCALE()) \
+{ \
+  diag("test disabled with maxscale"); \
+  return SKIP; \
+}
+
+#define SKIP_LOAD_INFILE_DISABLE \
+if (!((mysql->server_capabilities & CLIENT_LOCAL_FILES) &&  \
+         (mysql->options.client_flag & CLIENT_LOCAL_FILES))) { \
+  diag("Load local infile not supported"); \
+  return SKIP; \
+}
+
+#define MAX_KEY MAX_INDEXES
+#define MAX_KEY_LENGTH_DECIMAL_WIDTH 4          /* strlen("4096") */
+
+#define SL(s) (s), (unsigned long)strlen((s))
+#define SL_BIN(s) (s), (unsigned long)sizeof((s))
+
+#define MAX_TEST_QUERY_LENGTH 300 /* MAX QUERY BUFFER LENGTH */
+
+/* prevent warnings on Win64 by using STMT_LEN instead of strlen */
+#define STMT_LEN(A) ((unsigned long)strlen((A)))
+
+#define SKIP_TRAVIS()\
+do {\
+  if (getenv("TRAVIS"))\
+  {\
+    diag("Skip test on Travis CI");\
+    return SKIP;\
+  }\
+}while(0)
+
+#define SKIP_MYSQL(mysql)\
+do {\
+  if (!mariadb_connection(mysql))\
+  {\
+    diag("Skip test for non MariaDB server");\
+    return OK;\
+  }\
+} while(0)
+
+#define check_mysql_rc(rc, mysql) \
+do {\
+  if (rc)\
+  {\
+    diag("Error (%d): %s (%d) in %s line %d", rc, mysql_error(mysql), \
+         mysql_errno(mysql), __FILE__, __LINE__);\
+    return(FAIL);\
+  }\
+} while(0)
+
+#define check_stmt_rc(rc, stmt) \
+do {\
+  if (rc)\
+  {\
+    diag("Error: %s (%s: %d)", mysql_stmt_error(stmt), __FILE__, __LINE__);\
+    return(FAIL);\
+  }\
+} while(0)
+
+#define FAIL_IF(expr, reason)\
+do {\
+  if (expr)\
+  {\
+    diag("Error: %s (%s: %d)", reason, __FILE__, __LINE__);\
+    return FAIL;\
+  }\
+} while(0)
+
+#define FAIL_UNLESS(expr, reason)\
+do {\
+  if (!(expr))\
+  {\
+    diag("Error: %s (%s: %d)", reason, __FILE__, __LINE__);\
+    return FAIL;\
+  }\
+} while(0)
+
+#define SKIP_CONNECTION_HANDLER \
+do {\
+  if (hostname && strstr(hostname, "://"))\
+  {\
+    diag("Test skipped (connection handler)");\
+    return SKIP;\
+  }\
+} while(0)
+
+/* connection options */
+#define TEST_CONNECTION_DEFAULT    1 /* default connection */
+#define TEST_CONNECTION_NONE       2 /* tests creates own connection */
+#define TEST_CONNECTION_NEW        4 /* create a separate connection */
+#define TEST_CONNECTION_DONT_CLOSE 8 /* don't close connection */
+
+struct my_option_st
+{
+  enum mysql_option option;
+  char              *value;
+};
+
+struct my_tests_st
+{
+  const char *name;
+  int  (*function)(MYSQL *);
+  int   connection;
+  ulong connect_flags;
+  struct my_option_st *options;
+  const char *skipmsg;
+};
+
+MYSQL *my_test_connect(MYSQL *mysql,
+                       const char *host,
+                       const char *user,
+                       const char *passwd,
+                       const char *db,
+                       unsigned int port,
+                       const char *unix_socket,
+                       unsigned long clientflag);
+
+static const char *schema = 0;
+static char *hostname = 0;
+static char *password = 0;
+static unsigned int port = 0;
+static unsigned int ssl_port = 0;
+static char *socketname = 0;
+static char *username = 0;
+static int force_tls= 0;
+static uchar is_mariadb= 0;
+static char *this_host= 0;
+static char *plugindir= 0;
+static unsigned char travis_test= 0;
+/*
+static struct my_option test_options[] =
+{
+  {"schema", 'd', "database to use", (uchar **) &schema, (uchar **) &schema,
+   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"help", '?', "Display this help and exit", 0, 0, 0, GET_NO_ARG, NO_ARG, 0,
+   0, 0, 0, 0, 0},
+  {"host", 'h', "Connect to host", (uchar **) &hostname, (uchar **) &hostname,
+   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"password", 'p',
+   "Password to use when connecting to server.", (uchar **) &password, (uchar **) &password,
+   0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
+  {"port", 'P', "Port number to use for connection or 0 for default to, in "
+   "order of preference, my.cnf, $MYSQL_TCP_PORT, "
+#if MYSQL_PORT_DEFAULT == 0
+   "/etc/services, "
+#endif
+   "built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",
+   (uchar **) &port,
+   (uchar **) &port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"socket", 'S', "Socket file to use for connection",
+   (uchar **) &socketname, (uchar **) &socketname, 0, GET_STR,
+   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"user", 'u', "User for login if not current user", (uchar **) &username,
+   (uchar **) &username, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
+};
+*/
+#define verify_prepare_field(result,no,name,org_name,type,table,\
+                             org_table,db,length,def) \
+          do_verify_prepare_field((result),(no),(name),(org_name),(type), \
+                                  (table),(org_table),(db),(length),(def), \
+                                  __FILE__, __LINE__)
+
+int do_verify_prepare_field(MYSQL_RES *result,
+                            unsigned int no, const char *name,
+                            const char *org_name,
+                            enum enum_field_types type __attribute__((unused)),
+                            const char *table,
+                            const char *org_table, const char *db,
+                            unsigned long length __attribute__((unused)), 
+                            const char *def __attribute__((unused)),
+                            const char *file __attribute__((unused)),
+                            int line __attribute__((unused)))
+{
+  MYSQL_FIELD *field;
+/*  MARIADB_CHARSET_INFO *cs; */
+
+  FAIL_IF(!(field= mysql_fetch_field_direct(result, no)), "FAILED to get result");
+/*  cs= mysql_find_charset_nr(field->charsetnr);
+  FAIL_UNLESS(cs, "Couldn't get character set"); */
+  FAIL_UNLESS(strcmp(field->name, name) == 0, "field->name differs");
+  FAIL_UNLESS(strcmp(field->org_name, org_name) == 0, "field->org_name differs");
+/*
+  if ((expected_field_length= length * cs->mbmaxlen) > UINT_MAX32)
+    expected_field_length= UINT_MAX32;
+*/
+  /*
+    XXX: silent column specification change works based on number of
+    bytes a column occupies. So CHAR -> VARCHAR upgrade is possible even
+    for CHAR(2) column if its character set is multibyte.
+    VARCHAR -> CHAR downgrade won't work for VARCHAR(3) as one would
+    expect.
+  */
+//  if (cs->char_maxlen == 1)
+//    FAIL_UNLESS(field->type == type, "field->type differs");
+  if (table)
+    FAIL_UNLESS(strcmp(field->table, table) == 0, "field->table differs");
+  if (org_table)
+    FAIL_UNLESS(strcmp(field->org_table, org_table) == 0, "field->org_table differs");
+  if (strcmp(field->db,db))
+    diag("%s / %s", field->db, db);
+  FAIL_UNLESS(strcmp(field->db, db) == 0, "field->db differs");
+  /*
+    Character set should be taken into account for multibyte encodings, such
+    as utf8. Field length is calculated as number of characters * maximum
+    number of bytes a character can occupy.
+  */
+
+  return OK;
+}
+
+void get_this_host(MYSQL *mysql)
+{
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+
+  if (mysql_query(mysql, "select substr(current_user(), locate('@', current_user())+1)"))
+    return;
+
+  if ((res= mysql_store_result(mysql)))
+  {
+    if ((row= mysql_fetch_row(res)))
+      this_host= strdup(row[0]);
+    mysql_free_result(res);
+  }
+}
+
+/* Prepare statement, execute, and process result set for given query */
+
+int my_stmt_result(MYSQL *mysql, const char *buff)
+{
+  MYSQL_STMT *stmt;
+  int        row_count= 0;
+  int        rc;
+
+  stmt= mysql_stmt_init(mysql);
+
+  rc= mysql_stmt_prepare(stmt, buff, (unsigned long)strlen(buff));
+  FAIL_IF(rc, mysql_stmt_error(stmt));
+
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(rc, mysql_stmt_error(stmt));
+
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    row_count++;
+
+  mysql_stmt_close(stmt);
+
+  return row_count;
+}
+/*
+static my_bool
+get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
+               char *argument)
+{
+  switch (optid) {
+  case '?':
+  case 'I':                           
+    my_print_help(test_options);
+    exit(0);
+    break;
+  }
+  return 0;
+}
+*/
+/* Utility function to verify a particular column data */
+
+int verify_col_data(MYSQL *mysql, const char *table, const char *col,
+                            const char *exp_data)
+{
+  static char query[MAX_TEST_QUERY_LENGTH];
+  MYSQL_RES *result;
+  MYSQL_ROW row;
+  int       rc;
+
+  if (table && col)
+  {
+    sprintf(query, "SELECT %s FROM %s LIMIT 1", col, table);
+    rc= mysql_query(mysql, query);
+    check_mysql_rc(rc, mysql);
+  }
+  result= mysql_use_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  if (!(row= mysql_fetch_row(result)) || !row[0]) {
+    diag("Failed to get the result");
+    goto error;
+  }
+  if(strcmp(row[0], exp_data)) {
+    diag("Expected %s, got %s", exp_data, row[0]);
+    goto error;
+  }
+  mysql_free_result(result);
+
+  return OK;
+
+error:
+  mysql_free_result(result);
+  return FAIL;
+}
+
+my_bool query_int_variable(MYSQL *con, const char *var_name, int *var_value)
+{
+  MYSQL_RES *rs;
+  MYSQL_ROW row;
+
+  char query_buffer[MAX_TEST_QUERY_LENGTH];
+
+  my_bool is_null;
+
+  sprintf(query_buffer,
+          "SELECT %s",
+          (const char *) var_name);
+
+  FAIL_IF(mysql_query(con, query_buffer), "Query failed");
+  FAIL_UNLESS(rs= mysql_store_result(con), "Invaliid result set");
+  FAIL_UNLESS(row= mysql_fetch_row(rs), "Nothing to fetch");
+
+  is_null= row[0] == NULL;
+
+  if (!is_null)
+    *var_value= atoi(row[0]);
+
+  mysql_free_result(rs);
+
+  return is_null;
+}
+
+static void usage()
+{
+  printf("Execute test with the following options:\n");
+  printf("-h hostname\n");
+  printf("-u username\n");
+  printf("-p password\n");
+  printf("-d database\n");
+  printf("-S socketname\n");
+  printf("-t force use of TLS\n");
+  printf("-P port number\n");
+  printf("?  displays this help and exits\n");
+}
+
+void get_options(int argc, char **argv)
+{
+  int c= 0;
+
+  while ((c=getopt(argc,argv, "h:u:p:d:w:P:S:t:?")) >= 0)
+  {
+    switch(c) {
+    case 'h':
+      hostname= optarg;
+      break;
+    case 'u':
+      username= optarg;
+      break;
+    case 'p':
+      password= optarg;
+      break;
+    case 'd':
+      schema= optarg;
+      break;
+    case 'P':
+      port= atoi(optarg);
+      ssl_port=port;
+      break;
+    case 'S':
+      socketname= optarg;
+      break;
+    case 't':
+      force_tls= 1;
+      break;
+    case '?':
+      usage();
+      exit(0);
+      break;
+    default:
+      usage();
+      BAIL_OUT("Unknown option %c\n", c);
+    }
+  }
+}
+
+
+int check_variable(MYSQL *mysql, const char *variable, const char *value)
+{
+  char query[MAX_TEST_QUERY_LENGTH];
+  MYSQL_RES *result;
+  MYSQL_ROW row;
+
+  sprintf(query, "SELECT %s", variable);
+  result= mysql_store_result(mysql);
+  if (!result)
+    return FAIL;
+
+  if ((row = mysql_fetch_row(result)))
+    if (strcmp(row[0], value) == 0) {
+      mysql_free_result(result);
+      return OK;
+    }
+  mysql_free_result(result);
+  return FAIL;
+}
+
+/* 
+ * function *test_connect
+ *
+ * returns a new connection. This function will be called, if the test doesn't
+ * use default_connection.
+ */
+MYSQL *test_connect(struct my_tests_st *test)
+{
+  MYSQL *mysql;
+  int i= 0, rc;
+  int timeout= 10;
+  my_bool truncation_report= 1;
+  if (!(mysql = mysql_init(NULL))) {
+    BAIL_OUT("Not enough memory available - mysql_init failed");
+  }
+  mysql_options(mysql, MYSQL_REPORT_DATA_TRUNCATION, &truncation_report);
+  mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout);
+  if (plugindir)
+    mysql_options(mysql, MYSQL_PLUGIN_DIR, plugindir);
+
+  /* option handling */
+  if (test && test->options) {
+
+    while (test->options[i].option)
+    {
+      if (mysql_options(mysql, test->options[i].option, test->options[i].value)) {
+        diag("Couldn't set option %d. Error (%d) %s", test->options[i].option,
+                      mysql_errno(mysql), mysql_error(mysql));
+        mysql_close(mysql);
+        return(NULL);
+      }
+      i++;
+    }
+  }
+  if (!(my_test_connect(mysql, hostname, username, password,
+                           schema, port, socketname, (test) ? test->connect_flags:0)))
+  {
+    diag("Couldn't establish connection to server %s. Error (%d): %s", 
+                   hostname, mysql_errno(mysql), mysql_error(mysql));
+    mysql_close(mysql);
+    return(NULL);
+  }
+
+  /* Clear sql_mode when establishing a new connection. */
+  rc= mysql_query(mysql, "SET sql_mode=''");
+  if (rc)
+  {
+    diag("Error (%d): %s (%d) in %s line %d", rc, mysql_error(mysql),
+         mysql_errno(mysql), __FILE__, __LINE__);
+    return(NULL);
+  }
+
+  return(mysql);
+}
+
+static int reset_connection(MYSQL *mysql) {
+  int rc;
+
+  if (is_mariadb && !IS_MAXSCALE())
+    rc= mysql_change_user(mysql, username, password, schema);
+  else
+    rc= mysql_reset_connection(mysql);
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "SET sql_mode=''");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/*
+ * function get_envvars((
+ *
+ * checks for connection related environment variables
+ */
+void get_envvars() {
+  char  *envvar;
+
+  if (!getenv("MYSQLTEST_VARDIR") &&
+      !getenv("MARIADB_CC_TEST"))
+  {
+    skip_all("Tests skipped.\nFor running unittest suite outside of MariaDB server tests,\nplease specify MARIADB_CC_TEST environment variable.");
+    exit(0);
+  }
+
+  if (getenv("TRAVIS_JOB_ID"))
+    travis_test= 1;
+
+  if (!hostname && (envvar= getenv("MYSQL_TEST_HOST")))
+    hostname= envvar;
+
+
+  if (!username)
+  {
+    if ((envvar= getenv("MYSQL_TEST_USER")))
+      username= envvar;
+    else
+      username= (char *)"root";
+  }
+  if (!password && (envvar= getenv("MYSQL_TEST_PASSWD")))
+    password= envvar;
+  if (!schema && (envvar= getenv("MYSQL_TEST_DB")))
+    schema= envvar;
+  if (!schema)
+    schema= "test";
+  if (!port)
+  {
+    if ((envvar= getenv("MYSQL_TEST_PORT")))
+      port= atoi(envvar);
+    else if ((envvar= getenv("MASTER_MYPORT")))
+      port= atoi(envvar);
+    diag("port: %d", port);
+  }
+  if (!ssl_port)
+  {
+    if ((envvar= getenv("MYSQL_TEST_SSL_PORT")))
+      ssl_port= atoi(envvar);
+    else
+      ssl_port = port;
+    diag("ssl_port: %d", ssl_port);
+  }
+
+  if (!force_tls && (envvar= getenv("MYSQL_TEST_TLS")))
+    force_tls= atoi(envvar);
+  if (!socketname)
+  {
+    if ((envvar= getenv("MYSQL_TEST_SOCKET")))
+      socketname= envvar;
+    else if ((envvar= getenv("MASTER_MYSOCK")))
+      socketname= envvar;
+    diag("socketname: %s", socketname);
+  }
+  if ((envvar= getenv("MYSQL_TEST_PLUGINDIR")))
+    plugindir= envvar;
+}
+
+MYSQL *my_test_connect(MYSQL *mysql,
+                       const char *host,
+                       const char *user,
+                       const char *passwd,
+                       const char *db,
+                       unsigned int port,
+                       const char *unix_socket,
+                       unsigned long clientflag)
+{
+  if (force_tls)
+    mysql_options(mysql, MYSQL_OPT_SSL_ENFORCE, &force_tls); 
+  if (!mysql_real_connect(mysql, host, user, passwd, db, port, unix_socket, clientflag))
+  {
+    diag("error: %s", mysql_error(mysql));
+    return NULL;
+  }
+
+  if (mysql && force_tls && !mysql_get_ssl_cipher(mysql))
+  {
+    diag("Error: TLS connection not established");
+    return NULL;
+  }
+  if (!this_host)
+    get_this_host(mysql);
+  return mysql;
+}
+
+
+void run_tests(struct my_tests_st *test) {
+  int i, rc, total=0;
+  MYSQL *mysql, *mysql_default= NULL;  /* default connection */
+
+  while (test[total].function)
+    total++;
+  plan(total);
+
+  if ((mysql_default= test_connect(NULL)))
+  {
+    diag("Testing against MySQL Server %s", mysql_get_server_info(mysql_default));
+    diag("Host: %s", mysql_get_host_info(mysql_default));
+    diag("Client library: %s", mysql_get_client_info());
+    is_mariadb= mariadb_connection(mysql_default);
+  }
+  else
+  {
+    BAIL_OUT("Can't connect to a server. Aborting....");
+  }
+
+  for (i=0; i < total; i++) {
+    if (!mysql_default && (test[i].connection & TEST_CONNECTION_DEFAULT))
+    {
+      diag("MySQL server not running");
+      skip(1, "%s", test[i].name);
+    } else if (!test[i].skipmsg) {
+      mysql= mysql_default;
+      if (test[i].connection & TEST_CONNECTION_NEW)
+        mysql= test_connect(&test[i]);
+      if (test[i].connection & TEST_CONNECTION_NONE)
+        mysql= NULL;
+
+      /* run test */
+      rc= test[i].function(mysql);
+
+      if (rc == SKIP)
+        skip(1, "%s", test[i].name);
+      else
+        ok(rc == OK, "%s", test[i].name);
+
+      /* if test failed, close and reopen default connection to prevent
+         errors for further tests */
+      if ((rc == FAIL || mysql_errno(mysql_default)) && (test[i].connection & TEST_CONNECTION_DEFAULT)) {
+        mysql_close(mysql_default);
+        mysql_default= test_connect(&test[i]);
+      }
+      /* clear connection: reset default connection or close extra connection */
+      else if (mysql_default && (test[i].connection & TEST_CONNECTION_DEFAULT))  {
+          if (reset_connection(mysql))
+            return; /* default doesn't work anymore */
+      }
+      else if (mysql && !(test[i].connection & TEST_CONNECTION_DONT_CLOSE))
+      {
+          mysql_close(mysql);
+      }
+    } else {
+      skip(1, "%s", test[i].skipmsg);
+    }
+  }
+  if (this_host)
+    free(this_host);
+
+  if (mysql_default) {
+    diag("close default");
+    mysql_close(mysql_default);
+  }
+}
+
diff --git a/libmariadb/unittest/libmariadb/performance.c b/libmariadb/unittest/libmariadb/performance.c
new file mode 100644
index 00000000..f99253f7
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/performance.c
@@ -0,0 +1,76 @@
+/*
+Copyright (c) 2016 MariaDB Corporation AB
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+
+/**
+  Some basic tests of the client API.
+*/
+
+#include "my_test.h"
+#include "ma_common.h"
+
+static int perf1(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  const char *stmtstr= "SELECT s.emp_no, s.salary, e.emp_no, e.first_name, e.last_name, e.gender FROM salaries s, employees e WHERE s.emp_no = e.emp_no";
+
+  rc= mysql_select_db(mysql, "employees");
+  if (rc)
+  {
+    diag("Employees database not installed");
+    return SKIP;
+  }
+
+  stmt= mysql_stmt_init(mysql);
+
+  diag("prepare");
+  rc= mysql_stmt_prepare(stmt, SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  diag("execute");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  diag("store");
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  diag("fetch");
+  while (!mysql_stmt_fetch(stmt));
+
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+struct my_tests_st my_tests[] = {
+  {"perf1", perf1, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/ps.c b/libmariadb/unittest/libmariadb/ps.c
new file mode 100644
index 00000000..da815fdb
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/ps.c
@@ -0,0 +1,5261 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+#include "my_test.h"
+
+/* Utility function to verify the field members */
+
+static int test_conc97(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+
+  diag("Please run this test manually");
+  return SKIP;
+  stmt= mysql_stmt_init(mysql);
+
+  mysql_close(mysql);
+
+  rc= mysql_stmt_reset(stmt);
+  FAIL_IF(!rc, "Error expected while resetting stmt");
+
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql= mysql_init(NULL);
+
+  return OK;
+}
+
+static int test_conc83(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  MYSQL *mysql= mysql_init(NULL);
+  my_bool reconnect= 1;
+
+  const char *query= "SELECT 1,2,3 FROM DUAL";
+
+  SKIP_MAXSCALE;
+
+  stmt= mysql_stmt_init(mysql);
+
+  mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+  FAIL_IF(!(my_test_connect(mysql, hostname, username, password,
+                           schema, port, socketname, 0)), "my_test_connect failed");
+
+  /* 1. Status is inited, so prepare should work */
+
+  rc= mysql_kill(mysql, mysql_thread_id(mysql));
+
+  rc= mysql_ping(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  diag("Ok");
+
+  /* 2. Status is prepared, execute should fail */
+  rc= mysql_kill(mysql, mysql_thread_id(mysql));
+
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(!rc, "Error expected"); 
+
+  mysql_stmt_close(stmt);
+  mysql_close(mysql);
+  return OK;
+}
+
+
+static int test_conc60(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *query= "SELECT * FROM agendas";
+  my_bool x= 1;
+
+  stmt= mysql_stmt_init(mysql);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void *)&x);
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  if (rc && mysql_stmt_errno(stmt) == 1146) {
+    diag("Internal test - customer data not available");
+    mysql_stmt_close(stmt);
+    return SKIP;
+  }
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_free_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_prepare_insert_update(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  int        i;
+  const char *testcase[]= {
+    "CREATE TABLE t1 (a INT, b INT, c INT, UNIQUE (A), UNIQUE(B))",
+    "INSERT t1 VALUES (1,2,10), (3,4,20)",
+    "INSERT t1 VALUES (5,6,30), (7,4,40), (8,9,60) ON DUPLICATE KEY UPDATE c=c+100",
+    "SELECT * FROM t1",
+    "INSERT t1 SET a=5 ON DUPLICATE KEY UPDATE b=0",
+    "SELECT * FROM t1",
+    "INSERT t1 VALUES (2,1,11), (7,4,40) ON DUPLICATE KEY UPDATE c=c+VALUES(a)",
+    NULL};
+  const char **cur_query;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  for (cur_query= testcase; *cur_query; cur_query++)
+  {
+    char query[MAX_TEST_QUERY_LENGTH];
+    strcpy(query, *cur_query);
+    stmt= mysql_stmt_init(mysql);
+    FAIL_IF(!stmt, mysql_error(mysql));
+    rc= mysql_stmt_prepare(stmt, SL(query));
+    check_stmt_rc(rc, stmt);
+
+    FAIL_IF(mysql_stmt_param_count(stmt) != 0, "Paramcount is not 0");
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    /* try the last query several times */
+    if (!cur_query[1])
+    {
+      for (i=0; i < 3;i++)
+      {
+        rc= mysql_stmt_execute(stmt);
+        check_stmt_rc(rc, stmt);
+        rc= mysql_stmt_execute(stmt);
+        check_stmt_rc(rc, stmt);
+      }
+    }
+    mysql_stmt_close(stmt);
+  }
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/*
+  Generalized conversion routine to handle DATE, TIME and DATETIME
+  conversion using MYSQL_TIME structure
+*/
+
+static int test_bind_date_conv(MYSQL *mysql, uint row_count)
+{
+  MYSQL_STMT   *stmt= 0;
+  uint         rc, i, count= row_count;
+  MYSQL_BIND   my_bind[4];
+  my_bool      is_null[4]= {0,0,0,0};
+  MYSQL_TIME   tm[4];
+  ulong        second_part;
+  uint         year, month, day, hour, minute, sec;
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO test_date VALUES(?, ?, ?, ?)"));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 4, "param_count != 4");
+
+  /*
+    We need to bzero bind structure because mysql_stmt_bind_param checks all
+    its members.
+  */
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_TIMESTAMP;
+  my_bind[1].buffer_type= MYSQL_TYPE_TIME;
+  my_bind[2].buffer_type= MYSQL_TYPE_DATETIME;
+  my_bind[3].buffer_type= MYSQL_TYPE_DATETIME;
+
+  for (i= 0; i < (int) array_elements(my_bind); i++)
+  {
+    my_bind[i].buffer= (void *) &tm[i];
+    my_bind[i].is_null= &is_null[i];
+    my_bind[i].buffer_length= sizeof(MYSQL_TIME);
+  }
+
+  second_part= 0;
+
+  year= 2000;
+  month= 01;
+  day= 10;
+
+  hour= 11;
+  minute= 16;
+  sec= 20;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  for (count= 0; count < row_count; count++)
+  {
+    for (i= 0; i < (int) array_elements(my_bind); i++)
+    {
+      memset(&tm[i],  0, sizeof(MYSQL_TIME));
+      tm[i].neg= 0;
+      tm[i].second_part= second_part+count;
+      if (my_bind[i].buffer_type != MYSQL_TYPE_TIME)
+      {
+        tm[i].year= year+count;
+        tm[i].month= month+count;
+        tm[i].day= day+count;
+      }
+      else
+        tm[i].year= tm[i].month= tm[i].day= 0;
+      if (my_bind[i].buffer_type != MYSQL_TYPE_DATE)
+      {
+        tm[i].hour= hour+count;
+        tm[i].minute= minute+count;
+        tm[i].second= sec+count;
+      }
+      else
+        tm[i].hour= tm[i].minute= tm[i].second= 0;
+    }
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  mysql_stmt_close(stmt);
+
+  rc= my_stmt_result(mysql, "SELECT * FROM test_date");
+  FAIL_UNLESS(row_count == rc, "rowcount != rc");
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT * FROM test_date"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  for (count= 0; count < row_count; count++)
+  {
+    rc= mysql_stmt_fetch(stmt);
+    FAIL_UNLESS(rc == 0 || rc == MYSQL_DATA_TRUNCATED, "rc != 0 | rc != MYSQL_DATA_TRUNCATED");
+
+    for (i= 0; i < array_elements(my_bind); i++)
+    {
+      FAIL_UNLESS(tm[i].year == 0 || tm[i].year == year+count, "wrong value for year");
+      FAIL_UNLESS(tm[i].month == 0 || tm[i].month == month+count, "wrong value for month");
+      FAIL_UNLESS(tm[i].day == 0 || tm[i].day == day+count, "wrong value for day");
+      FAIL_UNLESS(tm[i].hour == 0 || tm[i].hour % 24 == 0 || tm[i].hour % 24 == hour+count, "wrong value for hour");
+      FAIL_UNLESS(tm[i].minute == 0 || tm[i].minute == minute+count, "wrong value for minute");
+      FAIL_UNLESS(tm[i].second == 0 || tm[i].second == sec+count, "wrong value for second");
+      FAIL_UNLESS(tm[i].second_part == 0 ||
+                 tm[i].second_part == second_part+count, "wrong value for second_part");
+    }
+  }
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+
+/* Test simple prepares of all DML statements */
+
+static int test_prepare_simple(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prepare_simple");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_prepare_simple("
+                         "id int, name varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  /* insert */
+  strcpy(query, "INSERT INTO test_prepare_simple VALUES(?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Paramcount is not 2");
+  mysql_stmt_close(stmt);
+
+  /* update */
+  strcpy(query, "UPDATE test_prepare_simple SET id=? "
+                "WHERE id=? AND CONVERT(name USING utf8)= ?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 3, "Paramcount is not 3");
+  mysql_stmt_close(stmt);
+
+  /* delete */
+  strcpy(query, "DELETE FROM test_prepare_simple WHERE id=10");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 0, "Paramcount is not 0");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+
+  /* delete */
+  strcpy(query, "DELETE FROM test_prepare_simple WHERE id=?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 1, "Paramcount != 1");
+
+  mysql_stmt_close(stmt);
+
+  /* select */
+  strcpy(query, "SELECT * FROM test_prepare_simple WHERE id=? "
+                "AND CONVERT(name USING utf8)= ?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Paramcount != 2");
+
+  mysql_stmt_close(stmt);
+
+  /* now fetch the results ..*/
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prepare_simple");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_prepare_field_result(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_RES  *result;
+  int        rc;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prepare_field_result");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_prepare_field_result(int_c int, "
+                         "var_c varchar(50), ts_c timestamp, "
+                         "char_c char(4), date_c date, extra tinyint)");
+  check_mysql_rc(rc, mysql);
+
+  /* insert */
+  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_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 1, "Paramcount != 1");
+
+  result= mysql_stmt_result_metadata(stmt);
+  FAIL_IF(!result, mysql_stmt_error(stmt));
+
+  if (verify_prepare_field(result, 0, "int_c", "int_c", MYSQL_TYPE_LONG,
+                       "t1", "test_prepare_field_result", schema, 11, 0))
+    goto error;
+  if (verify_prepare_field(result, 1, "var_c", "var_c", MYSQL_TYPE_VAR_STRING,
+                       "t1", "test_prepare_field_result", schema, 50, 0))
+    goto error;
+  if (verify_prepare_field(result, 2, "date", "date_c", MYSQL_TYPE_DATE,
+                       "t1", "test_prepare_field_result", schema, 10, 0))
+    goto error;
+  if (verify_prepare_field(result, 3, "ts_c", "ts_c", MYSQL_TYPE_TIMESTAMP,
+                       "t1", "test_prepare_field_result", schema, 19, 0))
+    goto error;
+  if (verify_prepare_field(result, 4, "char_c", "char_c",
+                       (mysql_get_server_version(mysql) <= 50000 ?
+                        MYSQL_TYPE_VAR_STRING : MYSQL_TYPE_STRING),
+                       "t1", "test_prepare_field_result", schema, 4, 0))
+    goto error;
+
+  FAIL_IF(mysql_num_fields(result) != 5, "Paramcount != 5");
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prepare_field_result");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+
+error:
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+  return FAIL;
+}
+
+
+/* Test simple prepare field results */
+
+static int test_prepare_syntax(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prepare_syntax");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_prepare_syntax("
+                         "id int, name varchar(50), extra int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "FLUSH TABLES");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "START TRANSACTION");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO test_prepare_syntax VALUES(?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  FAIL_IF(!rc, "error expected");
+
+  strcpy(query, "SELECT id, name FROM test_prepare_syntax WHERE id=? AND WHERE");
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  FAIL_IF(!rc, "error expected");
+
+  /* now fetch the results ..*/
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prepare_syntax");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_prepare(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc, i;
+  int        int_data, o_int_data;
+  char       str_data[50], data[50];
+  char       tiny_data, o_tiny_data;
+  short      small_data, o_small_data;
+  longlong   big_data, o_big_data;
+  float      real_data, o_real_data;
+  double     double_data, o_double_data;
+  ulong      length[7], len;
+  my_bool    is_null[7];
+  MYSQL_BIND my_bind[7];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS my_prepare");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE my_prepare(col1 tinyint, "
+                         "col2 varchar(15), col3 int, "
+                         "col4 smallint, col5 bigint, "
+                         "col6 float, col7 double )");
+  check_mysql_rc(rc, mysql);
+
+  /* insert by prepare */
+  strcpy(query, "INSERT INTO my_prepare VALUES(?, ?, ?, ?, ?, ?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 7, "Paramcount != 7");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  /* tinyint */
+  my_bind[0].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[0].buffer= (void *)&tiny_data;
+  /* string */
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= (void *)str_data;
+  my_bind[1].buffer_length= 1000;                  /* Max string length */
+  /* integer */
+  my_bind[2].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[2].buffer= (void *)&int_data;
+  /* short */
+  my_bind[3].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[3].buffer= (void *)&small_data;
+  /* bigint */
+  my_bind[4].buffer_type= MYSQL_TYPE_LONGLONG;
+  my_bind[4].buffer= (void *)&big_data;
+  /* float */
+  my_bind[5].buffer_type= MYSQL_TYPE_FLOAT;
+  my_bind[5].buffer= (void *)&real_data;
+  /* double */
+  my_bind[6].buffer_type= MYSQL_TYPE_DOUBLE;
+  my_bind[6].buffer= (void *)&double_data;
+
+  for (i= 0; i < (int) array_elements(my_bind); i++)
+  {
+    my_bind[i].length= &length[i];
+    my_bind[i].is_null= &is_null[i];
+    is_null[i]= 0;
+  }
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  int_data= 320;
+  small_data= 1867;
+  big_data= 1000;
+  real_data= 2;
+  double_data= 6578.001;
+
+  /* now, execute the prepared statement to insert 10 records.. */
+  for (tiny_data= 0; tiny_data < 100; tiny_data++)
+  {
+    length[1]= sprintf(str_data, "MySQL%d", int_data);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    int_data += 25;
+    small_data += 10;
+    big_data += 100;
+    real_data += 1;
+    double_data += 10.09;
+  }
+
+  mysql_stmt_close(stmt);
+
+  /* now fetch the results ..*/
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* test the results now, only one row should exist */
+  rc= my_stmt_result(mysql, "SELECT * FROM my_prepare");
+  FAIL_UNLESS(rc != 1, "rowcount != 1");
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, "SELECT * FROM my_prepare", 25);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  /* get the result */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  o_int_data= 320;
+  o_small_data= 1867;
+  o_big_data= 1000;
+  o_real_data= 2;
+  o_double_data= 6578.001;
+
+  /* now, execute the prepared statement to insert 10 records.. */
+  for (o_tiny_data= 0; o_tiny_data < 100; o_tiny_data++)
+  {
+    len= sprintf(data, "MySQL%d", o_int_data);
+
+    rc= mysql_stmt_fetch(stmt);
+    check_stmt_rc(rc, stmt);
+
+    FAIL_UNLESS(tiny_data == o_tiny_data, "Wrong value for tiny_data");
+    FAIL_UNLESS(is_null[0] == 0, "Wrong value for is_null");
+    FAIL_UNLESS(length[0] == 1, "length != 0");
+
+    FAIL_UNLESS(int_data == o_int_data, "Wrong value for int_data");
+    FAIL_UNLESS(length[2] == 4, "length != 4");
+
+    FAIL_UNLESS(small_data == o_small_data, "Wrong value for small_data");
+    FAIL_UNLESS(length[3] == 2, "length != 2");
+
+    FAIL_UNLESS(big_data == o_big_data, "Wrong value for big_data");
+    FAIL_UNLESS(length[4] == 8, "length != 8");
+
+    FAIL_UNLESS(real_data == o_real_data, "Wrong value for real_data");
+    FAIL_UNLESS(length[5] == 4, "length != 4");
+
+    FAIL_UNLESS(double_data == o_double_data, "Wrong value for double_data");
+    FAIL_UNLESS(length[6] == 8, "length != 8");
+
+    FAIL_UNLESS(strcmp(data, str_data) == 0, "Wrong value for data");
+    FAIL_UNLESS(length[1] == len, "length != len");
+
+    o_int_data += 25;
+    o_small_data += 10;
+    o_big_data += 100;
+    o_real_data += 1;
+    o_double_data += 10.09;
+  }
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "MYSQL_NO_DATA expected");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS my_prepare");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_prepare_multi_statements(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  char query[MAX_TEST_QUERY_LENGTH];
+  int rc;
+
+  strcpy(query, "select 1; select 'another value'");
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  FAIL_IF(!rc, "Error expected");
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_prepare_ext(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       *sql;
+  int        nData= 1;
+  char       tData= 1;
+  short      sData= 10;
+  longlong   bData= 20;
+  int        rowcount= 0;
+  MYSQL_BIND my_bind[6];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prepare_ext");
+  check_mysql_rc(rc, mysql);
+
+  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,"
+               " 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);
+  check_mysql_rc(rc, mysql);
+
+  /* insert by prepare - all integers */
+  strcpy(query, "INSERT INTO test_prepare_ext(c1, c2, c3, c4, c5, c6) VALUES(?, ?, ?, ?, ?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 6, "Paramcount != 6");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  /*tinyint*/
+  my_bind[0].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[0].buffer= (void *)&tData;
+
+  /*smallint*/
+  my_bind[1].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[1].buffer= (void *)&sData;
+
+  /*mediumint*/
+  my_bind[2].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[2].buffer= (void *)&nData;
+
+  /*int*/
+  my_bind[3].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[3].buffer= (void *)&nData;
+
+  /*integer*/
+  my_bind[4].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[4].buffer= (void *)&nData;
+
+  /*bigint*/
+  my_bind[5].buffer_type= MYSQL_TYPE_LONGLONG;
+  my_bind[5].buffer= (void *)&bData;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  /*
+  *  integer to integer
+  */
+  for (nData= 0; nData<10; nData++, tData++, sData++, bData++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+  mysql_stmt_close(stmt);
+
+  /* now fetch the results ..*/
+
+  strcpy(query, "SELECT c1, c2, c3, c4, c5, c6 FROM test_prepare_ext");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  /* get the result */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+
+  FAIL_UNLESS(nData == rowcount, "Invalid rowcount");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prepare_ext");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_prepare_alter(MYSQL *mysql)
+{
+  MYSQL_STMT  *stmt;
+  MYSQL       *mysql_new;
+  int         rc, id;
+  MYSQL_BIND  my_bind[1];
+  my_bool     is_null;
+  char        query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prep_alter");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_prep_alter(id int, name char(20))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_prep_alter values(10, 'venu'), (20, 'mysql')");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO test_prep_alter VALUES(?, 'monty')");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 1, "Paramcount != 1");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  is_null= 0;
+  my_bind[0].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[0].buffer= (void *)&id;
+  my_bind[0].is_null= &is_null;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  id= 30;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_new= mysql_init(NULL);
+  FAIL_IF(!mysql_new, "mysql_init failed");
+  FAIL_IF(!(my_test_connect(mysql_new, hostname, username, password,
+                           schema, port, socketname, 0)), "my_test_connect failed");
+  rc= mysql_query(mysql_new, "ALTER TABLE test_prep_alter change id id_new varchar(20)");
+  diag("Error: %d %s", mysql_errno(mysql_new), mysql_error(mysql_new));
+  check_mysql_rc(rc, mysql_new);
+  mysql_close(mysql_new);
+
+  is_null= 1;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= my_stmt_result(mysql, "SELECT * FROM test_prep_alter");
+  FAIL_UNLESS(rc == 4, "rowcount != 4");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prep_alter");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_prepare_resultset(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  MYSQL_RES  *result;
+  char       query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prepare_resultset");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_prepare_resultset(id int, \
+                                name varchar(50), extra double)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  strcpy(query, "SELECT * FROM test_prepare_resultset");
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt), "Paramcount != 0");
+
+  result= mysql_stmt_result_metadata(stmt);
+  FAIL_IF(!result, "Invalid resultset");
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prepare_resultset");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Test the direct query execution in the middle of open stmts */
+
+static int test_open_direct(MYSQL *mysql)
+{
+  MYSQL_STMT  *stmt;
+  MYSQL_RES   *result;
+  int         rc;
+  char        query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_open_direct");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_open_direct(id int, name char(6))");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO test_open_direct values(10, 'mysql')");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "SELECT * FROM test_open_direct");
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "invalid resultset");
+
+  FAIL_IF(mysql_num_rows(result), "rowcount != 0");
+  mysql_free_result(result);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_affected_rows(stmt) != 1, "affected rows != 1");
+
+  rc= mysql_query(mysql, "SELECT * FROM test_open_direct");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "invalid resultset");
+
+  FAIL_IF(mysql_num_rows(result) != 1, "rowcount != 1");
+  mysql_free_result(result);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_affected_rows(stmt) != 1, "affected rows != 1");
+
+  rc= mysql_query(mysql, "SELECT * FROM test_open_direct");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid resultset");
+  FAIL_IF(mysql_num_rows(result) != 2, "rowcount != 2");
+
+  mysql_free_result(result);
+
+  mysql_stmt_close(stmt);
+
+  /* run a direct query in the middle of a fetch */
+ 
+  strcpy(query, "SELECT * FROM test_open_direct");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "INSERT INTO test_open_direct(id) VALUES(20)");
+  FAIL_IF(!rc, "Error expected");
+
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "INSERT INTO test_open_direct(id) VALUES(20)");
+  check_mysql_rc(rc, mysql);
+
+  /* run a direct query with store result */
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "drop table test_open_direct");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+
+  return OK;
+}
+
+static int test_select_show(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char query[MAX_TEST_QUERY_LENGTH];
+  int        rowcount;
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_show");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_show(id int(4) NOT NULL primary "
+                         " key, name char(2))");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "show columns from test_show");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 0, "Paramcount != 0");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rowcount= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_IF(rowcount != 2, "rowcount != 2");
+
+  mysql_stmt_close(stmt);
+
+  strcpy(query, "show tables from mysql like ?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  FAIL_IF(!rc, "Error expected");
+
+  strcpy(query, "show tables like \'test_show\'");
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rowcount= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+  mysql_stmt_close(stmt);
+
+  strcpy(query, "describe test_show");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rowcount= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_IF(rowcount != 2, "rowcount != 2");
+  mysql_stmt_close(stmt);
+
+  strcpy(query, "show keys from test_show");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rowcount= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_show");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_simple_update(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       szData[25];
+  int        nData= 1;
+  MYSQL_RES  *result;
+  MYSQL_BIND my_bind[2];
+  ulong      length[2];
+  int        rowcount= 0;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_update");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_update(col1 int, "
+                         " col2 varchar(50), col3 int )");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_update VALUES(1, 'MySQL', 100)");
+  check_mysql_rc(rc, mysql);
+
+  FAIL_IF(mysql_affected_rows(mysql) != 1, "Affected rows != 1");
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* insert by prepare */
+  strcpy(query, "UPDATE test_update SET col2= ? WHERE col1= ?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Paramcount != 2");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  nData= 1;
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= szData;                /* string data */
+  my_bind[0].buffer_length= sizeof(szData);
+  my_bind[0].length= &length[0];
+  length[0]= sprintf(szData, "updated-data");
+
+  my_bind[1].buffer= (void *) &nData;
+  my_bind[1].buffer_type= MYSQL_TYPE_LONG;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_IF(mysql_stmt_affected_rows(stmt) != 1, "Affected_rows != 1");
+
+  mysql_stmt_close(stmt);
+
+  /* now fetch the results ..*/
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* test the results now, only one row should exist */
+  rc= mysql_query(mysql, "SELECT * FROM test_update");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid resultset");
+
+  while (mysql_fetch_row(result))
+    rowcount++;
+
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_update");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+/* Test simple long data handling */
+
+static int test_long_data(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc, int_data;
+  char       *data= NullS;
+  MYSQL_RES  *result;
+  MYSQL_BIND my_bind[3];
+  int        rowcount;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_long_data");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_long_data(col1 int, "
+                         "      col2 long varchar, col3 long varbinary)");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO test_long_data(col1, col2) VALUES(?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  FAIL_IF(!rc, "Error expected");
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+
+  strcpy(query, "INSERT INTO test_long_data(col1, col2, col3) VALUES(?, ?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 3, "Paramcount != 3");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer= (void *)&int_data;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+
+  my_bind[2]= my_bind[1];
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  int_data= 999;
+  data= (char *)"Michael";
+
+  /* supply data in pieces */
+  rc= mysql_stmt_send_long_data(stmt, 1, SL(data));
+  check_stmt_rc(rc, stmt);
+  data= (char *)" 'Monty' Widenius";
+  rc= mysql_stmt_send_long_data(stmt, 1, SL(data));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_send_long_data(stmt, 2, "Venu (venu@mysql.com)", 4);
+  check_stmt_rc(rc, stmt);
+
+  /* execute */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* now fetch the results ..*/
+  rc= mysql_query(mysql, "SELECT * FROM test_long_data");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  rowcount= 0;
+  while (mysql_fetch_row(result))
+    rowcount++;
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+  mysql_free_result(result);
+
+  if (verify_col_data(mysql, "test_long_data", "col1", "999"))
+    goto error;
+  if (verify_col_data(mysql, "test_long_data", "col2", "Michael 'Monty' Widenius"))
+    goto error;
+  if (verify_col_data(mysql, "test_long_data", "col3", "Venu"))
+    goto error;
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_long_data");
+  check_mysql_rc(rc, mysql);
+  return OK;
+
+error:
+  mysql_stmt_close(stmt);
+  return FAIL;
+}
+
+
+/* Test long data (string) handling */
+
+static int test_long_data_str(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc, i, rowcount= 0;
+  char       data[255];
+  long       length;
+  ulong      length1;
+  MYSQL_RES  *result;
+  MYSQL_BIND my_bind[2];
+  my_bool    is_null[2];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_long_data_str");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_long_data_str(id int, longstr long varchar)");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO test_long_data_str VALUES(?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Paramcount != 2");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer= (void *)&length;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].is_null= &is_null[0];
+  is_null[0]= 0;
+  length= 0;
+
+  my_bind[1].buffer= data;                          /* string data */
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].length= &length1;
+  my_bind[1].is_null= &is_null[1];
+  is_null[1]= 0;
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  length= 40;
+  strcpy(data, "MySQL AB");
+
+  /* supply data in pieces */
+  for(i= 0; i < 4; i++)
+  {
+    rc= mysql_stmt_send_long_data(stmt, 1, (char *)data, 5);
+    check_stmt_rc(rc, stmt);
+  }
+  /* execute */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* now fetch the results ..*/
+  rc= mysql_query(mysql, "SELECT LENGTH(longstr), longstr FROM test_long_data_str");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  while (mysql_fetch_row(result))
+    rowcount++;
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+
+  mysql_free_result(result);
+
+  sprintf(data, "%d", i*5);
+  if (verify_col_data(mysql, "test_long_data_str", "LENGTH(longstr)", data))
+    goto error;
+  strcpy(data, "MySQLMySQLMySQLMySQL");
+  if (verify_col_data(mysql, "test_long_data_str", "longstr", data))
+    goto error;
+
+  rc= mysql_query(mysql, "DROP TABLE test_long_data_str");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+
+error:
+  rc= mysql_query(mysql, "DROP TABLE test_long_data_str");
+  check_mysql_rc(rc, mysql);
+  return FAIL; 
+}
+
+
+/* Test long data (string) handling */
+
+static int test_long_data_str1(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc, i, rowcount= 0;
+  char       data[255];
+  long       length;
+  unsigned long max_blob_length, blob_length, length1;
+  my_bool    true_value;
+  MYSQL_RES  *result;
+  MYSQL_BIND my_bind[2];
+  MYSQL_FIELD *field;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_long_data_str");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_long_data_str(longstr long varchar, blb long varbinary)");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO test_long_data_str VALUES(?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Paramcount != 2");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer= data;            /* string data */
+  my_bind[0].buffer_length= sizeof(data);
+  my_bind[0].length= (unsigned long *)&length1;
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  length1= 0;
+
+  my_bind[1]= my_bind[0];
+  my_bind[1].buffer_type= MYSQL_TYPE_BLOB;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+  length= sprintf(data, "MySQL AB");
+
+  /* supply data in pieces */
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_send_long_data(stmt, 0, data, length);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_send_long_data(stmt, 1, data, 2);
+    check_stmt_rc(rc, stmt);
+  }
+
+  /* execute */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* now fetch the results ..*/
+  rc= mysql_query(mysql, "SELECT LENGTH(longstr), longstr, LENGTH(blb), blb FROM test_long_data_str");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+
+  mysql_field_seek(result, 1);
+  field= mysql_fetch_field(result);
+  max_blob_length= field->max_length;
+
+  FAIL_IF(!result, "Invalid result set");
+
+  while (mysql_fetch_row(result))
+    rowcount++;
+
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+  mysql_free_result(result);
+
+  sprintf(data, "%ld", (long)i*length);
+  if (verify_col_data(mysql, "test_long_data_str", "length(longstr)", data))
+    return FAIL;
+
+  sprintf(data, "%d", i*2);
+  if (verify_col_data(mysql, "test_long_data_str", "length(blb)", data))
+    return FAIL;
+
+  /* Test length of field->max_length */
+  strcpy(query, "SELECT * from test_long_data_str");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 0, "Paramcount != 0");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  result= mysql_stmt_result_metadata(stmt);
+  field= mysql_fetch_fields(result);
+
+  /* First test what happens if STMT_ATTR_UPDATE_MAX_LENGTH is not used */
+  FAIL_IF(field->max_length != 0, "field->max_length != 0");
+  mysql_free_result(result);
+
+  /* Enable updating of field->max_length */
+  true_value= 1;
+  mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &true_value);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  result= mysql_stmt_result_metadata(stmt);
+  field= mysql_fetch_fields(result);
+
+  diag("max_length: %lu  max_blob_length: %lu", (unsigned long)field->max_length, (unsigned long)max_blob_length);
+  FAIL_UNLESS(field->max_length == max_blob_length, "field->max_length != max_blob_length");
+
+  /* Fetch results into a data buffer that is smaller than data */
+  memset(my_bind, '\0', sizeof(*my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_BLOB;
+  my_bind[0].buffer= (void *) &data; /* this buffer won't be altered */
+  my_bind[0].buffer_length= 16;
+  my_bind[0].length= (unsigned long *)&blob_length;
+  my_bind[0].error= &my_bind[0].error_value;
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  data[16]= 0;
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_DATA_TRUNCATED, "truncation expected");
+  FAIL_UNLESS(my_bind[0].error_value, "No error value");
+  FAIL_UNLESS(strlen(data) == 16, "Invalid string length");
+  FAIL_UNLESS(blob_length == max_blob_length, "blob_length != max_blob_length");
+
+  /* Fetch all data */
+  memset((my_bind+1), '\0', sizeof(*my_bind));
+  my_bind[1].buffer_type= MYSQL_TYPE_BLOB;
+  my_bind[1].buffer= (void *) &data; /* this buffer won't be altered */
+  my_bind[1].buffer_length= sizeof(data);
+  my_bind[1].length= (unsigned long *)&blob_length;
+  memset(data, '\0', sizeof(data));
+  mysql_stmt_fetch_column(stmt, my_bind+1, 0, 0);
+  FAIL_UNLESS(strlen(data) == max_blob_length, "strlen(data) != max_blob_length");
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+
+  /* Drop created table */
+  rc= mysql_query(mysql, "DROP TABLE test_long_data_str");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+/* Test long data (binary) handling */
+
+static int test_long_data_bin(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc, rowcount= 0;
+  char       data[255];
+  long       length;
+  MYSQL_RES  *result;
+  MYSQL_BIND my_bind[2];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_long_data_bin");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_long_data_bin(id int, longbin long varbinary)");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO test_long_data_bin VALUES(?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Paramcount != 2");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer= (void *)&length;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  length= 0;
+
+  my_bind[1].buffer= data;           /* string data */
+  my_bind[1].buffer_type= MYSQL_TYPE_LONG_BLOB;
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  length= 10;
+  strcpy(data, "MySQL AB");
+
+  /* supply data in pieces */
+  {
+    int i;
+    for (i= 0; i < 100; i++)
+    {
+      rc= mysql_stmt_send_long_data(stmt, 1, (char *)data, 4);
+      check_stmt_rc(rc, stmt);
+    }
+  }
+  /* execute */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* now fetch the results ..*/
+  rc= mysql_query(mysql, "SELECT LENGTH(longbin), longbin FROM test_long_data_bin");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  while (mysql_fetch_row(result))
+    rowcount++;
+
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+  mysql_free_result(result);
+ 
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_long_data_bin");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+
+/* Test simple delete */
+
+static int test_simple_delete(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc, rowcount= 0;
+  char       szData[30]= {0};
+  int        nData= 1;
+  MYSQL_RES  *result;
+  MYSQL_BIND my_bind[2];
+  ulong length[2];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_simple_delete");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_simple_delete(col1 int, \
+                                col2 varchar(50), col3 int )");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_simple_delete VALUES(1, 'MySQL', 100)");
+  check_mysql_rc(rc, mysql);
+
+  FAIL_IF(mysql_affected_rows(mysql) != 1, "Affected rows != 1");
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* insert by prepare */
+  strcpy(query, "DELETE FROM test_simple_delete WHERE col1= ? AND "
+                "CONVERT(col2 USING utf8)= ? AND col3= 100");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Paramcount != 2");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  nData= 1;
+  strcpy(szData, "MySQL");
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= szData;               /* string data */
+  my_bind[1].buffer_length= sizeof(szData);
+  my_bind[1].length= &length[1];
+  length[1]= 5;
+
+  my_bind[0].buffer= (void *)&nData;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_affected_rows(stmt) != 1, "Affected rows != 1");
+
+  mysql_stmt_close(stmt);
+
+  /* now fetch the results ..*/
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* test the results now, only one row should exist */
+  rc= mysql_query(mysql, "SELECT * FROM test_simple_delete");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  while (mysql_fetch_row(result))
+    rowcount++;
+
+  FAIL_IF(rowcount, "rowcount > 0");
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_simple_delete");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_update(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       szData[25];
+  int        nData= 1, rowcount= 0;
+  MYSQL_RES  *result;
+  MYSQL_BIND my_bind[2];
+  ulong length[2];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_update");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_update("
+                               "col1 int primary key auto_increment, "
+                               "col2 varchar(50), col3 int )");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO test_update(col2, col3) VALUES(?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Paramcount != 2");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  /* string data */
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= szData;
+  my_bind[0].buffer_length= sizeof(szData);
+  my_bind[0].length= &length[0];
+  length[0]= sprintf(szData, "inserted-data");
+
+  my_bind[1].buffer= (void *)&nData;
+  my_bind[1].buffer_type= MYSQL_TYPE_LONG;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  nData= 100;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_affected_rows(stmt) != 1, "Affected rows != 1");
+  mysql_stmt_close(stmt);
+
+  strcpy(query, "UPDATE test_update SET col2= ? WHERE col3= ?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Paramcount != 2");
+  nData= 100;
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= szData;
+  my_bind[0].buffer_length= sizeof(szData);
+  my_bind[0].length= &length[0];
+  length[0]= sprintf(szData, "updated-data");
+
+  my_bind[1].buffer= (void *)&nData;
+  my_bind[1].buffer_type= MYSQL_TYPE_LONG;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_IF(mysql_stmt_affected_rows(stmt) != 1, "Affected rows != 1");
+
+
+  mysql_stmt_close(stmt);
+
+  /* now fetch the results ..*/
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* test the results now, only one row should exist */
+  rc= mysql_query(mysql, "SELECT * FROM test_update");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  while (mysql_fetch_row(result))
+    rowcount++;
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_update");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+/* Test prepare without parameters */
+
+static int test_prepare_noparam(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc, rowcount= 0;
+  MYSQL_RES  *result;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS my_prepare");
+  check_mysql_rc(rc, mysql);
+
+
+  rc= mysql_query(mysql, "CREATE TABLE my_prepare(col1 int, col2 varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  /* insert by prepare */
+  strcpy(query, "INSERT INTO my_prepare VALUES(10, 'venu')");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 0, "Paramcount != 0");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  /* now fetch the results ..*/
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* test the results now, only one row should exist */
+  rc= mysql_query(mysql, "SELECT * FROM my_prepare");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  while (mysql_fetch_row(result))
+    rowcount++;
+
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS my_prepare");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+/* Test simple bind result */
+
+static int test_bind_result(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  int        nData;
+  ulong      length1;
+  char       szData[100];
+  MYSQL_BIND my_bind[2];
+  my_bool    is_null[2];
+  char       query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_result");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_bind_result(col1 int , col2 varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_bind_result VALUES(10, 'venu')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_bind_result VALUES(20, 'MySQL')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_bind_result(col2) VALUES('monty')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* fetch */
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *) &nData;      /* integer data */
+  my_bind[0].is_null= &is_null[0];
+
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= szData;                /* string data */
+  my_bind[1].buffer_length= sizeof(szData);
+  my_bind[1].length= &length1;
+  my_bind[1].is_null= &is_null[1];
+
+  strcpy(query, "SELECT * FROM test_bind_result");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(nData == 10, "nData != 10");
+  FAIL_UNLESS(strcmp(szData, "venu") == 0, "szData != 'Venu'");
+  FAIL_UNLESS(length1 == 4, "length1 != 4");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(nData == 20, "nData != 20");
+  FAIL_UNLESS(strcmp(szData, "MySQL") == 0, "szData != 'MySQL'");
+  FAIL_UNLESS(length1 == 5, "length1 != 5");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(is_null[0], "null flag not set");
+  FAIL_UNLESS(strcmp(szData, "monty") == 0, "szData != 'Monty'");
+  FAIL_UNLESS(length1 == 5, "length1 != 5");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "MYSQL_NO_DATA expected");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_result");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bind_result_ext(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc, i;
+  uchar      t_data;
+  short      s_data;
+  int        i_data;
+  longlong   b_data;
+  float      f_data;
+  double     d_data;
+  char       szData[20], bData[20];
+  ulong       szLength, bLength;
+  MYSQL_BIND my_bind[8];
+  ulong      length[8];
+  my_bool    is_null[8];
+  char       query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_result");
+  check_mysql_rc(rc, mysql);
+
+  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))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_bind_result "
+                         "VALUES (19, 2999, 3999, 4999999, "
+                         " 2345.6, 5678.89563, 'venu', 'mysql')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  for (i= 0; i < (int) array_elements(my_bind); i++)
+  {
+    my_bind[i].length=  &length[i];
+    my_bind[i].is_null= &is_null[i];
+  }
+
+  my_bind[0].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[0].buffer= (void *)&t_data;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[2].buffer_type= MYSQL_TYPE_LONG;
+
+  my_bind[3].buffer_type= MYSQL_TYPE_LONGLONG;
+  my_bind[1].buffer= (void *)&s_data;
+
+  my_bind[2].buffer= (void *)&i_data;
+  my_bind[3].buffer= (void *)&b_data;
+
+  my_bind[4].buffer_type= MYSQL_TYPE_FLOAT;
+  my_bind[4].buffer= (void *)&f_data;
+
+  my_bind[5].buffer_type= MYSQL_TYPE_DOUBLE;
+  my_bind[5].buffer= (void *)&d_data;
+
+  my_bind[6].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[6].buffer= (void *)szData;
+  my_bind[6].buffer_length= sizeof(szData);
+  my_bind[6].length= &szLength;
+
+  my_bind[7].buffer_type= MYSQL_TYPE_TINY_BLOB;
+  my_bind[7].buffer= (void *)&bData;
+  my_bind[7].length= &bLength;
+  my_bind[7].buffer_length= sizeof(bData);
+
+  strcpy(query, "select * from test_bind_result");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(t_data == 19, "tdata != 19");
+  FAIL_UNLESS(s_data == 2999, "s_data != 2999");
+  FAIL_UNLESS(i_data == 3999, "i_data != 3999");
+  FAIL_UNLESS(b_data == 4999999, "b_data != 4999999");
+  FAIL_UNLESS(strcmp(szData, "venu") == 0, "szData != 'Venu'");
+  FAIL_UNLESS(strncmp(bData, "mysql", 5) == 0, "nData != 'mysql'");
+  FAIL_UNLESS(szLength == 4, "szLength != 4");
+  FAIL_UNLESS(bLength == 5, "bLength != 5");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "MYSQL_NO_DATA expected");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_result");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+
+/* Test ext bind result */
+
+static int test_bind_result_ext1(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  uint       i;
+  int        rc;
+  char       t_data[20];
+  float      s_data;
+  short      i_data;
+  uchar      b_data;
+  int        f_data;
+  long       bData;
+  char       d_data[20];
+  double     szData;
+  MYSQL_BIND my_bind[8];
+  ulong      length[8];
+  my_bool    is_null[8];
+  char       query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_result");
+  check_mysql_rc(rc, mysql);
+
+  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))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_bind_result VALUES(120, 2999, 3999, 54, \
+                                                              2.6, 58.89, \
+                                                              '206', '6.7')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *) t_data;
+  my_bind[0].buffer_length= sizeof(t_data);
+  my_bind[0].error= &my_bind[0].error_value;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_FLOAT;
+  my_bind[1].buffer= (void *)&s_data;
+  my_bind[1].buffer_length= 0;
+  my_bind[1].error= &my_bind[1].error_value;
+
+  my_bind[2].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[2].buffer= (void *)&i_data;
+  my_bind[2].buffer_length= 0;
+  my_bind[2].error= &my_bind[2].error_value;
+
+  my_bind[3].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[3].buffer= (void *)&b_data;
+  my_bind[3].buffer_length= 0;
+  my_bind[3].error= &my_bind[3].error_value;
+
+  my_bind[4].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[4].buffer= (void *)&f_data;
+  my_bind[4].buffer_length= 0;
+  my_bind[4].error= &my_bind[4].error_value;
+
+  my_bind[5].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[5].buffer= (void *)d_data;
+  my_bind[5].buffer_length= sizeof(d_data);
+  my_bind[5].error= &my_bind[5].error_value;
+
+  my_bind[6].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[6].buffer= (void *)&bData;
+  my_bind[6].buffer_length= 0;
+  my_bind[6].error= &my_bind[6].error_value;
+
+  my_bind[7].buffer_type= MYSQL_TYPE_DOUBLE;
+  my_bind[7].buffer= (void *)&szData;
+  my_bind[7].buffer_length= 0;
+  my_bind[7].error= &my_bind[7].error_value;
+
+  for (i= 0; i < array_elements(my_bind); i++)
+  {
+    my_bind[i].is_null= &is_null[i];
+    my_bind[i].length= &length[i];
+  }
+
+  strcpy(query, "select * from test_bind_result");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(strcmp(t_data, "120") == 0, "t_data != 120");
+  FAIL_UNLESS(i_data == 3999, "i_data != 3999");
+  FAIL_UNLESS(f_data == 2, "f_data != 2");
+  FAIL_UNLESS(strcmp(d_data, "58.89") == 0, "d_data != 58.89");
+  FAIL_UNLESS(b_data == 54, "b_data != 54");
+
+  FAIL_UNLESS(length[0] == 3, "Wrong length");
+  FAIL_UNLESS(length[1] == 4, "Wrong length");
+  FAIL_UNLESS(length[2] == 2, "Wrong length");
+  FAIL_UNLESS(length[3] == 1, "Wrong length");
+  FAIL_UNLESS(length[4] == 4, "Wrong length");
+  FAIL_UNLESS(length[5] == 5, "Wrong length");
+  FAIL_UNLESS(length[6] == 4, "Wrong length");
+  FAIL_UNLESS(length[7] == 8, "Wrong length");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "MYSQL_NO_DATA expected");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_result");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_bind_negative(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  char *query;
+  int rc;
+  MYSQL_BIND      my_bind[1];
+  int32           my_val= 0;
+  ulong           my_length= 0L;
+  my_bool         my_null= FALSE;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create temporary table t1 (c1 int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1), (-1)");
+  check_mysql_rc(rc, mysql);
+
+  query= (char*)"INSERT INTO t1 VALUES (?)";
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  /* bind parameters */
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&my_val;
+  my_bind[0].length= &my_length;
+  my_bind[0].is_null= &my_null;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  my_val= -1;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_buffers(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  int        rc;
+  ulong      length;
+  my_bool    is_null;
+  char       buffer[20];
+  char       query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_buffer");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_buffer(str varchar(20))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into test_buffer values('MySQL')\
+                          , ('Database'), ('Open-Source'), ('Popular')");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "select str from test_buffer");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(buffer, '\0', sizeof(buffer));              /* Avoid overruns in printf() */
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].length= &length;
+  my_bind[0].is_null= &is_null;
+  my_bind[0].buffer_length= 1;
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)buffer;
+  my_bind[0].error= &my_bind[0].error_value;
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  buffer[1]= 'X';
+  rc= mysql_stmt_fetch(stmt);
+
+  FAIL_UNLESS(rc == MYSQL_DATA_TRUNCATED, "rc != MYSQL_DATA_TRUNCATED");
+  FAIL_UNLESS(my_bind[0].error_value, "Errorflag not set");
+  FAIL_UNLESS(buffer[0] == 'M', "buffer[0] != M");
+  FAIL_UNLESS(buffer[1] == 'X', "buffer[1] != X");
+  FAIL_UNLESS(length == 5, "length != 5");
+
+  my_bind[0].buffer_length= 8;
+  rc= mysql_stmt_bind_result(stmt, my_bind);/* re-bind */
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(strncmp(buffer, "Database", 8) == 0, "buffer != 'Database'");
+  FAIL_UNLESS(length == 8, "length != 8");
+
+  my_bind[0].buffer_length= 12;
+  rc= mysql_stmt_bind_result(stmt, my_bind);/* re-bind */
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(strcmp(buffer, "Open-Source") == 0, "buffer != 'Open-Source'");
+  FAIL_UNLESS(length == 11, "Length != 11");
+
+  my_bind[0].buffer_length= 6;
+  rc= mysql_stmt_bind_result(stmt, my_bind);/* re-bind */
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_DATA_TRUNCATED, "rc != MYSQL_DATA_TRUNCATED");
+  FAIL_UNLESS(my_bind[0].error_value, "Errorflag not set");
+  FAIL_UNLESS(strncmp(buffer, "Popula", 6) == 0, "buffer != 'Popula'");
+  FAIL_UNLESS(length == 7, "length != 7");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_buffer");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_xjoin(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  const char *query=
+    "select t.id, p1.value, n1.value, p2.value, n2.value from t3 t LEFT JOIN t1 p1 ON (p1.id=t.param1_id) LEFT JOIN t2 p2 ON (p2.id=t.param2_id) LEFT JOIN t4 n1 ON (n1.id=p1.name_id) LEFT JOIN t4 n2 ON (n2.id=p2.name_id) where t.id=1";
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2, t3, t4");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t3 (id int(8), param1_id int(8), param2_id int(8)) ENGINE=InnoDB DEFAULT CHARSET=utf8");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 ( id int(8), name_id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t2 (id int(8), name_id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8;");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t4(id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t3 values (1, 1, 1), (2, 2, null)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t1 values (1, 1, 'aaa'), (2, null, 'bbb')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t2 values (1, 2, 'ccc')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t4 values (1, 'Name1'), (2, null)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= 0;
+    while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+      rc++;
+    FAIL_UNLESS(rc == 1, "rowcount != 1");
+  }
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1, t2, t3, t4");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_union_param(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  char *query;
+  int rc, i;
+  MYSQL_BIND      my_bind[2];
+  char            my_val[4];
+  ulong           my_length= 3L;
+  my_bool         my_null= FALSE;
+
+  strcpy(my_val, "abc");
+
+  query= (char*)"select ? as my_col union distinct select ?";
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  /*
+    We need to bzero bind structure because mysql_stmt_bind_param checks all
+    its members.
+  */
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  /* bind parameters */
+  my_bind[0].buffer_type=    MYSQL_TYPE_STRING;
+  my_bind[0].buffer=         (char*) &my_val;
+  my_bind[0].buffer_length=  4;
+  my_bind[0].length=         &my_length;
+  my_bind[0].is_null=        &my_null;
+  my_bind[1].buffer_type=    MYSQL_TYPE_STRING;
+  my_bind[1].buffer=         (char*) &my_val;
+  my_bind[1].buffer_length=  4;
+  my_bind[1].length=         &my_length;
+  my_bind[1].is_null=        &my_null;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= 0;
+    while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+      rc++;
+    FAIL_UNLESS(rc == 1, "rowcount != 1");
+  }
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_union(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *query= "SELECT t1.name FROM t1 UNION "
+                     "SELECT t2.name FROM t2";
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql,
+                  "CREATE TABLE t1 "
+                  "(id INTEGER NOT NULL PRIMARY KEY, "
+                  " name VARCHAR(20) NOT NULL)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "INSERT INTO t1 (id, name) VALUES "
+                  "(2, 'Ja'), (3, 'Ede'), "
+                  "(4, 'Haag'), (5, 'Kabul'), "
+                  "(6, 'Almere'), (7, 'Utrecht'), "
+                  "(8, 'Qandahar'), (9, 'Amsterdam'), "
+                  "(10, 'Amersfoort'), (11, 'Constantine')");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "CREATE TABLE t2 "
+                  "(id INTEGER NOT NULL PRIMARY KEY, "
+                  " name VARCHAR(20) NOT NULL)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "INSERT INTO t2 (id, name) VALUES "
+                  "(4, 'Guam'), (5, 'Aruba'), "
+                  "(6, 'Angola'), (7, 'Albania'), "
+                  "(8, 'Anguilla'), (9, 'Argentina'), "
+                  "(10, 'Azerbaijan'), (11, 'Afghanistan'), "
+                  "(12, 'Burkina Faso'), (13, 'Faroe Islands')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+  FAIL_UNLESS(rc == 20, "rc != 20");
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_union2(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  const char *query= "select col1 FROM t1 where col1=1 union distinct "
+                     "select col1 FROM t1 where col1=2";
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1(col1 INT, \
+                                         col2 VARCHAR(40),      \
+                                         col3 SMALLINT, \
+                                         col4 TIMESTAMP)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= 0;
+    while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+      rc++;
+    FAIL_UNLESS(rc == 0, "rowcount != 0");
+  }
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Misc tests to keep pure coverage happy */
+
+static int test_pure_coverage(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  int        rc;
+  ulong      length;
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_pure");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_pure(c1 int, c2 varchar(20))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "FLUSH TABLES");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "START TRANSACTION");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("insert into test_pure(c67788) values(10)"));
+  FAIL_IF(!rc, "Error expected");
+  mysql_stmt_close(stmt);
+
+  /* Query without params and result should allow one to bind 0 arrays */
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("insert into test_pure(c2) values(10)"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, (MYSQL_BIND*)0);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_bind_result(stmt, (MYSQL_BIND*)0);
+  FAIL_UNLESS(rc == 1, "");
+
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("insert into test_pure(c2) values(?)"));
+  check_stmt_rc(rc, stmt);
+
+  /*
+    We need to bzero bind structure because mysql_stmt_bind_param checks all
+    its members.
+  */
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].length= &length;
+  my_bind[0].is_null= 0;
+  my_bind[0].buffer_length= 0;
+
+  my_bind[0].buffer_type= MYSQL_TYPE_GEOMETRY;
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  FAIL_IF(!rc, "Error expected");
+
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("select * from test_pure"));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+
+  mysql_query(mysql, "DROP TABLE test_pure");
+  return OK;
+}
+
+static int test_insert_select(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt_insert, *stmt_select;
+  char *query;
+  int rc;
+  uint i;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t2 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t2 values (1)");
+  check_mysql_rc(rc, mysql);
+
+  query= (char*)"insert into t1 select a from t2";
+  stmt_insert= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_insert, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_insert, SL(query));
+  check_stmt_rc(rc, stmt_insert);
+
+  query= (char*)"select * from t1";
+  stmt_select= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_select, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_select, SL(query));
+  check_stmt_rc(rc, stmt_select);
+
+  for(i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt_insert);
+    check_stmt_rc(rc, stmt_insert);
+
+    rc= mysql_stmt_execute(stmt_select);
+    check_stmt_rc(rc, stmt_select);
+    rc= 0;
+    while (mysql_stmt_fetch(stmt_select) != MYSQL_NO_DATA)
+      rc++;
+    FAIL_UNLESS(rc == (int)(i+1), "rc != i+1");
+  }
+
+  mysql_stmt_close(stmt_insert);
+  mysql_stmt_close(stmt_select);
+  rc= mysql_query(mysql, "drop table t1, t2");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test simple prepare-insert */
+
+static int test_insert(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       str_data[50];
+  char       tiny_data;
+  MYSQL_RES  *result;
+  MYSQL_BIND my_bind[2];
+  ulong      length;
+
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prep_insert");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_prep_insert(col1 tinyint, \
+                                col2 varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  /* insert by prepare */
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO test_prep_insert VALUES(?, ?)"));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Param_count != 2");
+
+  /*
+    We need to bzero bind structure because mysql_stmt_bind_param checks all
+    its members.
+  */
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  /* tinyint */
+  my_bind[0].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[0].buffer= (void *)&tiny_data;
+
+  /* string */
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= str_data;
+  my_bind[1].buffer_length= sizeof(str_data);;
+  my_bind[1].length= &length;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  /* now, execute the prepared statement to insert 10 records.. */
+  for (tiny_data= 0; tiny_data < 3; tiny_data++)
+  {
+    length= sprintf(str_data, "MySQL%d", tiny_data);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+
+  mysql_stmt_close(stmt);
+
+  /* now fetch the results ..*/
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* test the results now, only one row should exist */
+  rc= mysql_query(mysql, "SELECT * FROM test_prep_insert");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS((int) tiny_data == rc, "rowcount != tinydata");
+  mysql_free_result(result);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_prep_insert");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_join(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i, j;
+  const char *query[]= {"SELECT * FROM t2 join t1 on (t1.a=t2.a)",
+                        "SELECT * FROM t2 natural join t1",
+                        "SELECT * FROM t2 join t1 using(a)",
+                        "SELECT * FROM t2 left join t1 on(t1.a=t2.a)",
+                        "SELECT * FROM t2 natural left join t1",
+                        "SELECT * FROM t2 left join t1 using(a)",
+                        "SELECT * FROM t2 right join t1 on(t1.a=t2.a)",
+                        "SELECT * FROM t2 natural right join t1",
+                        "SELECT * FROM t2 right join t1 using(a)"};
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int , b int);");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql,
+                  "insert into t1 values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5);");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t2 (a int , c int);");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql,
+                  "insert into t2 values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5);");
+  check_mysql_rc(rc, mysql);
+
+  for (j= 0; j < 9; j++)
+  {
+    stmt= mysql_stmt_init(mysql);
+    FAIL_IF(!stmt, mysql_error(mysql));
+    rc= mysql_stmt_prepare(stmt, SL(query[j]));
+    check_stmt_rc(rc, stmt);
+    for (i= 0; i < 3; i++)
+    {
+      rc= mysql_stmt_execute(stmt);
+      check_stmt_rc(rc, stmt);
+      rc= 0;
+      while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+        rc++;
+      FAIL_UNLESS(rc == 5, "rowcount != 5");
+    }
+    mysql_stmt_close(stmt);
+  }
+
+  rc= mysql_query(mysql, "DROP TABLE t1, t2");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_left_join_view(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  const char *query=
+    "select t1.a, v1.x from t1 left join v1 on (t1.a= v1.x);";
+
+
+  rc = mysql_query(mysql, "DROP TABLE IF EXISTS t1,v1");
+  check_mysql_rc(rc, mysql);
+
+  rc = mysql_query(mysql, "DROP VIEW IF EXISTS v1,t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"insert into t1 values (1), (2), (3)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"create view v1 (x) as select a from t1 where a > 1");
+  check_mysql_rc(rc, mysql);
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= 0;
+     while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+       rc++;
+     FAIL_UNLESS(rc == 3, "rowcount != 3");
+  }
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP VIEW v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test simple sample - manual */
+
+static int test_manual_sample(MYSQL *mysql)
+{
+  unsigned int param_count;
+  MYSQL_STMT   *stmt;
+  short        small_data;
+  int          int_data;
+  int          rc;
+  char         str_data[50];
+  ulonglong    affected_rows;
+  MYSQL_BIND   my_bind[3];
+  my_bool      is_null;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+
+  /*
+    Sample which is incorporated directly in the manual under Prepared
+    statements section (Example from mysql_stmt_execute()
+  */
+
+  memset(str_data, 0, sizeof(str_data));
+  mysql_autocommit(mysql, 1);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_table");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE test_table(col1 int, col2 varchar(50), \
+                                                 col3 smallint, \
+                                                 col4 timestamp)");
+  check_mysql_rc(rc, mysql);
+
+  /* Prepare a insert query with 3 parameters */
+  strcpy(query, "INSERT INTO test_table(col1, col2, col3) values(?, ?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  /* Get the parameter count from the statement */
+  param_count= mysql_stmt_param_count(stmt);
+  FAIL_IF(param_count != 3, "param_count != 3");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  /* INTEGER PART */
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&int_data;
+
+  /* STRING PART */
+  my_bind[1].buffer_type= MYSQL_TYPE_VAR_STRING;
+  my_bind[1].buffer= (void *)str_data;
+  my_bind[1].buffer_length= sizeof(str_data);
+
+  /* SMALLINT PART */
+  my_bind[2].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[2].buffer= (void *)&small_data;
+  my_bind[2].is_null= &is_null;
+  is_null= 0;
+
+  /* Bind the buffers */
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  /* Specify the data */
+  int_data= 10;             /* integer */
+  strcpy(str_data, "MySQL"); /* string  */
+
+  /* INSERT SMALLINT data as NULL */
+  is_null= 1;
+
+  /* Execute the insert statement - 1*/
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /* Get the total rows affected */
+  affected_rows= mysql_stmt_affected_rows(stmt);
+  FAIL_IF(affected_rows != 1, "affected-rows != 1");
+
+  /* Re-execute the insert, by changing the values */
+  int_data= 1000;
+  strcpy(str_data, "The most popular open source database");
+  small_data= 1000;         /* smallint */
+  is_null= 0;               /* reset */
+
+  /* Execute the insert statement - 2*/
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /* Get the total rows affected */
+  affected_rows= mysql_stmt_affected_rows(stmt);
+
+  FAIL_IF(affected_rows != 1, "affected_rows != 1");
+
+  /* Close the statement */
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /* DROP THE TABLE */
+  rc= mysql_query(mysql, "DROP TABLE test_table");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_create_drop(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt_create, *stmt_drop, *stmt_select, *stmt_create_select;
+  char *query;
+  int rc, i;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t2 (a int);");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 (a int);");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t2 values (3), (2), (1);");
+  check_mysql_rc(rc, mysql);
+
+  query= (char*)"create table t1 (a int)";
+  stmt_create= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_create, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_create, SL(query));
+  check_stmt_rc(rc, stmt_create);
+
+  query= (char*)"drop table t1";
+  stmt_drop= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_drop, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_drop, SL(query));
+  check_stmt_rc(rc, stmt_drop);
+
+  query= (char*)"select a in (select a from t2) from t1";
+  stmt_select= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_select, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_select, SL(query));
+  check_stmt_rc(rc, stmt_select);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  query= (char*)"create table t1 select a from t2";
+  stmt_create_select= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_create_select, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_create_select, SL(query));
+  check_stmt_rc(rc, stmt_create_select);
+
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt_create);
+    check_stmt_rc(rc, stmt_create);
+
+    rc= mysql_stmt_execute(stmt_select);
+    check_stmt_rc(rc, stmt_select);
+
+    rc= 0;
+    while (mysql_stmt_fetch(stmt_select) != MYSQL_NO_DATA)
+      rc++;
+    FAIL_UNLESS(rc == 0, "rowcount != 0");
+
+    rc= mysql_stmt_execute(stmt_drop);
+    check_stmt_rc(rc, stmt_drop);
+
+    rc= mysql_stmt_execute(stmt_create_select);
+    check_stmt_rc(rc, stmt_create);
+
+    rc= mysql_stmt_execute(stmt_select);
+    check_stmt_rc(rc, stmt_select);
+    rc= 0;
+    while (mysql_stmt_fetch(stmt_select) != MYSQL_NO_DATA)
+      rc++;
+    FAIL_UNLESS(rc == 3, "rowcount != 3");
+
+    rc= mysql_stmt_execute(stmt_drop);
+    check_stmt_rc(rc, stmt_drop);
+  }
+
+  mysql_stmt_close(stmt_create);
+  mysql_stmt_close(stmt_drop);
+  mysql_stmt_close(stmt_select);
+  mysql_stmt_close(stmt_create_select);
+
+  rc= mysql_query(mysql, "DROP TABLE t2");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test DATE, TIME, DATETIME and TS with MYSQL_TIME conversion */
+
+static int test_date(MYSQL *mysql)
+{
+  int        rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_date");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_date(c1 TIMESTAMP, \
+                                                 c2 TIME, \
+                                                 c3 DATETIME, \
+                                                 c4 DATE)");
+
+  check_mysql_rc(rc, mysql);
+
+  rc= test_bind_date_conv(mysql, 5);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_date");
+  return rc;
+}
+
+
+/* Test all time types to DATE and DATE to all types */
+
+static int test_date_date(MYSQL *mysql)
+{
+  int        rc;
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_date");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_date(c1 DATE, \
+                                                 c2 DATE, \
+                                                 c3 DATE, \
+                                                 c4 DATE)");
+
+  check_mysql_rc(rc, mysql);
+
+  rc= test_bind_date_conv(mysql, 3);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_date");
+  return rc;
+}
+
+/* Test all time types to TIMESTAMP and TIMESTAMP to all types */
+
+static int test_date_ts(MYSQL *mysql)
+{
+  int        rc;
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_date");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_date(c1 TIMESTAMP, \
+                                                 c2 TIMESTAMP, \
+                                                 c3 TIMESTAMP, \
+                                                 c4 TIMESTAMP)");
+
+  check_mysql_rc(rc, mysql);
+
+  rc= test_bind_date_conv(mysql, 2);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_date");
+  return rc;
+}
+
+
+/* Test all time types to DATETIME and DATETIME to all types */
+
+static int test_date_dt(MYSQL *mysql)
+{
+  int rc;
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_date");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_date(c1 datetime, "
+                         " c2 datetime, c3 datetime, c4 date)");
+  check_mysql_rc(rc, mysql);
+
+  rc= test_bind_date_conv(mysql, 2);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_date");
+  return rc;
+}
+
+/* Test all time types to TIME and TIME to all types */
+
+static int test_date_time(MYSQL *mysql)
+{
+  int        rc;
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_date");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_date(c1 TIME, \
+                                                 c2 TIME, \
+                                                 c3 TIME, \
+                                                 c4 TIME)");
+
+  check_mysql_rc(rc, mysql);
+
+  rc= test_bind_date_conv(mysql, 3);
+  mysql_query(mysql, "DROP TABLE IF EXISTS test_date");
+  return rc;
+}
+
+/*
+  Test of basic checks that are performed in server for components
+  of MYSQL_TIME parameters.
+*/
+
+static int test_datetime_ranges(MYSQL *mysql)
+{
+  const char *stmt_text;
+  int rc, i;
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[6];
+  MYSQL_TIME tm[6];
+
+  if (!is_mariadb)
+    return SKIP;
+
+  stmt_text= "drop table if exists t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "create table t1 (year datetime, month datetime, day datetime, "
+                              "hour datetime, min datetime, sec datetime)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  stmt_text= "INSERT INTO t1 VALUES (?, ?, ?, ?, ?, ?)";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  FAIL_IF(mysql_stmt_param_count(stmt) != 6, "param_count != 6");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  for (i= 0; i < 6; i++)
+  {
+    my_bind[i].buffer_type= MYSQL_TYPE_DATETIME;
+    my_bind[i].buffer= &tm[i];
+  }
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  tm[0].year= 2004; tm[0].month= 11; tm[0].day= 10;
+  tm[0].hour= 12; tm[0].minute= 30; tm[0].second= 30;
+  tm[0].second_part= 0; tm[0].neg= 0;
+
+  tm[5]= tm[4]= tm[3]= tm[2]= tm[1]= tm[0];
+  tm[0].year= 10000;  tm[1].month= 13; tm[2].day= 32;
+  tm[3].hour= 24; tm[4].minute= 60; tm[5].second= 60;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(!mysql_warning_count(mysql), "warnings expected");
+
+  if (verify_col_data(mysql, "t1", "year", "0000-00-00 00:00:00"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "month", "0000-00-00 00:00:00"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "day", "0000-00-00 00:00:00"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "hour", "0000-00-00 00:00:00"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "min", "0000-00-00 00:00:00"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "sec", "0000-00-00 00:00:00"))
+    goto error;
+
+  mysql_stmt_close(stmt);
+
+  stmt_text= "delete from t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "INSERT INTO t1 (year, month, day) VALUES (?, ?, ?)";
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  /*
+    We reuse contents of bind and tm arrays left from previous part of test.
+  */
+  for (i= 0; i < 3; i++)
+    my_bind[i].buffer_type= MYSQL_TYPE_DATE;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_IF(!mysql_warning_count(mysql), "warnings expected");
+
+  if (verify_col_data(mysql, "t1", "year", "0000-00-00 00:00:00"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "month", "0000-00-00 00:00:00"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "day", "0000-00-00 00:00:00"))
+    goto error;
+
+  mysql_stmt_close(stmt);
+
+  stmt_text= "drop table t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "create table t1 (day_ovfl time, day time, hour time, min time, sec time)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  stmt_text= "INSERT INTO t1 VALUES (?,?,?,?,?)";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  FAIL_IF(mysql_stmt_param_count(stmt) != 5, "param_count != 5");
+
+  /*
+    Again we reuse what we can from previous part of test.
+  */
+  for (i= 0; i < 5; i++)
+    my_bind[i].buffer_type= MYSQL_TYPE_TIME;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  tm[0].year= 0; tm[0].month= 0; tm[0].day= 10;
+  tm[0].hour= 12; tm[0].minute= 30; tm[0].second= 30;
+  tm[0].second_part= 0; tm[0].neg= 0;
+
+  tm[4]= tm[3]= tm[2]= tm[1]= tm[0];
+  tm[0].day= 35; tm[1].day= 34; tm[2].hour= 30; tm[3].minute= 60; tm[4].second= 60;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_IF(mysql_warning_count(mysql) != 2, "warning_count != 2");
+
+  if (verify_col_data(mysql, "t1", "day_ovfl", "838:59:59"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "day", "828:30:30"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "hour", "270:30:30"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "min", "00:00:00"))
+    goto error;
+  if (verify_col_data(mysql, "t1", "sec", "00:00:00"))
+    goto error;
+
+  mysql_stmt_close(stmt);
+  stmt_text= "drop table t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  return OK;
+error:
+  mysql_stmt_close(stmt);
+  stmt_text= "drop table t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_derived(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  MYSQL_BIND      my_bind[1];
+  int32           my_val= 0;
+  ulong           my_length= 0L;
+  my_bool         my_null= FALSE;
+  const char *query=
+    "select count(1) from (select f.id from t1 f where f.id=?) as x";
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 (id  int(8), primary key (id)) \
+ENGINE=InnoDB DEFAULT CHARSET=utf8");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t1 values (1)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&my_val;
+  my_bind[0].length= &my_length;
+  my_bind[0].is_null= &my_null;
+  my_val= 1;
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= 0;
+    while (!mysql_stmt_fetch(stmt))
+      rc++;
+    FAIL_UNLESS(rc == 1, "rowcount != 1");
+  }
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_distinct(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  const char *query=
+    "SELECT 2+count(distinct b), group_concat(a) FROM t1 group by a";
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int , b int);");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql,
+                  "insert into t1 values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), \
+(1, 10), (2, 20), (3, 30), (4, 40), (5, 50);");
+  check_mysql_rc(rc, mysql);
+
+  for (i= 0; i < 3; i++)
+  {
+    stmt= mysql_stmt_init(mysql);
+    FAIL_IF(!stmt, mysql_error(mysql));
+    rc= mysql_stmt_prepare(stmt, SL(query));
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    rc= 0;
+    while (!mysql_stmt_fetch(stmt))
+      rc++;
+    FAIL_UNLESS(rc == 5, "rowcount != 5");
+    mysql_stmt_close(stmt);
+  }
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_do_set(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt_do, *stmt_set;
+  char *query;
+  int rc, i;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  query= (char*)"do @var:=(1 in (select * from t1))";
+  stmt_do= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_do, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_do, SL(query));
+  check_stmt_rc(rc, stmt_do);
+
+  query= (char*)"set @var=(1 in (select * from t1))";
+  stmt_set= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_set, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_set, SL(query));
+  check_stmt_rc(rc, stmt_set);
+
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt_do);
+    check_stmt_rc(rc, stmt_do);
+    rc= mysql_stmt_execute(stmt_set);
+    check_stmt_rc(rc, stmt_set);
+  }
+
+  mysql_stmt_close(stmt_do);
+  mysql_stmt_close(stmt_set);
+  return OK;
+}
+
+static int test_double_compare(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       real_data[10], tiny_data;
+  double     double_data;
+  MYSQL_RES  *result;
+  MYSQL_BIND my_bind[3];
+  ulong      length[3];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_double_compare");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_double_compare(col1 tinyint, "
+                         " col2 float, col3 double )");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_double_compare "
+                         "VALUES (1, 10.2, 34.5)");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "UPDATE test_double_compare SET col1=100 "
+                "WHERE col1 = ? AND col2 = ? AND COL3 = ?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 3, "param_count != 3");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  /* tinyint */
+  my_bind[0].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[0].buffer= (void *)&tiny_data;
+
+  /* string->float */
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= (void *)&real_data;
+  my_bind[1].buffer_length= sizeof(real_data);
+  my_bind[1].length= &length[1];
+
+  /* double */
+  my_bind[2].buffer_type= MYSQL_TYPE_DOUBLE;
+  my_bind[2].buffer= (void *)&double_data;
+
+  tiny_data= 1;
+  strcpy(real_data, "10.2");
+  length[1]= (ulong)strlen(real_data);
+  double_data= 34.5;
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_affected_rows(stmt), "affected_rows != 0");
+
+  mysql_stmt_close(stmt);
+
+  /* now fetch the results ..*/
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* test the results now, only one row should exist */
+  rc= mysql_query(mysql, "SELECT * FROM test_double_compare");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS((int)tiny_data == rc, "rowcount != tinydata");
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_double_compare");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_multi(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt_delete, *stmt_update, *stmt_select1, *stmt_select2;
+  char *query;
+  MYSQL_BIND my_bind[1];
+  int rc, i;
+  int32 param= 1;
+  ulong length= 1;
+
+  /*
+    We need to bzero bind structure because mysql_stmt_bind_param checks all
+    its members.
+  */
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&param;
+  my_bind[0].length= &length;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 (a int, b int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t2 (a int, b int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t1 values (3, 3), (2, 2), (1, 1)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t2 values (3, 3), (2, 2), (1, 1)");
+  check_mysql_rc(rc, mysql);
+
+  query= (char*)"delete t1, t2 from t1, t2 where t1.a=t2.a and t1.b=10";
+  stmt_delete= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_delete, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_delete, SL(query));
+  check_stmt_rc(rc, stmt_delete);
+
+  query= (char*)"update t1, t2 set t1.b=10, t2.b=10 where t1.a=t2.a and t1.b=?";
+  stmt_update= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_update, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_update, SL(query));
+  check_stmt_rc(rc, stmt_update);
+
+  query= (char*)"select * from t1";
+  stmt_select1= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_select1, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_select1, SL(query));
+  check_stmt_rc(rc, stmt_select1);
+
+  query= (char*)"select * from t2";
+  stmt_select2= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_select2, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_select2, SL(query));
+  check_stmt_rc(rc, stmt_select2);
+
+  for(i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_bind_param(stmt_update, my_bind);
+    check_stmt_rc(rc, stmt_update);
+
+    rc= mysql_stmt_execute(stmt_update);
+    check_stmt_rc(rc, stmt_update);
+
+    rc= mysql_stmt_execute(stmt_delete);
+    check_stmt_rc(rc, stmt_delete);
+
+    rc= mysql_stmt_execute(stmt_select1);
+    check_stmt_rc(rc, stmt_select1);
+    rc= 0;
+    while (!mysql_stmt_fetch(stmt_select1))
+      rc++;
+    FAIL_UNLESS(rc == 3-param, "rc != 3 - param");
+
+    rc= mysql_stmt_execute(stmt_select2);
+    check_stmt_rc(rc, stmt_select2);
+    rc= 0;
+    while (!mysql_stmt_fetch(stmt_select2))
+      rc++;
+    FAIL_UNLESS(rc == 3-param, "rc != 3 - param");
+
+    param++;
+  }
+
+  mysql_stmt_close(stmt_delete);
+  mysql_stmt_close(stmt_update);
+  mysql_stmt_close(stmt_select1);
+  mysql_stmt_close(stmt_select2);
+  rc= mysql_query(mysql, "drop table t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Multiple stmts .. */
+
+static int test_multi_stmt(MYSQL *mysql)
+{
+
+  MYSQL_STMT  *stmt, *stmt1, *stmt2;
+  int         rc;
+  uint32      id;
+  char        name[50];
+  MYSQL_BIND  my_bind[2];
+  ulong       length[2];
+  my_bool     is_null[2];
+  const char *query;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_multi_table");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_multi_table(id int, name char(20))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_multi_table values(10, 'mysql')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  query= "SELECT * FROM test_multi_table WHERE id=?";
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  stmt2= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt2, mysql_error(mysql));
+  query= "UPDATE test_multi_table SET name='updated' WHERE id=10";
+  rc= mysql_stmt_prepare(stmt2, SL(query));
+  check_stmt_rc(rc, stmt2);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 1, "param_count != 1");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&id;
+  my_bind[0].is_null= &is_null[0];
+  my_bind[0].length= &length[0];
+  is_null[0]= 0;
+  length[0]= 0;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= (void *)name;
+  my_bind[1].buffer_length= sizeof(name);
+  my_bind[1].length= &length[1];
+  my_bind[1].is_null= &is_null[1];
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  id= 10;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  id= 999;
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(id == 10, "id != 10");
+  FAIL_UNLESS(strcmp(name, "mysql") == 0, "name != 'mysql'");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "");
+
+  /* alter the table schema now */
+  stmt1= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt1, mysql_error(mysql));
+  query= "DELETE FROM test_multi_table WHERE id=? AND CONVERT(name USING utf8)=?";
+  rc= mysql_stmt_prepare(stmt1, SL(query));
+  check_stmt_rc(rc, stmt1);
+
+  FAIL_IF(mysql_stmt_param_count(stmt1) != 2, "param_count != 2");
+
+  rc= mysql_stmt_bind_param(stmt1, my_bind);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_execute(stmt2);
+  check_stmt_rc(rc, stmt2);
+
+  FAIL_IF(mysql_stmt_affected_rows(stmt2) != 1, "affected_rows != 1");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(id == 10, "id != 10");
+  FAIL_UNLESS(strcmp(name, "updated") == 0, "name != 'updated'");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  rc= mysql_stmt_execute(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  FAIL_IF(mysql_stmt_affected_rows(stmt1) != 1, "affected_rows != 1");
+
+  mysql_stmt_close(stmt1);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  rc= my_stmt_result(mysql, "SELECT * FROM test_multi_table");
+  FAIL_UNLESS(rc == 0, "rc != 0");
+
+  mysql_stmt_close(stmt);
+  mysql_stmt_close(stmt2);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_multi_table");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Test 'n' statements create and close */
+
+static int test_nstmts(MYSQL *mysql)
+{
+  MYSQL_STMT  *stmt;
+  char        query[255];
+  int         rc;
+  static uint i, total_stmts= 2000;
+  MYSQL_BIND  my_bind[1];
+
+  SKIP_SKYSQL;
+
+  mysql_autocommit(mysql, TRUE);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_nstmts");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_nstmts(id int)");
+  check_mysql_rc(rc, mysql);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer= (void *)&i;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+
+  for (i= 0; i < total_stmts; i++)
+  {
+    strcpy(query, "insert into test_nstmts values(?)");
+    stmt= mysql_stmt_init(mysql);
+    FAIL_IF(!stmt, mysql_error(mysql));
+    rc= mysql_stmt_prepare(stmt, SL(query));
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_bind_param(stmt, my_bind);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    mysql_stmt_close(stmt);
+  }
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(" select count(*) from test_nstmts"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  i= 0;
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS( i == total_stmts, "total_stmts != i");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE test_nstmts");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test simple null */
+
+static int test_null(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  uint       nData;
+  MYSQL_BIND my_bind[2];
+  my_bool    is_null[2];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_null");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_null(col1 int, col2 varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "FLUSH TABLES");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "START TRANSACTION");
+  check_mysql_rc(rc, mysql);
+
+  /* insert by prepare, wrong column name */
+  strcpy(query, "INSERT INTO test_null(col3, col2) VALUES(?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  FAIL_IF(!rc, "Error expected");
+  mysql_stmt_close(stmt);
+
+  strcpy(query, "INSERT INTO test_null(col1, col2) VALUES(?, ?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "param_count != 2");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].is_null= &is_null[0];
+  is_null[0]= 1;
+  my_bind[1]= my_bind[0];
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  /* now, execute the prepared statement to insert 10 records.. */
+  for (nData= 0; nData<10; nData++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+
+  /* Re-bind with MYSQL_TYPE_NULL */
+  my_bind[0].buffer_type= MYSQL_TYPE_NULL;
+  is_null[0]= 0; /* reset */
+  my_bind[1]= my_bind[0];
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  for (nData= 0; nData<10; nData++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+
+  mysql_stmt_close(stmt);
+
+  /* now fetch the results ..*/
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  nData*= 2;
+  rc= my_stmt_result(mysql, "SELECT * FROM test_null");;
+  FAIL_UNLESS((int) nData == rc, "rc != ndata");
+
+  /* Fetch results */
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&nData; /* this buffer won't be altered */
+  my_bind[0].length= 0;
+  my_bind[1]= my_bind[0];
+  my_bind[0].is_null= &is_null[0];
+  my_bind[1].is_null= &is_null[1];
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT * FROM test_null"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  is_null[0]= is_null[1]= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+  {
+    FAIL_UNLESS(is_null[0], "!is_null");
+    FAIL_UNLESS(is_null[1], "!is_null");
+    rc++;
+    is_null[0]= is_null[1]= 0;
+  }
+  FAIL_UNLESS(rc == (int) nData, "rc != nData");
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_null");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_order_param(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *query;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1(a INT, b char(10))");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  query= "select sum(a) + 200, 1 from t1 "
+         " union distinct "
+         "select sum(a) + 200, 1 from t1 group by b ";
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  query= "select sum(a) + 200, ? from t1 group by b "
+         " union distinct "
+         "select sum(a) + 200, 1 from t1 group by b ";
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  query= "select sum(a) + 200, ? from t1 "
+         " union distinct "
+         "select sum(a) + 200, 1 from t1 group by b ";
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_rename(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  const char *query= "rename table t1 to t2, t3 to t4";
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2, t3, t4");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "create table t1 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(!rc, "Error expected");
+
+  rc= mysql_query(mysql, "create table t3 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(!rc, "Errr expected");
+
+  rc= mysql_query(mysql, "rename table t2 to t1, t4 to t3");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t2, t4");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_rewind(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind;
+  int rc = 0;
+  const char *stmt_text;
+  long unsigned int length=4, Data=0;
+  my_bool isnull=0;
+
+
+  stmt_text= "CREATE TABLE t1 (a int)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "INSERT INTO t1 VALUES(2),(3),(4)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "SELECT * FROM t1";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  memset(&my_bind, '\0', sizeof(MYSQL_BIND));
+  my_bind.buffer_type= MYSQL_TYPE_LONG;
+  my_bind.buffer= (void *)&Data; /* this buffer won't be altered */
+  my_bind.length= &length;
+  my_bind.is_null= &isnull;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, &my_bind);
+  check_stmt_rc(rc, stmt);
+
+  /* retrieve all result sets till we are at the end */
+  while(!(rc=mysql_stmt_fetch(stmt)));
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  /* seek to the first row */
+  mysql_stmt_data_seek(stmt, 0);
+
+  /* now we should be able to fetch the results again */
+  /* but mysql_stmt_fetch returns MYSQL_NO_DATA */
+  while(!(rc= mysql_stmt_fetch(stmt)));
+  
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  stmt_text= "DROP TABLE t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  rc= mysql_stmt_free_result(stmt);
+  rc= mysql_stmt_close(stmt);
+  return OK;
+}
+
+/* Test simple select */
+
+static int test_select(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       szData[25];
+  int        nData= 1;
+  MYSQL_BIND my_bind[2];
+  ulong length[2];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_select");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_select(id int, name varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  /* insert a row and commit the transaction */
+  rc= mysql_query(mysql, "INSERT INTO test_select VALUES(10, 'venu')");
+  check_mysql_rc(rc, mysql);
+
+  /* now insert the second row, and roll back the transaction */
+  rc= mysql_query(mysql, "INSERT INTO test_select VALUES(20, 'mysql')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "SELECT * FROM test_select WHERE id= ? "
+                "AND CONVERT(name USING utf8) =?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "param_count != 2");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  /* string data */
+  nData= 10;
+  strcpy(szData, (char *)"venu");
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= (void *)szData;
+  my_bind[1].buffer_length= 4;
+  my_bind[1].length= &length[1];
+  length[1]= 4;
+
+  my_bind[0].buffer= (void *)&nData;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (!mysql_stmt_fetch(stmt))
+    rc++;
+  FAIL_UNLESS(rc == 1, "rc != 1");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_select");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test simple select with prepare */
+
+static int test_select_prepare(MYSQL *mysql)
+{
+  int        rc;
+  MYSQL_STMT *stmt;
+
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_select");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_select(id int, name varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  /* insert a row and commit the transaction */
+  rc= mysql_query(mysql, "INSERT INTO test_select VALUES(10, 'venu')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT * FROM test_select"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (!mysql_stmt_fetch(stmt))
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE test_select");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_select(id tinyint, id1 int, "
+                                                "  id2 float, id3 float, "
+                                                "  name varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  /* 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')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT * FROM test_select"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (!mysql_stmt_fetch(stmt))
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_select");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test simple show */
+
+static int test_select_show_table(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc, i;
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SHOW TABLES FROM mysql"));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt), "param_count != 0");
+
+  for (i= 1; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+
+  while (!mysql_stmt_fetch(stmt));
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+/* Test simple select */
+
+static int test_select_version(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT @@version"));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt), "param_count != 0");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  while (!mysql_stmt_fetch(stmt));
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_selecttmp(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  const char *query= "select a, (select count(distinct t1.b) as sum from t1, t2 where t1.a=t2.a and t2.b > 0 and t1.a <= t3.b group by t1.a order by sum limit 1) from t3";
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2, t3");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int , b int);");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t2 (a int, b int);");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t3 (a int, b int);");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql,
+                  "insert into t1 values (0, 100), (1, 2), (1, 3), (2, 2), (2, 7), \
+(2, -1), (3, 10);");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "insert into t2 values (0, 0), (1, 1), (2, 1), (3, 1), (4, 1);");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "insert into t3 values (3, 3), (2, 2), (1, 1);");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= 0;
+    while (!mysql_stmt_fetch(stmt))
+      rc++;
+    FAIL_UNLESS(rc == 3, "rowcount != 3");
+  }
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1, t2, t3");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_set_option(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_RES  *result;
+  int        rc;
+
+
+  mysql_autocommit(mysql, TRUE);
+
+  /* LIMIT the rows count to 2 */
+  rc= mysql_query(mysql, "SET SQL_SELECT_LIMIT= 2");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_limit");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_limit(a tinyint)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_limit VALUES(10), (20), (30), (40)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT * FROM test_limit");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS(rc == 2, "rowcunt != 2");
+  mysql_free_result(result);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT * FROM test_limit"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (!mysql_stmt_fetch(stmt))
+    rc++;
+  FAIL_UNLESS(rc == 2, "");
+
+  mysql_stmt_close(stmt);
+
+  /* RESET the LIMIT the rows count to 0 */
+  rc= mysql_query(mysql, "SET SQL_SELECT_LIMIT=DEFAULT");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT * FROM test_limit"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (!mysql_stmt_fetch(stmt))
+    rc++;
+  FAIL_UNLESS(rc == 4, "rowcount != 4");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_limit");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test simple set-variable prepare */
+
+static int test_set_variable(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt, *stmt1;
+  int        rc;
+  int        set_count, def_count, get_count;
+  ulong      length;
+  char       var[NAME_LEN+1];
+  MYSQL_BIND set_bind[1], get_bind[2];
+
+
+  mysql_autocommit(mysql, TRUE);
+
+  stmt1= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt1, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt1, SL("show variables like 'max_error_count'"));
+  check_stmt_rc(rc, stmt1);
+
+  memset(get_bind, '\0', sizeof(get_bind));
+
+  get_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  get_bind[0].buffer= (void *)var;
+  get_bind[0].length= &length;
+  get_bind[0].buffer_length= (int)NAME_LEN;
+  length= NAME_LEN;
+
+  get_bind[1].buffer_type= MYSQL_TYPE_LONG;
+  get_bind[1].buffer= (void *)&get_count;
+
+  rc= mysql_stmt_execute(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_bind_result(stmt1, get_bind);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_fetch(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  def_count= get_count;
+
+  FAIL_UNLESS(strcmp(var, "max_error_count") == 0, "var != max_error_count");
+  rc= mysql_stmt_fetch(stmt1);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("set max_error_count=?"));
+  check_stmt_rc(rc, stmt);
+
+  memset(set_bind, '\0', sizeof(set_bind));
+
+  set_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  set_bind[0].buffer= (void *)&set_count;
+
+  rc= mysql_stmt_bind_param(stmt, set_bind);
+  check_stmt_rc(rc, stmt);
+
+  set_count= 31;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_commit(mysql);
+
+  rc= mysql_stmt_execute(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_fetch(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  FAIL_UNLESS(get_count == set_count, "get_count != set_count");
+
+  rc= mysql_stmt_fetch(stmt1);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  /* restore back to default */
+  set_count= def_count;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  rc= mysql_stmt_fetch(stmt1);
+  check_stmt_rc(rc, stmt1);
+
+  FAIL_UNLESS(get_count == set_count, "get_count != set_count");
+
+  rc= mysql_stmt_fetch(stmt1);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  mysql_stmt_close(stmt1);
+  return OK;
+}
+
+/* Test SQLmode */
+
+static int test_sqlmode(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[2];
+  char       c1[5], c2[5];
+  int        rc;
+  int        ignore_space= 0;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_piping");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_piping(name varchar(10))");
+  check_mysql_rc(rc, mysql);
+
+  /* PIPES_AS_CONCAT */
+  strcpy(query, "SET SQL_MODE= \"PIPES_AS_CONCAT\"");
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO test_piping VALUES(?||?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)c1;
+  my_bind[0].buffer_length= 2;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= (void *)c2;
+  my_bind[1].buffer_length= 3;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  strcpy(c1, "My"); strcpy(c2, "SQL");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+
+  if (verify_col_data(mysql, "test_piping", "name", "MySQL"))
+    return FAIL;
+
+  rc= mysql_query(mysql, "DELETE FROM test_piping");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "SELECT connection_id    ()");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+
+  /* ANSI */
+  strcpy(query, "SET SQL_MODE= \"ANSI\"");
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO test_piping VALUES(?||?)");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  strcpy(c1, "My"); strcpy(c2, "SQL");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+  if (verify_col_data(mysql, "test_piping", "name", "MySQL"))
+    return FAIL;
+
+  /* ANSI mode spaces ... 
+    skip, if ignore_space was set
+  */
+  query_int_variable(mysql, "@@sql_mode LIKE '%IGNORE_SPACE%'", &ignore_space);
+
+  if (!ignore_space)
+  {
+    strcpy(query, "SELECT connection_id ()");
+    stmt= mysql_stmt_init(mysql);
+    FAIL_IF(!stmt, mysql_error(mysql));
+    rc= mysql_stmt_prepare(stmt, SL(query));
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_fetch(stmt);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_fetch(stmt);
+    FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+    mysql_stmt_close(stmt);
+  }
+  /* IGNORE SPACE MODE */
+  strcpy(query, "SET SQL_MODE= \"IGNORE_SPACE\"");
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "SELECT connection_id    ()");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_piping");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test mysql_stmt_close for open stmts */
+
+static int test_stmt_close(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt1, *stmt2, *stmt3, *stmt_x;
+  MYSQL_BIND  my_bind[1];
+  MYSQL_RES   *result;
+  unsigned int  count;
+  int   rc;
+  char query[MAX_TEST_QUERY_LENGTH];
+  my_bool reconnect= 1;
+
+  mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+
+  /* set AUTOCOMMIT to ON*/
+  mysql_autocommit(mysql, TRUE);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_stmt_close");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_stmt_close(id int)");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "DO \"nothing\"");
+  stmt1= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt1, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt1, SL(query));
+  check_stmt_rc(rc, stmt1);
+
+  FAIL_IF(mysql_stmt_param_count(stmt1), "param_count != 0");
+
+  strcpy(query, "INSERT INTO test_stmt_close(id) VALUES(?)");
+  stmt_x= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt_x, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt_x, SL(query));
+  check_stmt_rc(rc, stmt_x);
+
+  FAIL_IF(mysql_stmt_param_count(stmt_x) != 1, "param_count != 1");
+
+  strcpy(query, "UPDATE test_stmt_close SET id= ? WHERE id= ?");
+  stmt3= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt3, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt3, SL(query));
+  check_stmt_rc(rc, stmt3);
+
+  FAIL_IF(mysql_stmt_param_count(stmt3) != 2, "param_count != 2");
+
+  strcpy(query, "SELECT * FROM test_stmt_close WHERE id= ?");
+  stmt2= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt2, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt2, SL(query));
+  check_stmt_rc(rc, stmt2);
+
+  FAIL_IF(mysql_stmt_param_count(stmt2) != 1, "param_count != 1");
+
+  rc= mysql_stmt_close(stmt1);
+
+  /*
+    Originally we were going to close all statements automatically in
+    mysql_close(). This proved to not work well - users weren't able to
+    close statements by hand once mysql_close() had been called.
+    Now mysql_close() doesn't free any statements, so this test doesn't
+    serve its original designation any more.
+    Here we free stmt2 and stmt3 by hand to avoid memory leaks.
+  */
+  mysql_stmt_close(stmt2);
+  mysql_stmt_close(stmt3);
+
+  /*
+    We need to bzero bind structure because mysql_stmt_bind_param checks all
+    its members.
+  */
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer= (void *)&count;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  count= 100;
+
+  rc= mysql_stmt_bind_param(stmt_x, my_bind);
+  check_stmt_rc(rc, stmt_x);
+
+  rc= mysql_stmt_execute(stmt_x);
+  check_stmt_rc(rc, stmt_x);
+
+  FAIL_IF(mysql_stmt_affected_rows(stmt_x) != 1, "affected_rows != 1");
+
+  rc= mysql_stmt_close(stmt_x);
+  check_stmt_rc(rc, stmt_x);
+
+  rc= mysql_query(mysql, "SELECT id FROM test_stmt_close");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS(rc == 1, "rwcount != 1");
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_stmt_close");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_new_date(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind[1];
+  int rc;
+  char buffer[50];
+  my_bool reconnect= 1;
+  mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+
+  /* set AUTOCOMMIT to ON*/
+  mysql_autocommit(mysql, TRUE);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a date, b date)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (now(), now() + INTERVAL 1 day)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, "SELECT if(1, a, b) FROM t1", 26);
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, sizeof(MYSQL_BIND));
+  bind[0].buffer_length= 50;
+  bind[0].buffer= (void *)buffer;
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(rc != MYSQL_NO_DATA, "NO DATA expected");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_long_data1(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  MYSQL_BIND bind[1];
+  char query[MAX_TEST_QUERY_LENGTH];
+  const char *data= "12345";
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS tld");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE tld (col1 int, "
+                         "col2 long varbinary)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO tld VALUES (1,'test')");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "UPDATE tld SET col2=? WHERE col1=1");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  memset(bind, 0, sizeof(MYSQL_BIND));
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_send_long_data(stmt, 0, data, 6);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS tld");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+int test_blob_9000(MYSQL *mysql)
+{
+  MYSQL_BIND bind[1];
+  MYSQL_STMT *stmt;
+  int rc;
+  char buffer[9200];
+  const char *query= "INSERT INTO tb9000 VALUES (?)";
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS tb9000");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE tb9000 (a blob)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+
+  memset(bind, 0, sizeof(MYSQL_BIND));
+  memset(buffer, 'C', 9200);
+  bind[0].buffer= buffer;
+  bind[0].buffer_length= 9200;
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS tb9000");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+int test_fracseconds(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *str= "SELECT NOW(6)";
+  char buffer[60], buffer1[60];
+  MYSQL_BIND bind[2];
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(str));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(&bind, 0, sizeof(MYSQL_BIND));
+  bind[0].buffer= buffer;
+  bind[0].buffer_length=60;
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(strlen(buffer) != 26, "Expected timestamp with length of 26");
+
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a timestamp(6), b time(6))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES ('2012-04-25 10:20:49.0194','10:20:49.0194' )");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, "SELECT a,b FROM t1", 18);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, 2 * sizeof(MYSQL_BIND));
+  bind[0].buffer= buffer;
+  bind[1].buffer= buffer1;
+  bind[0].buffer_length=  bind[1].buffer_length= 60;
+  bind[0].buffer_type= bind[1].buffer_type= MYSQL_TYPE_STRING;
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_IF(strcmp(buffer, "2012-04-25 10:20:49.019400") != 0, "Wrong result");
+  FAIL_IF(strcmp(buffer1, "10:20:49.019400") != 0, "Wrong result");
+
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+
+  return OK;  
+}
+
+int test_notrunc(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  my_bool trunc= 1;
+  MYSQL_BIND bind[2];
+  char buffer[5], buffer2[5];
+  int rc;
+  my_bool error= 0;
+  unsigned long len= 1;
+
+  const char *query= "SELECT '1234567890', 'foo' FROM DUAL";
+
+  mysql_options(mysql, MYSQL_REPORT_DATA_TRUNCATION, &trunc);
+
+  stmt= mysql_stmt_init(mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt); 
+  check_stmt_rc(rc, stmt);
+
+  strcpy(buffer, "bar");
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 2);
+  bind[0].buffer_type= MYSQL_TYPE_NULL;
+  bind[0].buffer= buffer;
+  bind[0].buffer_length= 1;
+  bind[0].length= &len;
+  bind[0].flags|= MADB_BIND_DUMMY;
+  bind[0].error= &error;
+  bind[1].buffer_type= MYSQL_TYPE_STRING;
+  bind[1].buffer= buffer2;
+  bind[1].buffer_length= 5;
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_store_result(stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  mysql_stmt_close(stmt);
+
+  FAIL_IF(rc!= 0, "expected rc= 0");
+  FAIL_IF(strcmp(buffer, "bar"), "Bind dummy failed");
+  FAIL_IF(strcmp(buffer2, "foo"), "Invalid second buffer");
+
+  return OK;
+}
+
+static int test_bit2tiny(MYSQL *mysql)
+{
+  MYSQL_BIND bind[2];
+  char       data[11];
+  unsigned   long length[2];
+  my_bool    is_null[2], error[2];
+  const char *query = "SELECT val FROM justbit";
+  MYSQL_STMT *stmt;
+  int rc;
+
+  mysql_query(mysql, "DROP TABLE IF EXISTS justbit");
+  mysql_query(mysql, "CREATE TABLE justbit(val bit(1) not null)");
+  mysql_query(mysql, "INSERT INTO justbit values (1)");
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, '\0', sizeof(bind));
+
+  bind[0].buffer_type=  MYSQL_TYPE_TINY;
+  bind[0].buffer=       &data[0];
+  bind[0].buffer_length= 1;
+  bind[0].is_null=      &is_null[0];
+  bind[0].length=       &length[0];
+  bind[0].error=        &error[0];
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_fetch(stmt);
+
+  FAIL_IF(data[0] != 1, "Value should be 1");
+
+  mysql_stmt_free_result(stmt);
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS justbit");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_reexecute(MYSQL *mysql)
+{
+    MYSQL_STMT *stmt;
+  MYSQL_BIND ps_params[3];  /* input parameter buffers */
+  int        int_data[3];   /* input/output values */
+  int        rc;
+
+  if (!mariadb_connection(mysql))
+    return SKIP;
+
+  /* set up stored procedure */
+  rc = mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+
+  rc = mysql_query(mysql,
+      "CREATE PROCEDURE p1("
+      "  IN p_in INT, "
+      "  OUT p_out INT, "
+      "  INOUT p_inout INT) "
+      "BEGIN "
+      "  SELECT p_in, p_out, p_inout; "
+      "  SET p_in = 100, p_out = 200, p_inout = 300; "
+      "  SELECT p_in, p_out, p_inout; "
+      "END");
+  check_mysql_rc(rc, mysql);
+
+  /* initialize and prepare CALL statement with parameter placeholders */
+  stmt = mysql_stmt_init(mysql);
+  if (!stmt)
+  {
+    diag("Could not initialize statement");
+    exit(1);
+  }
+  rc = mysql_stmt_prepare(stmt, "CALL p1(?, ?, ?)", 16);
+  check_stmt_rc(rc, stmt);
+
+  /* initialize parameters: p_in, p_out, p_inout (all INT) */
+  memset(ps_params, 0, sizeof (ps_params));
+
+  ps_params[0].buffer_type = MYSQL_TYPE_LONG;
+  ps_params[0].buffer = (char *) &int_data[0];
+  ps_params[0].length = 0;
+  ps_params[0].is_null = 0;
+
+  ps_params[1].buffer_type = MYSQL_TYPE_LONG;
+  ps_params[1].buffer = (char *) &int_data[1];
+  ps_params[1].length = 0;
+  ps_params[1].is_null = 0;
+
+  ps_params[2].buffer_type = MYSQL_TYPE_LONG;
+  ps_params[2].buffer = (char *) &int_data[2];
+  ps_params[2].length = 0;
+  ps_params[2].is_null = 0;
+
+  /* bind parameters */
+  rc = mysql_stmt_bind_param(stmt, ps_params);
+  check_stmt_rc(rc, stmt);
+
+  /* assign values to parameters and execute statement */
+  int_data[0]= 10;  /* p_in */
+  int_data[1]= 20;  /* p_out */
+  int_data[2]= 30;  /* p_inout */
+
+  rc = mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc = mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_prepare_error(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+
+  rc= mysql_stmt_prepare(stmt, SL("SELECT 1 FROM tbl_not_exists"));
+  FAIL_IF(!rc, "Expected error");
+
+  rc= mysql_stmt_reset(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_prepare(stmt, SL("SELECT 1 FROM tbl_not_exists"));
+  FAIL_IF(!rc, "Expected error");
+
+  rc= mysql_stmt_reset(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_prepare(stmt, SL("SET @a:=1"));
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_conc349(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+  enum mysql_stmt_state state;
+
+  rc= mysql_stmt_attr_get(stmt, STMT_ATTR_STATE, &state);
+  FAIL_IF(state != MYSQL_STMT_INITTED, "expected status MYSQL_STMT_INITTED");
+
+  rc= mysql_stmt_prepare(stmt, SL("SET @a:=1"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_attr_get(stmt, STMT_ATTR_STATE, &state);
+  FAIL_IF(state != MYSQL_STMT_PREPARED, "expected status MYSQL_STMT_PREPARED");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_attr_get(stmt, STMT_ATTR_STATE, &state);
+  FAIL_IF(state != MYSQL_STMT_EXECUTED, "expected status MYSQL_STMT_EXECUTED");
+
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_conc565(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_FIELD *fields_binary, *fields_text;
+  MYSQL_RES *result;
+  int rc;
+  unsigned int i;
+  my_bool x=1;
+  my_bool error= 0;
+
+  rc= mysql_query(mysql, "CREATE TEMPORARY TABLE t1 (a year, b tinyint unsigned, c smallint unsigned, d mediumint unsigned, e int unsigned, f bigint unsigned)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (2020, 127, 0xFFFF, 0xFFFFFF, 0xFFFFFFFF, 0xFFFFFFFFFFFFFFFF)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, "select a,b,c,d,e,f from t1", -1);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void *)&x);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_store_result(stmt);
+  fields_binary= mariadb_stmt_fetch_fields(stmt);
+
+  rc= mysql_query(mysql, "SELECT a,b,c,d,e,f FROM t1");
+  result= mysql_store_result(mysql);
+  fields_text= mysql_fetch_fields(result);
+
+  for (i=0; i < mysql_field_count(mysql); i++)
+  {
+     if (fields_binary[i].length != fields_text[i].length ||
+         fields_binary[i].max_length != fields_text[i].max_length)
+     {
+       diag("Sizes differ for column %d (type= %d)", i, fields_binary[i].type);
+       diag("Binary (length=%ld max_length=%ld) != Text(length=%ld max_length=%ld",
+             fields_binary[i].length, fields_binary[i].max_length,
+             fields_text[i].length, fields_text[i].max_length);
+       error= 1;
+       goto end; 
+     }
+  }
+end:
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+
+  return error ? FAIL : OK;
+}
+
+struct my_tests_st my_tests[] = {
+  {"test_conc565", test_conc565, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc349", test_conc349, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_prepare_error", test_prepare_error, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_reexecute", test_reexecute, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_bit2tiny", test_bit2tiny, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_conc97", test_conc97, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_conc83", test_conc83, TEST_CONNECTION_NONE, 0, NULL, NULL},
+  {"test_conc60", test_conc60, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_notrunc", test_notrunc, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_fracseconds", test_fracseconds, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_blob_9000", test_blob_9000, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_long_data1", test_long_data1, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_prepare_insert_update", test_prepare_insert_update, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_prepare_simple", test_prepare_simple, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_prepare_syntax", test_prepare_syntax, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_prepare_field_result", test_prepare_field_result, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_prepare", test_prepare, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_prepare_ext", test_prepare_ext, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_prepare_multi_statements", test_prepare_multi_statements, TEST_CONNECTION_NEW, 0, NULL , NULL},
+  {"test_prepare_alter", test_prepare_alter, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_prepare_resultset", test_prepare_resultset, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_open_direct", test_open_direct, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_select_show", test_select_show, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_select", test_select, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_long_data", test_long_data, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_long_data_str", test_long_data_str, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_long_data_str1", test_long_data_str1, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_long_data_bin", test_long_data_bin, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_simple_update", test_simple_update, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_simple_delete", test_simple_delete, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_update", test_update, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_prepare_noparam", test_prepare_noparam, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bind_result", test_bind_result, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bind_result_ext", test_bind_result_ext, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bind_result_ext1", test_bind_result_ext1, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bind_negative", test_bind_negative, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_buffers", test_buffers, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_xjoin", test_xjoin, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_union", test_union, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_union2", test_union2, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_union_param", test_union_param, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_pure_coverage", test_pure_coverage, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_insert_select", test_insert_select, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_insert", test_insert, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_join", test_join, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_left_join_view", test_left_join_view, TEST_CONNECTION_DEFAULT, 0, NULL , NULL}, 
+  {"test_manual_sample", test_manual_sample, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_create_drop", test_create_drop, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_date", test_date, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_date_ts", test_date_ts, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_date_dt", test_date_dt, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_date_date", test_date_date, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_date_time", test_date_time, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_datetime_ranges", test_datetime_ranges, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_derived", test_derived, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_distinct", test_distinct, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_do_set", test_do_set, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_double_compare", test_double_compare, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_multi", test_multi, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_multi_stmt", test_multi_stmt, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_nstmts", test_nstmts, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_null", test_null, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_order_param", test_order_param, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_rename", test_rename, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_rewind", test_rewind, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_select_prepare", test_select_prepare, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_select_show_table", test_select_show_table, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_select_version", test_select_version, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_selecttmp", test_selecttmp, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_set_option", test_set_option, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_set_variable", test_set_variable, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_sqlmode", test_sqlmode, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_stmt_close", test_stmt_close, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_new_date", test_new_date, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/ps_bugs.c b/libmariadb/unittest/libmariadb/ps_bugs.c
new file mode 100644
index 00000000..07a4bac0
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/ps_bugs.c
@@ -0,0 +1,5418 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+#include "my_test.h"
+
+#define MY_INT64_NUM_DECIMAL_DIGITS 21
+#define MAX_INDEXES 64
+
+/* A workaround for Sun Forte 5.6 on Solaris x86 */
+
+static int cmp_double(double *a, double *b)
+{
+  return *a == *b;
+  return OK;
+}
+
+/* Test BUG#1115 (incorrect string parameter value allocation) */
+
+static int test_conc67(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  const char *query= "SELECT a,b FROM conc67 WHERE a=?";
+  int rc, i;
+  MYSQL_BIND bind[2];
+  char val[20];
+  MYSQL_BIND rbind;
+  MYSQL_RES *res;
+  ulong prefetch_rows= 1000;
+  ulong cursor_type= CURSOR_TYPE_READ_ONLY;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc67");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE conc67 (a int, b text)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO conc67 VALUES (1, 'foo')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, &cursor_type);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_PREFETCH_ROWS, &prefetch_rows);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  memset(&rbind, 0, sizeof(MYSQL_BIND));
+  i= 1;
+  rbind.buffer_type= MYSQL_TYPE_LONG;
+  rbind.buffer= &i;
+  rbind.buffer_length= 4;
+  mysql_stmt_bind_param(stmt, &rbind);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  res= mysql_stmt_result_metadata(stmt);
+  mysql_free_result(res);
+
+  memset(bind, 0, 2 * sizeof(MYSQL_BIND));
+
+  i= 0;
+  bind[0].buffer_type= MYSQL_TYPE_LONG;
+  bind[0].buffer= &i;
+  bind[0].buffer_length= 4;
+  bind[1].buffer_type= MYSQL_TYPE_STRING;
+  bind[1].buffer= &val;
+  bind[1].buffer_length= 20;
+
+  mysql_stmt_bind_result(stmt, bind);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(i != 1, "expected value 1 for first row");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(rc != MYSQL_NO_DATA, "Eof expected");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc67");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_bug1115(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, rowcount;
+  MYSQL_BIND my_bind[1];
+  ulong length[1];
+  char szData[11];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_select");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_select(\
+session_id  char(9) NOT NULL, \
+    a       int(8) unsigned NOT NULL, \
+    b        int(5) NOT NULL, \
+    c      int(5) NOT NULL, \
+    d  datetime NOT NULL)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO test_select VALUES "
+                         "(\"abc\", 1, 2, 3, 2003-08-30), "
+                         "(\"abd\", 1, 2, 3, 2003-08-30), "
+                         "(\"abf\", 1, 2, 3, 2003-08-30), "
+                         "(\"abg\", 1, 2, 3, 2003-08-30), "
+                         "(\"abh\", 1, 2, 3, 2003-08-30), "
+                         "(\"abj\", 1, 2, 3, 2003-08-30), "
+                         "(\"abk\", 1, 2, 3, 2003-08-30), "
+                         "(\"abl\", 1, 2, 3, 2003-08-30), "
+                         "(\"abq\", 1, 2, 3, 2003-08-30) ");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO test_select VALUES "
+                         "(\"abw\", 1, 2, 3, 2003-08-30), "
+                         "(\"abe\", 1, 2, 3, 2003-08-30), "
+                         "(\"abr\", 1, 2, 3, 2003-08-30), "
+                         "(\"abt\", 1, 2, 3, 2003-08-30), "
+                         "(\"aby\", 1, 2, 3, 2003-08-30), "
+                         "(\"abu\", 1, 2, 3, 2003-08-30), "
+                         "(\"abi\", 1, 2, 3, 2003-08-30), "
+                         "(\"abo\", 1, 2, 3, 2003-08-30), "
+                         "(\"abp\", 1, 2, 3, 2003-08-30), "
+                         "(\"abz\", 1, 2, 3, 2003-08-30), "
+                         "(\"abx\", 1, 2, 3, 2003-08-30)");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "SELECT * FROM test_select WHERE "
+                "CONVERT(session_id USING utf8)= ?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 1, "Paramcount != 1");
+
+  memset(my_bind, '\0', sizeof(MYSQL_BIND));
+
+  strcpy(szData, (char *)"abc");
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)szData;
+  my_bind[0].buffer_length= 10;
+  my_bind[0].length= &length[0];
+  length[0]= 3;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rowcount= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_IF(rowcount != 1, "rowcount=%d != 1");
+
+  strcpy(szData, (char *)"venu");
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)szData;
+  my_bind[0].buffer_length= 10;
+  my_bind[0].length= &length[0];
+  length[0]= 4;
+  my_bind[0].is_null= 0;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rowcount= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_IF(rowcount != 0, "rowcount != 0");
+
+  strcpy(szData, (char *)"abc");
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)szData;
+  my_bind[0].buffer_length= 10;
+  my_bind[0].length= &length[0];
+  length[0]= 3;
+  my_bind[0].is_null= 0;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rowcount= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_select");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+/* Test BUG#1180 (optimized away part of WHERE clause) */
+
+static int test_bug1180(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, rowcount;
+  MYSQL_BIND my_bind[1];
+  ulong length[1];
+  char szData[11];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_select");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_select(session_id  char(9) NOT NULL)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO test_select VALUES (\"abc\")");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "SELECT * FROM test_select WHERE ?= \"1111\" and "
+                "session_id= \"abc\"");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 1, "Paramcount != 1");
+
+  memset(my_bind, '\0', sizeof(MYSQL_BIND));
+
+  strcpy(szData, (char *)"abc");
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)szData;
+  my_bind[0].buffer_length= 10;
+  my_bind[0].length= &length[0];
+  length[0]= 3;
+  my_bind[0].is_null= 0;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+
+  rowcount= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_IF(rowcount != 0, "rowcount != 0");
+
+  strcpy(szData, (char *)"1111");
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)szData;
+  my_bind[0].buffer_length= 10;
+  my_bind[0].length= &length[0];
+  length[0]= 4;
+  my_bind[0].is_null= 0;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rowcount= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_IF(rowcount != 1, "rowcount != 1");
+
+  strcpy(szData, (char *)"abc");
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)szData;
+  my_bind[0].buffer_length= 10;
+  my_bind[0].length= &length[0];
+  length[0]= 3;
+  my_bind[0].is_null= 0;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rowcount= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_IF(rowcount != 0, "rowcount != 0");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_select");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+/*
+  Test BUG#1644 (Insertion of more than 3 NULL columns with parameter
+  binding fails)
+*/
+
+static int test_bug1644(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_RES *result;
+  MYSQL_ROW row;
+  MYSQL_BIND my_bind[4];
+  int num;
+  my_bool isnull;
+  int rc, i;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS foo_dfr");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql,
+           "CREATE TABLE foo_dfr(col1 int, col2 int, col3 int, col4 int);");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "INSERT INTO foo_dfr VALUES (?, ?, ?, ? )");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 4, "Paramcount != 4");
+
+  memset(my_bind, '\0', sizeof(MYSQL_BIND) * 4);
+
+  num= 22;
+  isnull= 0;
+  for (i= 0 ; i < 4 ; i++)
+  {
+    my_bind[i].buffer_type= MYSQL_TYPE_LONG;
+    my_bind[i].buffer= (void *)&num;
+    my_bind[i].is_null= &isnull;
+  }
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  isnull= 1;
+  for (i= 0 ; i < 4 ; i++)
+    my_bind[i].is_null= &isnull;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  isnull= 0;
+  num= 88;
+  for (i= 0 ; i < 4 ; i++)
+    my_bind[i].is_null= &isnull;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "SELECT * FROM foo_dfr");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid resultset");
+
+  FAIL_IF(mysql_num_rows(result) != 3, "rowcount != 3");
+
+  mysql_data_seek(result, 0);
+
+  row= mysql_fetch_row(result);
+  FAIL_IF(!row, "row = NULL");
+  for (i= 0 ; i < 4 ; i++)
+  {
+    FAIL_UNLESS(strcmp(row[i], "22") == 0, "Wrong value");
+  }
+  row= mysql_fetch_row(result);
+  FAIL_IF(!row, "Invalid row");
+  for (i= 0 ; i < 4 ; i++)
+  {
+    FAIL_UNLESS(row[i] == 0, "row[i] != 0");
+  }
+  row= mysql_fetch_row(result);
+  FAIL_IF(!row, "Invalid row");
+  for (i= 0 ; i < 4 ; i++)
+  {
+    FAIL_UNLESS(strcmp(row[i], "88") == 0, "row[i] != 88");
+  }
+  row= mysql_fetch_row(result);
+  FAIL_IF(row, "row != NULL");
+
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS foo_dfr");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug11037(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *stmt_text;
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 (id int not null)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t1 values (1)");
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "select id FROM t1";
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  /* expected error */
+  rc = mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc==1, "Error expedted");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc==MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc==MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/* Bug#11183 "mysql_stmt_reset() doesn't reset information about error" */
+
+static int test_bug11183(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  char bug_statement[]= "insert into t1 values (1)";
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL(bug_statement));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  /* Trying to execute statement that should fail on execute stage */
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(!rc, "Error expected");
+
+  mysql_stmt_reset(stmt);
+  FAIL_IF(mysql_stmt_errno(stmt) != 0, "stmt->error != 0");
+
+  rc= mysql_query(mysql, "create table t1 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  /* Trying to execute statement that should pass ok */
+  if (mysql_stmt_execute(stmt))
+  {
+    mysql_stmt_reset(stmt);
+    FAIL_IF(mysql_stmt_errno(stmt) == 0, "stmt->error != 0");
+  }
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug12744(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt = NULL;
+  int rc;
+
+  SKIP_MAXSCALE;
+
+  stmt = mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, "SET @a:=1", 9);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /* set reconnect, kill and ping to reconnect */
+  rc= mysql_query(mysql, "SET @a:=1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_options(mysql, MYSQL_OPT_RECONNECT, "1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_kill(mysql, mysql_thread_id(mysql));
+
+  rc= mysql_ping(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_close(stmt);
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug1500(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[3];
+  int        rc= 0;
+  int32 int_data[3]= {2, 3, 4};
+  const char *data;
+  const char *query;
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bg1500");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_bg1500 (i INT)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_bg1500 VALUES (1), (2)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  query= "SELECT i FROM test_bg1500 WHERE i IN (?, ?, ?)";
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 3, "paramcount != 3");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer= (void *)int_data;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[2]= my_bind[1]= my_bind[0];
+  my_bind[1].buffer= (void *)(int_data + 1);
+  my_bind[2].buffer= (void *)(int_data + 2);
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE test_bg1500");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_bg1500 (s VARCHAR(25), FULLTEXT(s)) engine=MyISAM");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql,
+        "INSERT INTO test_bg1500 VALUES ('Gravedigger'), ('Greed'), ('Hollow Dogs')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  query= "SELECT s FROM test_bg1500 WHERE MATCH (s) AGAINST (?)";
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 1, "paramcount != 1");
+
+  data= "Dogs";
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *) data;
+  my_bind[0].buffer_length= (unsigned long)strlen(data);
+  my_bind[0].is_null= 0;
+  my_bind[0].length= 0;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+
+  mysql_stmt_close(stmt);
+
+  /* This should work too */
+  query= "SELECT s FROM test_bg1500 WHERE MATCH (s) AGAINST (CONCAT(?, 'digger'))";
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 1, "paramcount != 1");
+
+  data= "Grave";
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *) data;
+  my_bind[0].buffer_length= (unsigned long)strlen(data);
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bg1500");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug15510(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *query= "select 1 from dual where 1/0";
+
+  SKIP_MYSQL(mysql);
+
+  rc= mysql_query(mysql, "set @@sql_mode='ERROR_FOR_DIVISION_BY_ZERO'");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(mysql_warning_count(mysql), "Warning expected");
+
+  /* Cleanup */
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "set @@sql_mode=''");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/*
+  Bug #15518 - Reusing a stmt that has failed during prepare
+  does not clear error
+*/
+
+static int test_bug15518(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+
+  stmt= mysql_stmt_init(mysql);
+
+  /*
+    The prepare of foo should fail with errno 1064 since
+    it's not a valid query
+  */
+  rc= mysql_stmt_prepare(stmt, "foo", 3);
+  FAIL_UNLESS(rc && mysql_stmt_errno(stmt) && mysql_errno(mysql), "Error expected");
+
+  /*
+    Use the same stmt and reprepare with another query that
+    succeeds
+  */
+  rc= mysql_stmt_prepare(stmt, "SHOW STATUS", 12);
+  FAIL_UNLESS(!rc || mysql_stmt_errno(stmt) || mysql_errno(mysql), "Error expected");
+
+  rc= mysql_stmt_close(stmt);
+  check_mysql_rc(rc, mysql);
+  /*
+    part2, when connection to server has been closed
+    after first prepare
+  */
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, "foo", 3);
+  FAIL_UNLESS(rc && mysql_stmt_errno(stmt) && mysql_errno(mysql), "Error expected");
+
+  /* Close connection to server */
+  mysql_close(mysql);
+
+  /*
+    Use the same stmt and reprepare with another query that
+    succeeds. The prepare should fail with error 2013 since
+    connection to server has been closed.
+  */
+  rc= mysql_stmt_prepare(stmt, "SHOW STATUS", 12);
+  FAIL_UNLESS(rc && mysql_stmt_errno(stmt), "Error expected");
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+/*
+  Bug #15613: "libmysqlclient API function mysql_stmt_prepare returns wrong
+  field length"
+*/
+
+static int test_bug15613(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  const char *stmt_text;
+  MYSQL_RES *metadata;
+  MYSQL_FIELD *field;
+  int rc;
+
+  /* I. Prepare the table */
+  rc= mysql_query(mysql, "set names latin1");
+  check_mysql_rc(rc, mysql);
+  mysql_query(mysql, "drop table if exists t1");
+  rc= mysql_query(mysql,
+                  "create table t1 (t text character set utf8, "
+                                   "tt tinytext character set utf8, "
+                                   "mt mediumtext character set utf8, "
+                                   "lt longtext character set utf8, "
+                                   "vl varchar(255) character set latin1,"
+                                   "vb varchar(255) character set binary,"
+                                   "vu varchar(255) character set utf8)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+
+  /* II. Check SELECT metadata */
+  stmt_text= ("select t, tt, mt, lt, vl, vb, vu from t1");
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  metadata= mysql_stmt_result_metadata(stmt);
+  field= mysql_fetch_fields(metadata);
+  FAIL_UNLESS(field[0].length == 65535, "length != 65535");
+  FAIL_UNLESS(field[1].length == 255, "length != 244");
+  FAIL_UNLESS(field[2].length == 16777215, "length != 166777215");
+  FAIL_UNLESS(field[3].length == 4294967295UL, "length != 4294967295UL");
+  FAIL_UNLESS(field[4].length == 255, "length != 255");
+  FAIL_UNLESS(field[5].length == 255, "length != 255");
+  FAIL_UNLESS(field[6].length == 255, "length != 255");
+  mysql_free_result(metadata);
+  mysql_stmt_free_result(stmt);
+
+  /* III. Cleanup */
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "set names default");
+  check_mysql_rc(rc, mysql);
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_bug16144(MYSQL *mysql)
+{
+  const my_bool flag_orig= (my_bool) 0xde;
+  my_bool flag= flag_orig;
+  MYSQL_STMT *stmt;
+
+  /* Check that attr_get returns correct data on little and big endian CPUs */
+  stmt= mysql_stmt_init(mysql);
+  mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (const void*) &flag);
+  mysql_stmt_attr_get(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &flag);
+  FAIL_UNLESS(flag == flag_orig, "flag != flag_orig");
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+/*
+  This tests for various mysql_stmt_send_long_data bugs described in #1664
+*/
+
+static int test_bug1664(MYSQL *mysql)
+{
+    MYSQL_STMT *stmt;
+    int        rc, int_data;
+    const char *data;
+    const char *str_data= "Simple string";
+    MYSQL_BIND my_bind[2];
+    const char *query= "INSERT INTO test_long_data(col2, col1) VALUES(?, ?)";
+
+
+    rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_long_data");
+    check_mysql_rc(rc, mysql);
+
+    rc= mysql_query(mysql, "CREATE TABLE test_long_data(col1 int, col2 long varchar)");
+    check_mysql_rc(rc, mysql);
+
+    stmt= mysql_stmt_init(mysql);
+    rc= mysql_stmt_prepare(stmt, SL(query));
+    check_stmt_rc(rc, stmt);
+
+    FAIL_IF(mysql_stmt_param_count(stmt) != 2, "Param count != 2");
+
+    memset(my_bind, '\0', sizeof(my_bind));
+
+    my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+    my_bind[0].buffer= (void *)str_data;
+    my_bind[0].buffer_length= (unsigned long)strlen(str_data);
+
+    my_bind[1].buffer= (void *)&int_data;
+    my_bind[1].buffer_type= MYSQL_TYPE_LONG;
+
+    rc= mysql_stmt_bind_param(stmt, my_bind);
+    check_stmt_rc(rc, stmt);
+
+    int_data= 1;
+
+    /*
+      Let us supply empty long_data. This should work and should
+      not break following execution.
+    */
+    data= "";
+    rc= mysql_stmt_send_long_data(stmt, 0, SL(data));
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    if (verify_col_data(mysql, "test_long_data", "col1", "1"))
+      goto error;
+    if (verify_col_data(mysql, "test_long_data", "col2", ""))
+      goto error;
+    rc= mysql_query(mysql, "DELETE FROM test_long_data");
+    check_mysql_rc(rc, mysql);
+
+    /* This should pass OK */
+    data= (char *)"Data";
+    rc= mysql_stmt_send_long_data(stmt, 0, SL(data));
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    if (verify_col_data(mysql, "test_long_data", "col1", "1"))
+      goto error;
+    if (verify_col_data(mysql, "test_long_data", "col2", "Data"))
+      goto error;
+
+    /* clean up */
+    rc= mysql_query(mysql, "DELETE FROM test_long_data");
+    check_mysql_rc(rc, mysql);
+
+    /*
+      Now we are changing int parameter and don't do anything
+      with first parameter. Second mysql_stmt_execute() should run
+      OK treating this first parameter as string parameter.
+    */
+
+    int_data= 2;
+    /* execute */
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    if (verify_col_data(mysql, "test_long_data", "col1", "2"))
+      goto error;
+    if (verify_col_data(mysql, "test_long_data", "col2", str_data))
+      goto error;
+
+    /* clean up */
+    rc= mysql_query(mysql, "DELETE FROM test_long_data");
+    check_mysql_rc(rc, mysql);
+
+    /*
+      Now we are sending other long data. It should not be
+      concatenated to previous.
+    */
+
+    data= (char *)"SomeOtherData";
+    rc= mysql_stmt_send_long_data(stmt, 0, SL(data));
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    if (verify_col_data(mysql, "test_long_data", "col1", "2"))
+      goto error;
+    if (verify_col_data(mysql, "test_long_data", "col2", "SomeOtherData"))
+      goto error;
+
+    mysql_stmt_close(stmt);
+
+    /* clean up */
+    rc= mysql_query(mysql, "DELETE FROM test_long_data");
+    check_mysql_rc(rc, mysql);
+
+    /* Now let us test how mysql_stmt_reset works. */
+    stmt= mysql_stmt_init(mysql);
+    rc= mysql_stmt_prepare(stmt, SL(query));
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_bind_param(stmt, my_bind);
+    check_stmt_rc(rc, stmt);
+
+    data= (char *)"SomeData";
+    rc= mysql_stmt_send_long_data(stmt, 0, SL(data));
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_reset(stmt);
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    if (verify_col_data(mysql, "test_long_data", "col1", "2"))
+      goto error;
+    if (verify_col_data(mysql, "test_long_data", "col2", str_data))
+      goto error;
+
+    mysql_stmt_close(stmt);
+
+    /* Final clean up */
+    rc= mysql_query(mysql, "DROP TABLE test_long_data");
+    check_mysql_rc(rc, mysql);
+
+    return OK;
+
+error:
+    mysql_stmt_close(stmt);
+    rc= mysql_query(mysql, "DROP TABLE test_long_data");
+    return FAIL;
+}
+/* Test a misc bug */
+
+static int test_ushort_bug(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[4];
+  ushort     short_value;
+  uint32     long_value;
+  ulong      s_length, l_length, ll_length, t_length;
+  ulonglong  longlong_value;
+  int        rc;
+  uchar      tiny_value;
+  const char *query= "SELECT * FROM test_ushort";
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_ushort");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_ushort(a smallint unsigned, \
+                                                  b smallint unsigned, \
+                                                  c smallint unsigned, \
+                                                  d smallint unsigned)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql,
+                  "INSERT INTO test_ushort VALUES(35999, 35999, 35999, 200)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[0].buffer= (void *)&short_value;
+  my_bind[0].is_unsigned= TRUE;
+  my_bind[0].length= &s_length;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[1].buffer= (void *)&long_value;
+  my_bind[1].length= &l_length;
+
+  my_bind[2].buffer_type= MYSQL_TYPE_LONGLONG;
+  my_bind[2].buffer= (void *)&longlong_value;
+  my_bind[2].length= &ll_length;
+
+  my_bind[3].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[3].buffer= (void *)&tiny_value;
+  my_bind[3].is_unsigned= TRUE;
+  my_bind[3].length= &t_length;
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(short_value == 35999, "short_value != 35999");
+  FAIL_UNLESS(s_length == 2, "length != 2");
+
+  FAIL_UNLESS(long_value == 35999, "long_value != 35999");
+  FAIL_UNLESS(l_length == 4, "length != 4");
+
+  FAIL_UNLESS(longlong_value == 35999, "longlong_value != 35999");
+  FAIL_UNLESS(ll_length == 8, "length != 8");
+
+  FAIL_UNLESS(tiny_value == 200, "tiny_value != 200");
+  FAIL_UNLESS(t_length == 1, "length != 1");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_ushort");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug1946(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *query= "INSERT INTO prepare_command VALUES (?)";
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS prepare_command");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE prepare_command(ID INT)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_real_query(mysql, SL(query));
+  FAIL_IF(!rc, "Error expected");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE prepare_command");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_bug20152(MYSQL *mysql)
+{
+  MYSQL_BIND my_bind[1];
+  MYSQL_STMT *stmt;
+  MYSQL_TIME tm;
+  int rc;
+  const char *query= "INSERT INTO t1 (f1) VALUES (?)";
+
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_DATE;
+  my_bind[0].buffer= (void*)&tm;
+
+  memset(&tm, 0, sizeof(MYSQL_TIME));
+
+  tm.year = 2006;
+  tm.month = 6;
+  tm.day = 18;
+  tm.hour = 14;
+  tm.minute = 9;
+  tm.second = 42;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (f1 DATE)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  FAIL_UNLESS(tm.hour == 14 && tm.minute == 9 && tm.second == 42, "time != 14:09:42");
+  return OK;
+}
+
+static int test_bug2247(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_RES *res;
+  int rc;
+  int i;
+  const char *create= "CREATE TABLE bug2247(id INT UNIQUE AUTO_INCREMENT)";
+  const char *insert= "INSERT INTO bug2247 VALUES (NULL)";
+  const char *SELECT= "SELECT id FROM bug2247";
+  const char *update= "UPDATE bug2247 SET id=id+10";
+  const char *drop= "DROP TABLE IF EXISTS bug2247";
+  ulonglong exp_count;
+  enum { NUM_ROWS= 5 };
+
+
+  /* create table and insert few rows */
+  rc= mysql_query(mysql, drop);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, create);
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(insert));
+  check_stmt_rc(rc, stmt);
+  for (i= 0; i < NUM_ROWS; ++i)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+  exp_count= mysql_stmt_affected_rows(stmt);
+  FAIL_UNLESS(exp_count == 1, "exp_count != 1");
+
+  rc= mysql_query(mysql, SELECT);
+  check_mysql_rc(rc, mysql);
+  /*
+    mysql_store_result overwrites mysql->affected_rows. Check that
+    mysql_stmt_affected_rows() returns the same value, whereas
+    mysql_affected_rows() value is correct.
+  */
+  res= mysql_store_result(mysql);
+  FAIL_IF(!res, "Invalid result set");
+
+  FAIL_UNLESS(mysql_affected_rows(mysql) == NUM_ROWS, "affected_rows != NUM_ROWS");
+  FAIL_UNLESS(exp_count == mysql_stmt_affected_rows(stmt), "affected_rows != exp_count");
+
+  rc= mysql_query(mysql, update);
+  check_mysql_rc(rc, mysql);
+  FAIL_UNLESS(mysql_affected_rows(mysql) == NUM_ROWS, "affected_rows != NUM_ROWS");
+  FAIL_UNLESS(exp_count == mysql_stmt_affected_rows(stmt), "affected_rows != exp_count");
+
+  mysql_free_result(res);
+  mysql_stmt_close(stmt);
+
+  /* check that mysql_stmt_store_result modifies mysql_stmt_affected_rows */
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(SELECT));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);  exp_count= mysql_stmt_affected_rows(stmt);
+  FAIL_UNLESS(exp_count == NUM_ROWS, "exp_count != NUM_ROWS");
+
+  rc= mysql_query(mysql, insert);
+  check_mysql_rc(rc, mysql);
+  FAIL_UNLESS(mysql_affected_rows(mysql) == 1, "affected_rows != 1");
+  FAIL_UNLESS(exp_count == mysql_stmt_affected_rows(stmt), "affected_rows != exp_count");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, drop);
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/*
+  Test for bug#2248 "mysql_fetch without prior mysql_stmt_execute hangs"
+*/
+
+static int test_bug2248(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *query1= "SELECT DATABASE()";
+  const char *query2= "INSERT INTO test_bug2248 VALUES (10)";
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bug2248");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_bug2248 (id int)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query1));
+  check_stmt_rc(rc, stmt);
+
+  /* This should not hang */
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(!rc, "Error expected");
+
+  /* And this too */
+  rc= mysql_stmt_store_result(stmt);
+  FAIL_IF(!rc, "Error expected");
+
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query2));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  /* This too should not hang but should return proper error */
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == 1, "rc != 1");
+
+  /* This too should not hang but should not bark */
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+  /* This should return proper error */
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == 1, "rc != 1");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE test_bug2248");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/*
+  BUG#23383: mysql_affected_rows() returns different values than
+  mysql_stmt_affected_rows()
+
+  Test that both mysql_affected_rows() and mysql_stmt_affected_rows()
+  return -1 on error, 0 when no rows were affected, and (positive) row
+  count when some rows were affected.
+*/
+static int test_bug23383(MYSQL *mysql)
+{
+  const char *insert_query= "INSERT INTO t1 VALUES (1), (2)";
+  const char *update_query= "UPDATE t1 SET i= 4 WHERE i = 3";
+  MYSQL_STMT *stmt;
+  unsigned long long row_count;
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (i INT UNIQUE)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, insert_query);
+  check_mysql_rc(rc, mysql);
+  row_count= mysql_affected_rows(mysql);
+  FAIL_UNLESS(row_count == 2, "row_count != 2");
+
+  rc= mysql_query(mysql, insert_query);
+  FAIL_IF(!rc, "Error expected");
+  row_count= mysql_affected_rows(mysql);
+  FAIL_UNLESS(row_count == (unsigned long long)-1, "rowcount != -1");
+
+  rc= mysql_query(mysql, update_query);
+  check_mysql_rc(rc, mysql);
+  row_count= mysql_affected_rows(mysql);
+  FAIL_UNLESS(row_count == 0, "");
+
+  rc= mysql_query(mysql, "DELETE FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL(insert_query));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  row_count= mysql_stmt_affected_rows(stmt);
+  FAIL_UNLESS(row_count == 2, "row_count != 2");
+
+  rc= mysql_stmt_execute(stmt);
+  FAIL_UNLESS(rc != 0, "");
+  row_count= mysql_stmt_affected_rows(stmt);
+  FAIL_UNLESS(row_count == (unsigned long long)-1, "rowcount != -1");
+
+  rc= mysql_stmt_prepare(stmt, SL(update_query));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  row_count= mysql_stmt_affected_rows(stmt);
+  FAIL_UNLESS(row_count == 0, "rowcount != 0");
+
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/*
+  Bug#27592 (stack overrun when storing datetime value using prepared statements)
+*/
+
+static int test_bug27592(MYSQL *mysql)
+{
+  const int NUM_ITERATIONS= 40;
+  int i;
+  int rc;
+  MYSQL_STMT *stmt= NULL;
+  MYSQL_BIND bind[1];
+  MYSQL_TIME time_val;
+
+  mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  mysql_query(mysql, "CREATE TABLE t1(c2 DATETIME)");
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO t1 VALUES (?)"));
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, '\0', sizeof(bind));
+
+  bind[0].buffer_type= MYSQL_TYPE_DATETIME;
+  bind[0].buffer= (char *) &time_val;
+  bind[0].length= NULL;
+
+  for (i= 0; i < NUM_ITERATIONS; i++)
+  {
+    time_val.year= 2007;
+    time_val.month= 6;
+    time_val.day= 7;
+    time_val.hour= 18;
+    time_val.minute= 41;
+    time_val.second= 3;
+
+    time_val.second_part=0;
+    time_val.neg=0;
+
+    rc= mysql_stmt_bind_param(stmt, bind);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+
+  mysql_stmt_close(stmt);
+  mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+
+  return OK;
+}
+
+/*
+  Bug#28934: server crash when receiving malformed com_execute packets
+*/
+
+static int test_bug28934(MYSQL *mysql)
+{
+  my_bool error= 0;
+  MYSQL_BIND bind[5];
+  MYSQL_STMT *stmt;
+  int rc, cnt;
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1(id int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t1 values(1),(2),(3),(4),(5)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("select * from t1 where id in(?,?,?,?,?)"));
+  check_stmt_rc(rc, stmt);
+
+  memset (&bind, '\0', sizeof (bind));
+  for (cnt= 0; cnt < 5; cnt++)
+  {
+    bind[cnt].buffer_type= MYSQL_TYPE_LONG;
+    bind[cnt].buffer= (char*)&cnt;
+    bind[cnt].buffer_length= 0;
+  }
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  stmt->param_count=2;
+  error= mysql_stmt_execute(stmt);
+  FAIL_UNLESS(error != 0, "Error expected");
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_bug3035(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  MYSQL_BIND bind_array[12], *my_bind= bind_array, *bind_end= my_bind + 12;
+  int8 int8_val;
+  uint8 uint8_val;
+  int16 int16_val;
+  uint16 uint16_val;
+  int32 int32_val;
+  uint32 uint32_val;
+  longlong int64_val;
+  ulonglong uint64_val;
+  double double_val, udouble_val, double_tmp;
+  char longlong_as_string[22], ulonglong_as_string[22];
+
+  /* mins and maxes */
+  const int8 int8_min= -128;
+  const int8 int8_max= 127;
+  const uint8 uint8_min= 0;
+  const uint8 uint8_max= 255;
+
+  const int16 int16_min= -32768;
+  const int16 int16_max= 32767;
+  const uint16 uint16_min= 0;
+  const uint16 uint16_max= 65535;
+
+  const int32 int32_max= 2147483647L;
+  const int32 int32_min= -int32_max - 1;
+  const uint32 uint32_min= 0;
+  const uint32 uint32_max= 4294967295U;
+
+  /* it might not work okay everyplace */
+  const longlong int64_max= 9223372036854775807LL;
+  const longlong int64_min= -int64_max - 1;
+
+  const ulonglong uint64_min= 0U;
+  const ulonglong uint64_max= 18446744073709551615ULL;
+
+  const char *stmt_text;
+
+
+  stmt_text= "DROP TABLE IF EXISTS t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "CREATE TABLE t1 (i8 TINYINT, ui8 TINYINT UNSIGNED, "
+                              "i16 SMALLINT, ui16 SMALLINT UNSIGNED, "
+                              "i32 INT, ui32 INT UNSIGNED, "
+                              "i64 BIGINT, ui64 BIGINT UNSIGNED, "
+                              "id INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  memset(bind_array, '\0', sizeof(bind_array));
+  for (my_bind= bind_array; my_bind < bind_end; my_bind++)
+    my_bind->error= &my_bind->error_value;
+
+  bind_array[0].buffer_type= MYSQL_TYPE_TINY;
+  bind_array[0].buffer= (void *) &int8_val;
+
+  bind_array[1].buffer_type= MYSQL_TYPE_TINY;
+  bind_array[1].buffer= (void *) &uint8_val;
+  bind_array[1].is_unsigned= 1;
+
+  bind_array[2].buffer_type= MYSQL_TYPE_SHORT;
+  bind_array[2].buffer= (void *) &int16_val;
+
+  bind_array[3].buffer_type= MYSQL_TYPE_SHORT;
+  bind_array[3].buffer= (void *) &uint16_val;
+  bind_array[3].is_unsigned= 1;
+
+  bind_array[4].buffer_type= MYSQL_TYPE_LONG;
+  bind_array[4].buffer= (void *) &int32_val;
+
+  bind_array[5].buffer_type= MYSQL_TYPE_LONG;
+  bind_array[5].buffer= (void *) &uint32_val;
+  bind_array[5].is_unsigned= 1;
+
+  bind_array[6].buffer_type= MYSQL_TYPE_LONGLONG;
+  bind_array[6].buffer= (void *) &int64_val;
+
+  bind_array[7].buffer_type= MYSQL_TYPE_LONGLONG;
+  bind_array[7].buffer= (void *) &uint64_val;
+  bind_array[7].is_unsigned= 1;
+
+  stmt= mysql_stmt_init(mysql);
+  check_stmt_rc(rc, stmt);
+
+  stmt_text= "INSERT INTO t1 (i8, ui8, i16, ui16, i32, ui32, i64, ui64) "
+                     "VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_bind_param(stmt, bind_array);
+
+  int8_val= int8_min;
+  uint8_val= uint8_min;
+  int16_val= int16_min;
+  uint16_val= uint16_min;
+  int32_val= int32_min;
+  uint32_val= uint32_min;
+  int64_val= int64_min;
+  uint64_val= uint64_min;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  int8_val= int8_max;
+  uint8_val= uint8_max;
+  int16_val= int16_max;
+  uint16_val= uint16_max;
+  int32_val= int32_max;
+  uint32_val= uint32_max;
+  int64_val= int64_max;
+  uint64_val= uint64_max;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  stmt_text= "SELECT i8, ui8, i16, ui16, i32, ui32, i64, ui64, ui64, "
+             "cast(ui64 as signed), ui64, cast(ui64 as signed)"
+             "FROM t1 ORDER BY id ASC";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  bind_array[8].buffer_type= MYSQL_TYPE_DOUBLE;
+  bind_array[8].buffer= (void *) &udouble_val;
+
+  bind_array[9].buffer_type= MYSQL_TYPE_DOUBLE;
+  bind_array[9].buffer= (void *) &double_val;
+
+  bind_array[10].buffer_type= MYSQL_TYPE_STRING;
+  bind_array[10].buffer= (void *) &ulonglong_as_string;
+  bind_array[10].buffer_length= sizeof(ulonglong_as_string);
+
+  bind_array[11].buffer_type= MYSQL_TYPE_STRING;
+  bind_array[11].buffer= (void *) &longlong_as_string;
+  bind_array[11].buffer_length= sizeof(longlong_as_string);
+
+  mysql_stmt_bind_result(stmt, bind_array);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(int8_val == int8_min, "int8_val != int8_min");
+  FAIL_UNLESS(uint8_val == uint8_min, "uint8_val != uint8_min");
+  FAIL_UNLESS(int16_val == int16_min, "int16_val != int16_min");
+  FAIL_UNLESS(uint16_val == uint16_min, "uint16_val != uint16_min");
+  FAIL_UNLESS(int32_val == int32_min, "int32_val != int32_min");
+  FAIL_UNLESS(uint32_val == uint32_min, "uint32_val != uint32_min");
+  FAIL_UNLESS(int64_val == int64_min, "int64_val != int64_min");
+  FAIL_UNLESS(uint64_val == uint64_min, "uint64_val != uint64_min");
+  FAIL_UNLESS(double_val == (longlong) uint64_min, "double_val != uint64_min");
+  double_tmp= ulonglong2double(uint64_val);
+  FAIL_UNLESS(cmp_double(&udouble_val,&double_tmp), "udouble_val != double_tmp");
+  FAIL_UNLESS(!strcmp(longlong_as_string, "0"), "longlong_as_string != '0'");
+  FAIL_UNLESS(!strcmp(ulonglong_as_string, "0"), "ulonglong_as_string != '0'");
+
+  rc= mysql_stmt_fetch(stmt);
+
+  FAIL_UNLESS(rc == MYSQL_DATA_TRUNCATED || rc == 0, "rc != 0,MYSQL_DATA_TRUNCATED");
+
+  FAIL_UNLESS(int8_val == int8_max, "int8_val != int8_max");
+  FAIL_UNLESS(uint8_val == uint8_max, "uint8_val != uint8_max");
+  FAIL_UNLESS(int16_val == int16_max, "int16_val != int16_max");
+  FAIL_UNLESS(uint16_val == uint16_max, "uint16_val != uint16_max");
+  FAIL_UNLESS(int32_val == int32_max, "int32_val != int32_max");
+  FAIL_UNLESS(uint32_val == uint32_max, "uint32_val != uint32_max");
+  FAIL_UNLESS(int64_val == int64_max, "int64_val != int64_max");
+  FAIL_UNLESS(uint64_val == uint64_max, "uint64_val != uint64_max");
+  FAIL_UNLESS(double_val == (longlong) uint64_val, "double_val != uint64_val");
+  double_tmp= ulonglong2double(uint64_val);
+  FAIL_UNLESS(cmp_double(&udouble_val,&double_tmp), "udouble_val != double_tmp");
+  FAIL_UNLESS(!strcmp(longlong_as_string, "-1"), "longlong_as_string != '-1'");
+  FAIL_UNLESS(!strcmp(ulonglong_as_string, "18446744073709551615"), "ulonglong_as_string != '18446744073709551615'");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "");
+
+  mysql_stmt_close(stmt);
+
+  stmt_text= "DROP TABLE t1";
+  mysql_real_query(mysql, SL(stmt_text));
+  return OK;
+}
+
+/*
+  Test for BUG#3420 ("select id1, value1 from t where id= ? or value= ?"
+  returns all rows in the table)
+*/
+
+static int test_ps_conj_select(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  MYSQL_BIND my_bind[2];
+  int32      int_data;
+  char       str_data[32];
+  unsigned long str_length;
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 (id1 int(11) NOT NULL default '0', "
+                         "value2 varchar(100), value1 varchar(100))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t1 values (1, 'hh', 'hh'), "
+                          "(2, 'hh', 'hh'), (1, 'ii', 'ii'), (2, 'ii', 'ii')");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "select id1, value1 from t1 where id1= ? or "
+                "CONVERT(value1 USING utf8)= ?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 2, "param_count != 2");
+
+  /* Always bzero all members of bind parameter */
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&int_data;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_VAR_STRING;
+  my_bind[1].buffer= (void *)str_data;
+  my_bind[1].buffer_length= array_elements(str_data);
+  my_bind[1].length= &str_length;
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+  int_data= 1;
+  strcpy(str_data, "hh");
+  str_length= (unsigned long)strlen(str_data);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc=0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+   rc++;
+  FAIL_UNLESS(rc == 3, "rc != 3");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test for NULL as PS parameter (BUG#3367, BUG#3371) */
+
+static int test_ps_null_param(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+
+  MYSQL_BIND in_bind;
+  my_bool    in_is_null;
+  long int   in_long;
+
+  MYSQL_BIND out_bind;
+  ulong      out_length;
+  my_bool    out_is_null;
+  char       out_str_data[20];
+
+  const char *queries[]= {"select ?", "select ?+1",
+                    "select col1 from test_ps_nulls where col1 <=> ?",
+                    NULL
+                    };
+  const char **cur_query= queries;
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_ps_nulls");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_ps_nulls(col1 int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_ps_nulls values (1), (null)");
+  check_mysql_rc(rc, mysql);
+
+  /* Always bzero all members of bind parameter */
+  memset(&in_bind, '\0', sizeof(in_bind));
+  memset(&out_bind, '\0', sizeof(out_bind));
+  in_bind.buffer_type= MYSQL_TYPE_LONG;
+  in_bind.is_null= &in_is_null;
+  in_bind.length= 0;
+  in_bind.buffer= (void *)&in_long;
+  in_is_null= 1;
+  in_long= 1;
+
+  out_bind.buffer_type= MYSQL_TYPE_STRING;
+  out_bind.is_null= &out_is_null;
+  out_bind.length= &out_length;
+  out_bind.buffer= out_str_data;
+  out_bind.buffer_length= array_elements(out_str_data);
+
+  /* Execute several queries, all returning NULL in result. */
+  for(cur_query= queries; *cur_query; cur_query++)
+  {
+    char query[MAX_TEST_QUERY_LENGTH];
+    strcpy(query, *cur_query);
+    stmt= mysql_stmt_init(mysql);
+    FAIL_IF(!stmt, mysql_error(mysql));
+    rc= mysql_stmt_prepare(stmt, SL(query));
+    diag("statement: %s", query);
+    check_stmt_rc(rc, stmt);
+    FAIL_IF(mysql_stmt_param_count(stmt) != 1, "param_count != 1");
+
+    rc= mysql_stmt_bind_param(stmt, &in_bind);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_bind_result(stmt, &out_bind);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_fetch(stmt);
+    FAIL_UNLESS(rc != MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+    FAIL_UNLESS(out_is_null, "!out_is_null");
+    rc= mysql_stmt_fetch(stmt);
+    FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+    mysql_stmt_close(stmt);
+  }
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_ps_nulls");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/*
+  utility for the next test; expects 3 rows in the result from a SELECT,
+  compares each row/field with an expected value.
+ */
+#define test_ps_query_cache_result(i1,s1,l1,i2,s2,l2,i3,s3,l3)    \
+  r_metadata= mysql_stmt_result_metadata(stmt);                   \
+  FAIL_UNLESS(r_metadata != NULL, "");                            \
+  rc= mysql_stmt_fetch(stmt);                                     \
+  check_stmt_rc(rc,stmt);                                         \
+  FAIL_UNLESS((r_int_data == i1) && (r_str_length == l1) &&       \
+             (strcmp(r_str_data, s1) == 0), "test_ps_query_cache_result failure"); \
+  rc= mysql_stmt_fetch(stmt);                                     \
+  check_stmt_rc(rc,stmt);                                         \
+  FAIL_UNLESS((r_int_data == i2) && (r_str_length == l2) &&       \
+             (strcmp(r_str_data, s2) == 0), "test_ps_query_cache_result failure"); \
+  rc= mysql_stmt_fetch(stmt);                                     \
+  check_stmt_rc(rc,stmt);                                         \
+  FAIL_UNLESS((r_int_data == i3) && (r_str_length == l3) &&       \
+             (strcmp(r_str_data, s3) == 0), "test_ps_query_cache_result failure"); \
+  rc= mysql_stmt_fetch(stmt);                                     \
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");        \
+  mysql_free_result(r_metadata);
+
+/* reads Qcache_hits from server and returns its value */
+static int query_cache_hits(MYSQL *mysql)
+{
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  int rc;
+  uint result;
+
+  rc= mysql_query(mysql, "show status like 'qcache_hits'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_use_result(mysql);
+
+  row= mysql_fetch_row(res);
+
+  result= atoi(row[1]);
+  mysql_free_result(res);
+  return result;
+}
+
+
+/*
+  Test that prepared statements make use of the query cache just as normal
+  statements (BUG#735).
+*/
+static int test_ps_query_cache(MYSQL *mysql)
+{
+  MYSQL      *lmysql= mysql;
+  MYSQL_STMT *stmt;
+  int        rc;
+  MYSQL_BIND p_bind[2],r_bind[2]; /* p: param bind; r: result bind */
+  int32      p_int_data, r_int_data;
+  char       p_str_data[32], r_str_data[32];
+  unsigned long p_str_length, r_str_length;
+  MYSQL_RES  *r_metadata;
+  char       query[MAX_TEST_QUERY_LENGTH];
+  uint       hits1, hits2;
+  enum enum_test_ps_query_cache
+  {
+    /*
+      We iterate the same prepare/executes block, but have iterations where
+      we vary the query cache conditions.
+    */
+    /* the query cache is enabled for the duration of prep&execs: */
+    TEST_QCACHE_ON= 0,
+    /*
+      same but using a new connection (to see if qcache serves results from
+      the previous connection as it should):
+    */
+    TEST_QCACHE_ON_WITH_OTHER_CONN,
+    /*
+      First border case: disables the query cache before prepare and
+      re-enables it before execution (to test if we have no bug then):
+    */
+    TEST_QCACHE_OFF_ON,
+    /*
+      Second border case: enables the query cache before prepare and
+      disables it before execution:
+    */
+    TEST_QCACHE_ON_OFF
+  };
+  enum enum_test_ps_query_cache iteration;
+
+  diag("test needs to be fixed");
+  return SKIP;
+  /* prepare the table */
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1 (id1 int(11) NOT NULL default '0', "
+                         "value2 varchar(100), value1 varchar(100))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into t1 values (1, 'hh', 'hh'), "
+                          "(2, 'hh', 'hh'), (1, 'ii', 'ii'), (2, 'ii', 'ii')");
+  check_mysql_rc(rc, mysql);
+
+  for (iteration= TEST_QCACHE_ON; iteration <= TEST_QCACHE_ON_OFF; iteration++)
+  {
+    switch (iteration) {
+    case TEST_QCACHE_ON:
+    case TEST_QCACHE_ON_OFF:
+      rc= mysql_query(lmysql, "set global query_cache_size=1000000");
+      check_mysql_rc(rc, mysql);
+      break;
+    case TEST_QCACHE_OFF_ON:
+      rc= mysql_query(lmysql, "set global query_cache_size=0");
+      check_mysql_rc(rc, mysql);
+      break;
+    case TEST_QCACHE_ON_WITH_OTHER_CONN:
+      lmysql= test_connect(NULL);
+      FAIL_IF(!lmysql, "Opening new connection failed");
+      break;
+    }
+
+    strcpy(query, "select id1, value1 from t1 where id1= ? or "
+           "CONVERT(value1 USING utf8)= ?");
+    stmt= mysql_stmt_init(lmysql);
+    FAIL_IF(!stmt, mysql_error(lmysql));
+    rc= mysql_stmt_prepare(stmt, SL(query));
+    check_stmt_rc(rc, stmt);
+
+    FAIL_IF(mysql_stmt_param_count(stmt) != 2, "param_count != 2");
+
+    switch (iteration) {
+    case TEST_QCACHE_OFF_ON:
+      rc= mysql_query(lmysql, "set global query_cache_size=1000000");
+      check_mysql_rc(rc, mysql);
+      break;
+    case TEST_QCACHE_ON_OFF:
+      rc= mysql_query(lmysql, "set global query_cache_size=0");
+      check_mysql_rc(rc, mysql);
+    default:
+      break;
+    }
+
+    memset(p_bind, '\0', sizeof(p_bind));
+    p_bind[0].buffer_type= MYSQL_TYPE_LONG;
+    p_bind[0].buffer= (void *)&p_int_data;
+    p_bind[1].buffer_type= MYSQL_TYPE_VAR_STRING;
+    p_bind[1].buffer= (void *)p_str_data;
+    p_bind[1].buffer_length= array_elements(p_str_data);
+    p_bind[1].length= &p_str_length;
+
+    rc= mysql_stmt_bind_param(stmt, p_bind);
+    check_stmt_rc(rc, stmt);
+    p_int_data= 1;
+    strcpy(p_str_data, "hh");
+    p_str_length= (unsigned long)strlen(p_str_data);
+
+    memset(r_bind, '\0', sizeof(r_bind));
+    r_bind[0].buffer_type= MYSQL_TYPE_LONG;
+    r_bind[0].buffer= (void *)&r_int_data;
+    r_bind[1].buffer_type= MYSQL_TYPE_VAR_STRING;
+    r_bind[1].buffer= (void *)r_str_data;
+    r_bind[1].buffer_length= array_elements(r_str_data);
+    r_bind[1].length= &r_str_length;
+
+    rc= mysql_stmt_bind_result(stmt, r_bind);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    test_ps_query_cache_result(1, "hh", 2, 2, "hh", 2, 1, "ii", 2);
+  r_metadata= mysql_stmt_result_metadata(stmt);
+  FAIL_UNLESS(r_metadata != NULL, "");
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+  FAIL_UNLESS((r_int_data == 1) && (r_str_length == 2) &&
+             (strcmp(r_str_data, "hh") == 0), "test_ps_query_cache_result failure"); \
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+  FAIL_UNLESS((r_int_data == 2) && (r_str_length == 2) &&
+             (strcmp(r_str_data, "hh") == 0), "test_ps_query_cache_result failure"); \
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc,stmt);
+  FAIL_UNLESS((r_int_data == 1) && (r_str_length == 2) &&
+             (strcmp(r_str_data, "ii") == 0), "test_ps_query_cache_result failure"); \
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+  mysql_free_result(r_metadata);
+
+
+    /* now retry with the same parameter values and see qcache hits */
+    hits1= query_cache_hits(lmysql);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);    test_ps_query_cache_result(1, "hh", 2, 2, "hh", 2, 1, "ii", 2);
+    hits2= query_cache_hits(lmysql);
+    switch(iteration) {
+    case TEST_QCACHE_ON_WITH_OTHER_CONN:
+    case TEST_QCACHE_ON:                 /* should have hit */
+      FAIL_UNLESS(hits2-hits1 == 1, "hits2 != hits1 + 1");
+      break;
+    case TEST_QCACHE_OFF_ON:
+    case TEST_QCACHE_ON_OFF:             /* should not have hit */
+      FAIL_UNLESS(hits2-hits1 == 0, "hits2 != hits1");
+      break;
+    }
+
+    /* now modify parameter values and see qcache hits */
+    strcpy(p_str_data, "ii");
+    p_str_length= (unsigned long)strlen(p_str_data);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    test_ps_query_cache_result(1, "hh", 2, 1, "ii", 2, 2, "ii", 2);
+    hits1= query_cache_hits(lmysql);
+
+    switch(iteration) {
+    case TEST_QCACHE_ON:
+    case TEST_QCACHE_OFF_ON:
+    case TEST_QCACHE_ON_OFF:             /* should not have hit */
+      FAIL_UNLESS(hits2-hits1 == 0, "hits2 != hits1");
+      break;
+    case TEST_QCACHE_ON_WITH_OTHER_CONN: /* should have hit */
+      FAIL_UNLESS(hits1-hits2 == 1, "hits2 != hits1+1");
+      break;
+    }
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    test_ps_query_cache_result(1, "hh", 2, 1, "ii", 2, 2, "ii", 2);
+    hits2= query_cache_hits(lmysql);
+
+    mysql_stmt_close(stmt);
+
+    switch(iteration) {
+    case TEST_QCACHE_ON:                 /* should have hit */
+      FAIL_UNLESS(hits2-hits1 == 1, "hits2 != hits1+1");
+      break;
+    case TEST_QCACHE_OFF_ON:
+    case TEST_QCACHE_ON_OFF:             /* should not have hit */
+      FAIL_UNLESS(hits2-hits1 == 0, "hits2 != hits1");
+      break;
+    case TEST_QCACHE_ON_WITH_OTHER_CONN: /* should have hit */
+      FAIL_UNLESS(hits2-hits1 == 1, "hits2 != hits1+1");
+      break;
+    }
+
+  } /* for(iteration=...) */
+
+  if (lmysql != mysql)
+    mysql_close(lmysql);
+
+  rc= mysql_query(mysql, "set global query_cache_size=0");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_bug3117(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND buffer;
+  longlong lii;
+  ulong length;
+  my_bool is_null;
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (id int auto_increment primary key)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT LAST_INSERT_ID()"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (NULL)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  memset(&buffer, '\0', sizeof(buffer));
+  buffer.buffer_type= MYSQL_TYPE_LONGLONG;
+  buffer.buffer_length= sizeof(lii);
+  buffer.buffer= (void *)&lii;
+  buffer.length= &length;
+  buffer.is_null= &is_null;
+
+  rc= mysql_stmt_bind_result(stmt, &buffer);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(is_null == 0 && lii == 1, "is_null != 0 || lii != 1");
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (NULL)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(is_null == 0 && lii == 2, "is_null != 0 || lii != 2");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/**
+  Bug#36004 mysql_stmt_prepare resets the list of warnings
+*/
+
+static int test_bug36004(MYSQL *mysql)
+{
+  int rc, warning_count= 0;
+  MYSQL_STMT *stmt;
+  SKIP_MAXSCALE;
+  SKIP_MYSQL(mysql); // don't send expected warnings
+
+  if (mysql_get_server_version(mysql) < 60000) {
+    diag("Test requires MySQL Server version 6.0 or above");
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "drop table if exists inexistant");
+  check_mysql_rc(rc, mysql);
+
+  FAIL_UNLESS(mysql_warning_count(mysql) == 1, "");
+  query_int_variable(mysql, "@@warning_count", &warning_count);
+  FAIL_UNLESS(warning_count, "Warning expected");
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("select 1"));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(mysql_warning_count(mysql) == 0, "No warning expected");
+  query_int_variable(mysql, "@@warning_count", &warning_count);
+  FAIL_UNLESS(warning_count, "warning expected");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(mysql_warning_count(mysql) == 0, "No warning expected");
+  mysql_stmt_close(stmt);
+
+  query_int_variable(mysql, "@@warning_count", &warning_count);
+  FAIL_UNLESS(warning_count, "Warning expected");
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("drop table if exists inexistant"));
+  check_stmt_rc(rc, stmt);
+
+  query_int_variable(mysql, "@@warning_count", &warning_count);
+  FAIL_UNLESS(warning_count == 0, "No warning expected");
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_bug3796(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  const char *concat_arg0= "concat_with_";
+  enum { OUT_BUFF_SIZE= 30 };
+  char out_buff[OUT_BUFF_SIZE];
+  char canonical_buff[OUT_BUFF_SIZE];
+  ulong out_length;
+  const char *stmt_text;
+  int rc;
+
+
+  /* Create and fill test table */
+  stmt_text= "DROP TABLE IF EXISTS t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "CREATE TABLE t1 (a INT, b VARCHAR(30))";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "INSERT INTO t1 VALUES(1, 'ONE'), (2, 'TWO')";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  /* Create statement handle and prepare it with select */
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "SELECT concat(?, b) FROM t1";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  /* Bind input buffers */
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *) concat_arg0;
+  my_bind[0].buffer_length= (unsigned long)strlen(concat_arg0);
+
+  mysql_stmt_bind_param(stmt, my_bind);
+
+  /* Execute the select statement */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  my_bind[0].buffer= (void *) out_buff;
+  my_bind[0].buffer_length= OUT_BUFF_SIZE;
+  my_bind[0].length= &out_length;
+
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  strcpy(canonical_buff, concat_arg0);
+  strcat(canonical_buff, "ONE");
+  FAIL_UNLESS(strlen(canonical_buff) == out_length &&
+         strncmp(out_buff, canonical_buff, out_length) == 0, "");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  strcpy(canonical_buff + strlen(concat_arg0), "TWO");
+  FAIL_UNLESS(strlen(canonical_buff) == out_length &&
+         strncmp(out_buff, canonical_buff, out_length) == 0, "");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+
+  stmt_text= "DROP TABLE IF EXISTS t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_bug4026(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[2];
+  MYSQL_TIME time_in, time_out;
+  MYSQL_TIME datetime_in, datetime_out;
+  const char *stmt_text;
+  int rc;
+
+
+  /* Check that microseconds are inserted and selected successfully */
+
+  /* Create a statement handle and prepare it with select */
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "SELECT ?, ?";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  /* Bind input buffers */
+  memset(my_bind, '\0', sizeof(MYSQL_BIND) * 2);
+  memset(&time_in, '\0', sizeof(MYSQL_TIME));
+  memset(&time_out, '\0', sizeof(MYSQL_TIME));
+  memset(&datetime_in, '\0', sizeof(MYSQL_TIME));
+  memset(&datetime_out, '\0', sizeof(MYSQL_TIME));
+  my_bind[0].buffer_type= MYSQL_TYPE_TIME;
+  my_bind[0].buffer= (void *) &time_in;
+  my_bind[1].buffer_type= MYSQL_TYPE_DATETIME;
+  my_bind[1].buffer= (void *) &datetime_in;
+
+  time_in.hour= 23;
+  time_in.minute= 59;
+  time_in.second= 59;
+  time_in.second_part= 123456;
+  /*
+    This is not necessary, just to make DIE_UNLESS below work: this field
+    is filled in when time is received from server
+  */
+  time_in.time_type= MYSQL_TIMESTAMP_TIME;
+
+  datetime_in= time_in;
+  datetime_in.year= 2003;
+  datetime_in.month= 12;
+  datetime_in.day= 31;
+  datetime_in.time_type= MYSQL_TIMESTAMP_DATETIME;
+
+  mysql_stmt_bind_param(stmt, my_bind);
+
+  /* Execute the select statement */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  my_bind[0].buffer= (void *) &time_out;
+  my_bind[1].buffer= (void *) &datetime_out;
+
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == 0, "rc != 0");
+  FAIL_UNLESS(memcmp(&time_in, &time_out, sizeof(time_in)) == 0, "time_in != time_out");
+  FAIL_UNLESS(memcmp(&datetime_in, &datetime_out, sizeof(datetime_in)) == 0, "datetime_in != datetime_out");
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_bug4030(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[3];
+  MYSQL_TIME time_canonical, time_out;
+  MYSQL_TIME date_canonical, date_out;
+  MYSQL_TIME datetime_canonical, datetime_out;
+  const char *stmt_text;
+  int rc;
+
+
+  /* Check that microseconds are inserted and selected successfully */
+
+  /* Execute a query with time values in prepared mode */
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "SELECT '23:59:59.123456', '2003-12-31', "
+             "'2003-12-31 23:59:59.123456'";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  /* Bind output buffers */
+  memset(my_bind, '\0', sizeof(my_bind));
+  memset(&time_canonical, '\0', sizeof(time_canonical));
+  memset(&time_out, '\0', sizeof(time_out));
+  memset(&date_canonical, '\0', sizeof(date_canonical));
+  memset(&date_out, '\0', sizeof(date_out));
+  memset(&datetime_canonical, '\0', sizeof(datetime_canonical));
+  memset(&datetime_out, '\0', sizeof(datetime_out));
+  my_bind[0].buffer_type= MYSQL_TYPE_TIME;
+  my_bind[0].buffer= (void *) &time_out;
+  my_bind[1].buffer_type= MYSQL_TYPE_DATE;
+  my_bind[1].buffer= (void *) &date_out;
+  my_bind[2].buffer_type= MYSQL_TYPE_DATETIME;
+  my_bind[2].buffer= (void *) &datetime_out;
+
+  time_canonical.hour= 23;
+  time_canonical.minute= 59;
+  time_canonical.second= 59;
+  time_canonical.second_part= 123456;
+  time_canonical.time_type= MYSQL_TIMESTAMP_TIME;
+
+  date_canonical.year= 2003;
+  date_canonical.month= 12;
+  date_canonical.day= 31;
+  date_canonical.time_type= MYSQL_TIMESTAMP_DATE;
+
+  datetime_canonical= time_canonical;
+  datetime_canonical.year= 2003;
+  datetime_canonical.month= 12;
+  datetime_canonical.day= 31;
+  datetime_canonical.time_type= MYSQL_TIMESTAMP_DATETIME;
+
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == 0, "rc != 0");
+  FAIL_UNLESS(memcmp(&time_canonical, &time_out, sizeof(time_out)) == 0, "time_canonical != time_out");
+  FAIL_UNLESS(memcmp(&date_canonical, &date_out, sizeof(date_out)) == 0, "date_canoncical != date_out");
+  FAIL_UNLESS(memcmp(&datetime_canonical, &datetime_out, sizeof(datetime_out)) == 0, "datetime_canonical != datetime_out");
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_bug4079(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  const char *stmt_text;
+  uint32 res;
+  int rc;
+
+  /* Create and fill table */
+  mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  mysql_query(mysql, "INSERT INTO t1 VALUES (1), (2)");
+
+  /* Prepare erroneous statement */
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "SELECT 1 < (SELECT a FROM t1)";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  /* Execute the select statement */
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  /* Bind input buffers */
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *) &res;
+
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == 1, "rc != 1");
+  /* buggy version of libmysql hanged up here */
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_bug4172(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[3];
+  const char *stmt_text;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  int rc;
+  char f[100], d[100], e[100];
+  ulong f_len, d_len, e_len;
+
+  mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  mysql_query(mysql, "CREATE TABLE t1 (f float, d double, e decimal(10,4))");
+  mysql_query(mysql, "INSERT INTO t1 VALUES (12345.1234, 123456.123456, "
+                                            "123456.1234)");
+
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "SELECT f, d, e FROM t1";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  memset(my_bind, '\0', sizeof(my_bind));  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= f;
+  my_bind[0].buffer_length= sizeof(f);
+  my_bind[0].length= &f_len;
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= d;
+  my_bind[1].buffer_length= sizeof(d);
+  my_bind[1].length= &d_len;
+  my_bind[2].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[2].buffer= e;
+  my_bind[2].buffer_length= sizeof(e);
+  my_bind[2].length= &e_len;
+
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  mysql_stmt_store_result(stmt);
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+
+  diag("expected %s %s %s", row[0], row[1], row[2]);
+  diag("fetched %s %s %s", f, d, e);
+  FAIL_UNLESS(!strcmp(f, row[0]) && !strcmp(d, row[1]) && !strcmp(e, row[2]), "");
+
+  mysql_free_result(res);
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_bug4231(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[2];
+  MYSQL_TIME tm[2];
+  const char *stmt_text;
+  int rc;
+
+
+  stmt_text= "DROP TABLE IF EXISTS t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "CREATE TABLE t1 (a int)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "INSERT INTO t1 VALUES (1)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "SELECT a FROM t1 WHERE ? = ?";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  /* Bind input buffers */
+  memset(my_bind, '\0', sizeof(my_bind));  memset(tm, '\0', sizeof(tm));
+  my_bind[0].buffer_type= MYSQL_TYPE_DATE;
+  my_bind[0].buffer= &tm[0];
+  my_bind[1].buffer_type= MYSQL_TYPE_DATE;
+  my_bind[1].buffer= &tm[1];
+
+  mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+  /*
+    First set server-side params to some non-zero non-equal values:
+    then we will check that they are not used when client sends
+    new (zero) times.
+  */
+  tm[0].time_type = MYSQL_TIMESTAMP_DATE;
+  tm[0].year = 2000;
+  tm[0].month = 1;
+  tm[0].day = 1;
+  tm[1]= tm[0];
+  --tm[1].year;                                 /* tm[0] != tm[1] */
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_fetch(stmt);
+
+  /* binds are unequal, no rows should be returned */
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  /* Set one of the dates to zero */
+  tm[0].year= tm[0].month= tm[0].day= 0;
+  tm[1]= tm[0];
+  mysql_stmt_execute(stmt);
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == 0, "rc != 0");
+
+  mysql_stmt_close(stmt);
+  stmt_text= "DROP TABLE t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_bug4236(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt, *stmt1;
+  const char *stmt_text;
+  int rc;
+  MYSQL_STMT backup;
+  MYSQL      *mysql1;
+
+
+  stmt= mysql_stmt_init(mysql);
+
+  /* mysql_stmt_execute() of statement with statement id= 0 crashed server */
+  stmt_text= "SELECT 1";
+  /* We need to prepare statement to pass by possible check in libmysql */
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);  /* Hack to check that server works OK if statement wasn't found */
+  backup.stmt_id= stmt->stmt_id;
+  stmt->stmt_id= 0;
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(!rc, "Error expected");
+
+  /* lets try to hack with a new connection */
+  mysql1= test_connect(NULL);
+  stmt1= mysql_stmt_init(mysql1);
+  stmt_text= "SELECT 2";
+  rc= mysql_stmt_prepare(stmt1, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+
+  stmt->stmt_id= stmt1->stmt_id;
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(!rc, "Error expected");
+
+  mysql_stmt_close(stmt1);
+  mysql_close(mysql1);
+
+  /* Restore original statement id to be able to reprepare it */
+  stmt->stmt_id= backup.stmt_id;
+
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_bug5126(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[2];
+  int32 c1, c2;
+  const char *stmt_text;
+  int rc;
+
+
+  stmt_text= "DROP TABLE IF EXISTS t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "CREATE TABLE t1 (a mediumint, b int)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "INSERT INTO t1 VALUES (8386608, 1)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "SELECT a, b FROM t1";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  /* Bind output buffers */
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= &c1;
+  my_bind[1].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[1].buffer= &c2;
+
+  mysql_stmt_bind_result(stmt, my_bind);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == 0, "rc != 0");
+  FAIL_UNLESS(c1 == 8386608 && c2 == 1, "c1 != 8386608 || c2 != 1");
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_bug5194(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND *my_bind;
+  char *query;
+  char *param_str;
+  int param_str_length;
+  const char *stmt_text;
+  int rc;
+  float float_array[250] =
+  {
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,
+    0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25,  0.25
+  };
+  float *fa_ptr= float_array;
+  /* Number of columns per row */
+  const int COLUMN_COUNT= sizeof(float_array)/sizeof(*float_array);
+  /* Number of rows per bulk insert to start with */
+  const int MIN_ROWS_PER_INSERT= 262;
+  /* Max number of rows per bulk insert to end with */
+  const int MAX_ROWS_PER_INSERT= 300;
+  const int MAX_PARAM_COUNT= COLUMN_COUNT*MAX_ROWS_PER_INSERT;
+  const char *query_template= "insert into t1 values %s";
+  const int CHARS_PER_PARAM= 5; /* space needed to place ", ?" in the query */
+  const int uint16_max= 65535;
+  int nrows, i;
+
+  SKIP_MAXSCALE;
+
+  stmt_text= "drop table if exists t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+
+  stmt_text= "create table if not exists t1"
+   "(c1 float, c2 float, c3 float, c4 float, c5 float, c6 float, "
+   "c7 float, c8 float, c9 float, c10 float, c11 float, c12 float, "
+   "c13 float, c14 float, c15 float, c16 float, c17 float, c18 float, "
+   "c19 float, c20 float, c21 float, c22 float, c23 float, c24 float, "
+   "c25 float, c26 float, c27 float, c28 float, c29 float, c30 float, "
+   "c31 float, c32 float, c33 float, c34 float, c35 float, c36 float, "
+   "c37 float, c38 float, c39 float, c40 float, c41 float, c42 float, "
+   "c43 float, c44 float, c45 float, c46 float, c47 float, c48 float, "
+   "c49 float, c50 float, c51 float, c52 float, c53 float, c54 float, "
+   "c55 float, c56 float, c57 float, c58 float, c59 float, c60 float, "
+   "c61 float, c62 float, c63 float, c64 float, c65 float, c66 float, "
+   "c67 float, c68 float, c69 float, c70 float, c71 float, c72 float, "
+   "c73 float, c74 float, c75 float, c76 float, c77 float, c78 float, "
+   "c79 float, c80 float, c81 float, c82 float, c83 float, c84 float, "
+   "c85 float, c86 float, c87 float, c88 float, c89 float, c90 float, "
+   "c91 float, c92 float, c93 float, c94 float, c95 float, c96 float, "
+   "c97 float, c98 float, c99 float, c100 float, c101 float, c102 float, "
+   "c103 float, c104 float, c105 float, c106 float, c107 float, c108 float, "
+   "c109 float, c110 float, c111 float, c112 float, c113 float, c114 float, "
+   "c115 float, c116 float, c117 float, c118 float, c119 float, c120 float, "
+   "c121 float, c122 float, c123 float, c124 float, c125 float, c126 float, "
+   "c127 float, c128 float, c129 float, c130 float, c131 float, c132 float, "
+   "c133 float, c134 float, c135 float, c136 float, c137 float, c138 float, "
+   "c139 float, c140 float, c141 float, c142 float, c143 float, c144 float, "
+   "c145 float, c146 float, c147 float, c148 float, c149 float, c150 float, "
+   "c151 float, c152 float, c153 float, c154 float, c155 float, c156 float, "
+   "c157 float, c158 float, c159 float, c160 float, c161 float, c162 float, "
+   "c163 float, c164 float, c165 float, c166 float, c167 float, c168 float, "
+   "c169 float, c170 float, c171 float, c172 float, c173 float, c174 float, "
+   "c175 float, c176 float, c177 float, c178 float, c179 float, c180 float, "
+   "c181 float, c182 float, c183 float, c184 float, c185 float, c186 float, "
+   "c187 float, c188 float, c189 float, c190 float, c191 float, c192 float, "
+   "c193 float, c194 float, c195 float, c196 float, c197 float, c198 float, "
+   "c199 float, c200 float, c201 float, c202 float, c203 float, c204 float, "
+   "c205 float, c206 float, c207 float, c208 float, c209 float, c210 float, "
+   "c211 float, c212 float, c213 float, c214 float, c215 float, c216 float, "
+   "c217 float, c218 float, c219 float, c220 float, c221 float, c222 float, "
+   "c223 float, c224 float, c225 float, c226 float, c227 float, c228 float, "
+   "c229 float, c230 float, c231 float, c232 float, c233 float, c234 float, "
+   "c235 float, c236 float, c237 float, c238 float, c239 float, c240 float, "
+   "c241 float, c242 float, c243 float, c244 float, c245 float, c246 float, "
+   "c247 float, c248 float, c249 float, c250 float)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  my_bind= (MYSQL_BIND*) malloc(MAX_PARAM_COUNT * sizeof(MYSQL_BIND));
+  query= (char*) malloc(strlen(query_template) +
+                        MAX_PARAM_COUNT * CHARS_PER_PARAM + 1);
+  param_str= (char*) malloc(COLUMN_COUNT * CHARS_PER_PARAM);
+
+  FAIL_IF(my_bind == 0 || query == 0 || param_str == 0, "Not enough memory");
+
+  stmt= mysql_stmt_init(mysql);
+
+  /* setup a template for one row of parameters */
+  sprintf(param_str, "(");
+  for (i= 1; i < COLUMN_COUNT; ++i)
+    strcat(param_str, "?, ");
+  strcat(param_str, "?)");
+  param_str_length= (int)strlen(param_str);
+
+  /* setup bind array */
+  memset(my_bind, '\0', MAX_PARAM_COUNT * sizeof(MYSQL_BIND));
+  for (i= 0; i < MAX_PARAM_COUNT; ++i)
+  {
+    my_bind[i].buffer_type= MYSQL_TYPE_FLOAT;
+    my_bind[i].buffer= fa_ptr;
+    if (++fa_ptr == float_array + COLUMN_COUNT)
+      fa_ptr= float_array;
+  }
+
+  /*
+    Test each number of rows per bulk insert, so that we can see where
+    MySQL fails.
+  */
+  for (nrows= MIN_ROWS_PER_INSERT; nrows <= MAX_ROWS_PER_INSERT; ++nrows)
+  {
+    char *query_ptr;
+    /* Create statement text for current number of rows */
+    sprintf(query, query_template, param_str);
+    query_ptr= query + (unsigned long)strlen(query);
+    for (i= 1; i < nrows; ++i)
+    {
+      memcpy(query_ptr, ", ", 2);
+      query_ptr+= 2;
+      memcpy(query_ptr, param_str, param_str_length);
+      query_ptr+= param_str_length;
+    }
+    *query_ptr= '\0';
+
+    rc= mysql_stmt_prepare(stmt, query, (ulong)(query_ptr - query));
+
+    if (rc && nrows * COLUMN_COUNT > uint16_max) /* expected error */
+      break;
+
+    check_stmt_rc(rc, stmt);
+
+    /* bind the parameter array and execute the query */
+    rc= mysql_stmt_bind_param(stmt, my_bind);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_reset(stmt);
+  }
+
+  free(param_str);
+  free(query);
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+  free(my_bind);
+  stmt_text= "drop table t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_bug5315(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  const char *stmt_text;
+  int rc;
+  SKIP_MAXSCALE;
+
+  if (!is_mariadb)
+    return SKIP;
+
+  stmt_text= "SELECT 1";
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_change_user(mysql, username, password, schema);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_execute(stmt);
+  FAIL_UNLESS(rc != 0, "Error expected");
+
+  rc= mysql_stmt_close(stmt);
+  check_stmt_rc(rc, stmt);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_bug5399(MYSQL *mysql)
+{
+  /*
+    Ascii 97 is 'a', which gets mapped to Ascii 65 'A' unless internal
+    statement id hash in the server uses binary collation.
+  */
+#define NUM_OF_USED_STMT 97
+  MYSQL_STMT *stmt_list[NUM_OF_USED_STMT];
+  MYSQL_STMT **stmt;
+  MYSQL_BIND my_bind[1];
+  char buff[600];
+  int rc;
+  int32 no;
+
+
+  memset(my_bind, '\0', sizeof(my_bind));  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= &no;
+
+  for (stmt= stmt_list; stmt != stmt_list + NUM_OF_USED_STMT; ++stmt)
+  {
+    sprintf(buff, "select %d", (int) (stmt - stmt_list));
+    *stmt= mysql_stmt_init(mysql);
+    rc= mysql_stmt_prepare(*stmt, SL(buff));
+    check_stmt_rc(rc, *stmt);    mysql_stmt_bind_result(*stmt, my_bind);
+  }
+
+  for (stmt= stmt_list; stmt != stmt_list + NUM_OF_USED_STMT; ++stmt)
+  {
+    rc= mysql_stmt_execute(*stmt);
+    check_stmt_rc(rc, *stmt);
+    rc= mysql_stmt_store_result(*stmt);
+    check_stmt_rc(rc, *stmt);
+    rc= mysql_stmt_fetch(*stmt);
+    FAIL_UNLESS((int32) (stmt - stmt_list) == no, "");
+  }
+
+  for (stmt= stmt_list; stmt != stmt_list + NUM_OF_USED_STMT; ++stmt)
+    mysql_stmt_close(*stmt);
+#undef NUM_OF_USED_STMT
+  return OK;
+}
+
+static int test_bug6046(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  const char *stmt_text;
+  int rc;
+  short b= 1;
+  MYSQL_BIND my_bind[1];
+
+
+  stmt_text= "DROP TABLE IF EXISTS t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "CREATE TABLE t1 (a int, b int)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "INSERT INTO t1 VALUES (1,1),(2,2),(3,1),(4,2)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+
+  stmt_text= "SELECT t1.a FROM t1 NATURAL JOIN t1 as X1 "
+             "WHERE t1.b > ? ORDER BY t1.a";
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  b= 1;
+  memset(my_bind, '\0', sizeof(my_bind));  my_bind[0].buffer= &b;
+  my_bind[0].buffer_type= MYSQL_TYPE_SHORT;
+
+  mysql_stmt_bind_param(stmt, my_bind);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_store_result(stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_bug6049(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  const char *stmt_text;
+  char buffer[30];
+  ulong length;
+  int rc;
+
+
+  stmt_text= "SELECT MAKETIME(-25, 12, 12)";
+
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type    = MYSQL_TYPE_STRING;
+  my_bind[0].buffer         = &buffer;
+  my_bind[0].buffer_length  = sizeof(buffer);
+  my_bind[0].length         = &length;
+
+  mysql_stmt_bind_result(stmt, my_bind);
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(strcmp(row[0], (char*) buffer) == 0, "row[0] != buffer");
+
+  mysql_free_result(res);
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_bug6058(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  const char *stmt_text;
+  char buffer[30];
+  ulong length;
+  int rc;
+
+
+  stmt_text= "SELECT CAST('0000-00-00' AS DATE)";
+
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type    = MYSQL_TYPE_STRING;
+  my_bind[0].buffer         = &buffer;
+  my_bind[0].buffer_length  = sizeof(buffer);
+  my_bind[0].length         = &length;
+
+  mysql_stmt_bind_result(stmt, my_bind);
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(strcmp(row[0], buffer) == 0, "row[0] != buffer");
+
+  mysql_free_result(res);
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+
+static int test_bug6059(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  const char *stmt_text;
+  int rc;
+
+  SKIP_SKYSQL;
+
+  stmt_text= "SELECT 'foo' INTO OUTFILE 'x.3'";
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(mysql_stmt_field_count(stmt) == 0, "");
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_bug6096(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_RES *query_result, *stmt_metadata;
+  const char *stmt_text;
+  MYSQL_BIND my_bind[12];
+  MYSQL_FIELD *query_field_list, *stmt_field_list;
+  ulong query_field_count, stmt_field_count;
+  int rc;
+  my_bool update_max_length= TRUE;
+  uint i;
+
+
+  stmt_text= "drop table if exists t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  mysql_query(mysql, "set sql_mode=''");
+  stmt_text= "create table t1 (c_tinyint tinyint, c_smallint smallint, "
+                             " c_mediumint mediumint, c_int int, "
+                             " c_bigint bigint, c_float float, "
+                             " c_double double, c_varchar varchar(20), "
+                             " c_char char(20), c_time time, c_date date, "
+                             " c_datetime datetime)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "insert into t1  values (-100, -20000, 30000000, 4, 8, 1.0, "
+                                     "2.0, 'abc', 'def', now(), now(), now())";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "select * from t1";
+
+  /* Run select in prepared and non-prepared mode and compare metadata */
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  query_result= mysql_store_result(mysql);
+  query_field_list= mysql_fetch_fields(query_result);
+  FAIL_IF(!query_field_list, "fetch_fields failed");
+  query_field_count= mysql_num_fields(query_result);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);  mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH,
+                      (void*) &update_max_length);
+  mysql_stmt_store_result(stmt);
+  stmt_metadata= mysql_stmt_result_metadata(stmt);
+  stmt_field_list= mysql_fetch_fields(stmt_metadata);
+  stmt_field_count= mysql_num_fields(stmt_metadata);
+  FAIL_UNLESS(stmt_field_count == query_field_count, "");
+
+
+  /* Bind and fetch the data */
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  for (i= 0; i < stmt_field_count; ++i)
+  {
+    my_bind[i].buffer_type= MYSQL_TYPE_STRING;
+    my_bind[i].buffer_length= stmt_field_list[i].max_length + 1;
+    my_bind[i].buffer= malloc(my_bind[i].buffer_length);
+  }
+  mysql_stmt_bind_result(stmt, my_bind);
+  rc= mysql_stmt_fetch(stmt);
+  diag("rc=%d", rc);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  /* Clean up */
+
+  for (i= 0; i < stmt_field_count; ++i)
+    free(my_bind[i].buffer);
+  mysql_stmt_close(stmt);
+  mysql_free_result(query_result);
+  mysql_free_result(stmt_metadata);
+  stmt_text= "drop table t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Bug#7990 - mysql_stmt_close doesn't reset mysql->net.last_error */
+
+static int test_bug7990(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, "foo", 3);
+  /*
+    XXX: the fact that we store errno both in STMT and in
+    MYSQL is not documented and is subject to change in 5.0
+  */
+  FAIL_UNLESS(rc && mysql_stmt_errno(stmt) && mysql_errno(mysql), "Error expected");
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+/* Bug#8330 - mysql_stmt_execute crashes (libmysql) */
+
+static int test_bug8330(MYSQL *mysql)
+{
+  const char *stmt_text;
+  MYSQL_STMT *stmt[2];
+  int i, rc;
+  const char *query= "select a,b from t1 where a=?";
+  MYSQL_BIND my_bind[2];
+  long lval[2]= {1,2};
+
+  stmt_text= "drop table if exists t1";
+  /* in case some previous test failed */
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "create table t1 (a int, b int)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  for (i=0; i < 2; i++)
+  {
+    stmt[i]= mysql_stmt_init(mysql);
+    rc= mysql_stmt_prepare(stmt[i], SL(query));
+    check_stmt_rc(rc, stmt[i]);
+    my_bind[i].buffer_type= MYSQL_TYPE_LONG;
+    my_bind[i].buffer= (void*) &lval[i];
+    my_bind[i].is_null= 0;
+    mysql_stmt_bind_param(stmt[i], &my_bind[i]);
+  }
+
+  rc= mysql_stmt_execute(stmt[0]);
+  check_stmt_rc(rc, stmt[0]);
+  rc= mysql_stmt_execute(stmt[1]);
+  FAIL_UNLESS(rc && mysql_stmt_errno(stmt[1]) == CR_COMMANDS_OUT_OF_SYNC, "Error expected");
+  rc= mysql_stmt_execute(stmt[0]);
+  check_stmt_rc(rc, stmt[0]);
+  mysql_stmt_close(stmt[0]);
+  mysql_stmt_close(stmt[1]);
+
+  stmt_text= "drop table t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test misc field information, bug: #74 */
+
+static int test_field_misc(MYSQL *mysql)
+{
+  MYSQL_STMT  *stmt;
+  MYSQL_RES   *result;
+  int         rc;
+
+
+  rc= mysql_query(mysql, "SELECT @@autocommit");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+
+  verify_prepare_field(result, 0,
+                       "@@autocommit", "",  /* field and its org name */
+                       MYSQL_TYPE_LONGLONG, /* field type */
+                       "", "",              /* table and its org name */
+                       "", 1, 0);           /* db name, length(its bool flag)*/
+
+  mysql_free_result(result);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT @@autocommit"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  result= mysql_stmt_result_metadata(stmt);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+
+  verify_prepare_field(result, 0,
+                       "@@autocommit", "",  /* field and its org name */
+                       MYSQL_TYPE_LONGLONG, /* field type */
+                       "", "",              /* table and its org name */
+                       "", 1, 0);           /* db name, length(its bool flag)*/
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT @@max_error_count"));
+  check_stmt_rc(rc, stmt);
+
+  result= mysql_stmt_result_metadata(stmt);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+
+  if (verify_prepare_field(result, 0,
+                       "@@max_error_count", "",   /* field and its org name */
+                       MYSQL_TYPE_LONGLONG, /* field type */
+                       "", "",              /* table and its org name */
+                       /* db name, length */
+                       "", MY_INT64_NUM_DECIMAL_DIGITS , 0))
+    goto error;
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT @@max_allowed_packet"));
+  check_stmt_rc(rc, stmt);
+
+  result= mysql_stmt_result_metadata(stmt);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+
+  if (verify_prepare_field(result, 0,
+                       "@@max_allowed_packet", "", /* field and its org name */
+                       MYSQL_TYPE_LONGLONG, /* field type */
+                       "", "",              /* table and its org name */
+                       /* db name, length */
+                       "", MY_INT64_NUM_DECIMAL_DIGITS, 0))
+    goto error;
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT @@sql_warnings"));
+  check_stmt_rc(rc, stmt);
+
+  result= mysql_stmt_result_metadata(stmt);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+
+  if (verify_prepare_field(result, 0,
+                       "@@sql_warnings", "",  /* field and its org name */
+                       MYSQL_TYPE_LONGLONG,   /* field type */
+                       "", "",                /* table and its org name */
+                       "", 1, 0))             /* db name, length */
+    goto error;
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+  return OK;
+
+error:
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+  return FAIL;
+}
+
+/* Test a memory ovverun bug */
+
+static int test_mem_overun(MYSQL *mysql)
+{
+  char       buffer[10000], field[12];
+  MYSQL_STMT *stmt;
+  MYSQL_RES  *field_res, *res;
+  int        rc, i, length;
+
+  /*
+    Test a memory ovverun bug when a table had 1000 fields with
+    a row of data
+  */
+  rc= mysql_query(mysql, "drop table if exists t_mem_overun");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(buffer, "create table t_mem_overun(");
+  for (i= 0; i < 1000; i++)
+  {
+    sprintf(field, "c%d int, ", i);
+    strcat(buffer, field);
+  }
+  length= (int)strlen(buffer);
+  buffer[length-2]= ')';
+  buffer[--length]= '\0';
+
+  rc= mysql_real_query(mysql, buffer, length);
+  check_mysql_rc(rc, mysql);
+
+  strcpy(buffer, "insert into t_mem_overun values(");
+  for (i= 0; i < 1000; i++)
+  {
+    strcat(buffer, "1, ");
+  }
+  length= (int)strlen(buffer);
+  buffer[length-2]= ')';
+  buffer[--length]= '\0';
+
+  rc= mysql_real_query(mysql, buffer, length);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "select * from t_mem_overun");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  rc= 0;
+  while (mysql_fetch_row(res))
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+  mysql_free_result(res);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("select * from t_mem_overun"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  field_res= mysql_stmt_result_metadata(stmt);
+  FAIL_IF(!field_res, "Invalid result set");
+
+  FAIL_UNLESS( 1000 == mysql_num_fields(field_res), "fields != 1000");
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "");
+
+  mysql_free_result(field_res);
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table if exists t_mem_overun");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_bug8722(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *stmt_text;
+
+  /* Prepare test data */
+  stmt_text= "drop table if exists t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "drop view if exists v1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "CREATE TABLE t1 (c1 varchar(10), c2 varchar(10), c3 varchar(10),"
+                             " c4 varchar(10), c5 varchar(10), c6 varchar(10),"
+                             " c7 varchar(10), c8 varchar(10), c9 varchar(10),"
+                             "c10 varchar(10))";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,9,10)";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+  stmt_text= "CREATE VIEW v1 AS SELECT * FROM t1";
+  rc= mysql_real_query(mysql, SL(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  stmt_text= "select * from v1";
+  rc= mysql_stmt_prepare(stmt, SL(stmt_text));
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+  stmt_text= "drop table if exists t1, v1";
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW v1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test DECIMAL conversion */
+
+static int test_decimal_bug(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  char       data[30];
+  int        rc;
+  my_bool    is_null;
+
+  mysql_autocommit(mysql, TRUE);
+
+  rc= mysql_query(mysql, "drop table if exists test_decimal_bug");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table test_decimal_bug(c1 decimal(10, 2))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into test_decimal_bug value(8), (10.22), (5.61)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("select c1 from test_decimal_bug where c1=?"));
+  check_stmt_rc(rc, stmt);
+
+  /*
+    We need to bzero bind structure because mysql_stmt_bind_param checks all
+    its members.
+  */
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  memset(data, 0, sizeof(data));
+  my_bind[0].buffer_type= MYSQL_TYPE_NEWDECIMAL;
+  my_bind[0].buffer= (void *)data;
+  my_bind[0].buffer_length= 25;
+  my_bind[0].is_null= &is_null;
+
+  is_null= 0;
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  strcpy(data, "8.0");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  data[0]= 0;
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(strcmp(data, "8.00") == 0, "data != '8.00'");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  strcpy(data, "5.61");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  data[0]= 0;
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(strcmp(data, "5.61") == 0, "data != '5.61'");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  is_null= 1;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  strcpy(data, "10.22"); is_null= 0;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  data[0]= 0;
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(strcmp(data, "10.22") == 0, "data != '10.22'");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop table if exists test_decimal_bug");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test EXPLAIN bug (#115, reported by mark@mysql.com & georg@php.net). */
+
+static int test_explain_bug(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_RES  *result;
+  int        rc;
+
+  if (!is_mariadb)
+    return SKIP;
+
+  mysql_autocommit(mysql, TRUE);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_explain");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_explain(id int, name char(2))");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("explain test_explain"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (!mysql_stmt_fetch(stmt))
+    rc++;
+  FAIL_UNLESS(rc == 2, "rowcount != 2");
+
+  result= mysql_stmt_result_metadata(stmt);
+  FAIL_IF(!result, "Invalid result set");
+
+  FAIL_UNLESS(6 == mysql_num_fields(result), "fields != 6");
+
+  if (verify_prepare_field(result, 0, "Field", "COLUMN_NAME",
+                       mysql_get_server_version(mysql) <= 50000 ?
+                       MYSQL_TYPE_STRING : MYSQL_TYPE_VAR_STRING,
+                       0, 0,
+                       mysql_get_server_version(mysql) <= 50400 ? "" : "information_schema",
+                       64, 0))
+    goto error;
+
+  if (verify_prepare_field(result, 1, "Type", "COLUMN_TYPE", MYSQL_TYPE_BLOB,
+                       0, 0,
+                       mysql_get_server_version(mysql) <= 50400 ? "" : "information_schema",
+                       0, 0))
+    goto error;
+
+  if (verify_prepare_field(result, 2, "Null", "IS_NULLABLE",
+                       mysql_get_server_version(mysql) <= 50000 ?
+                       MYSQL_TYPE_STRING : MYSQL_TYPE_VAR_STRING,
+                       0, 0,
+                       mysql_get_server_version(mysql) <= 50400 ? "" : "information_schema",
+                       3, 0))
+    goto error;
+
+  if (verify_prepare_field(result, 3, "Key", "COLUMN_KEY",
+                       mysql_get_server_version(mysql) <= 50000 ?
+                       MYSQL_TYPE_STRING : MYSQL_TYPE_VAR_STRING,
+                       0, 0,
+                       mysql_get_server_version(mysql) <= 50400 ? "" : "information_schema",
+                       3, 0))
+    goto error;
+
+  if ( mysql_get_server_version(mysql) >= 50027 )
+  {
+    /*  The patch for bug#23037 changes column type of DEAULT to blob */
+    if (verify_prepare_field(result, 4, "Default", "COLUMN_DEFAULT",
+                         MYSQL_TYPE_BLOB, 0, 0,
+                         mysql_get_server_version(mysql) <= 50400 ? "" : "information_schema",
+                         0, 0))
+      goto error;
+  }
+  else
+  {
+    if (verify_prepare_field(result, 4, "Default", "COLUMN_DEFAULT",
+                         mysql_get_server_version(mysql) >= 50027 ?
+                         MYSQL_TYPE_BLOB :
+                         mysql_get_server_version(mysql) <= 50000 ?
+                         MYSQL_TYPE_STRING : MYSQL_TYPE_VAR_STRING,
+                         0, 0,
+                         mysql_get_server_version(mysql) <= 50400 ? "" : "information_schema",
+                         mysql_get_server_version(mysql) >= 50027 ? 0 :64, 0))
+      goto error;
+  }
+
+  if (verify_prepare_field(result, 5, "Extra", "EXTRA",
+                       mysql_get_server_version(mysql) <= 50000 ?
+                       MYSQL_TYPE_STRING : MYSQL_TYPE_VAR_STRING,
+                       0, 0,
+                       mysql_get_server_version(mysql) <= 50400 ? "" : "information_schema",
+                       27, 0))
+    goto error;
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("explain select id, name FROM test_explain"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (!mysql_stmt_fetch(stmt))
+    rc++;
+  FAIL_UNLESS(rc == 1, "rowcount != 1");
+
+  result= mysql_stmt_result_metadata(stmt);
+  FAIL_IF(!result, "Invalid result set");
+
+  FAIL_UNLESS(10 == mysql_num_fields(result), "fields != 10");
+
+  if (verify_prepare_field(result, 0, "id", "", MYSQL_TYPE_LONGLONG, "", "", "", 3, 0))
+    goto error;
+
+  if (verify_prepare_field(result, 1, "select_type", "", MYSQL_TYPE_VAR_STRING, "", "", "", 19, 0))
+    goto error;
+
+  if (verify_prepare_field(result, 2, "table", "", MYSQL_TYPE_VAR_STRING, "", "", "", NAME_CHAR_LEN, 0))
+    goto error;
+
+  if (verify_prepare_field(result, 3, "type", "", MYSQL_TYPE_VAR_STRING, "", "", "", 10, 0))
+    goto error;
+
+  if (verify_prepare_field(result, 4, "possible_keys", "", MYSQL_TYPE_VAR_STRING, "", "", "", NAME_CHAR_LEN*MAX_KEY, 0))
+    goto error;
+
+  if ( verify_prepare_field(result, 5, "key", "", MYSQL_TYPE_VAR_STRING, "", "", "", NAME_CHAR_LEN, 0))
+    goto error;
+
+  if (mysql_get_server_version(mysql) <= 50000)
+  {
+    if (verify_prepare_field(result, 6, "key_len", "", MYSQL_TYPE_LONGLONG, "", "", "", 3, 0))
+      goto error;
+  }
+  else if (mysql_get_server_version(mysql) <= 60000)
+  {
+    if (verify_prepare_field(result, 6, "key_len", "", MYSQL_TYPE_VAR_STRING, "", "", "", NAME_CHAR_LEN*MAX_KEY, 0))
+      goto error;
+  }
+  else
+  {
+    if (verify_prepare_field(result, 6, "key_len", "", MYSQL_TYPE_VAR_STRING, "", "", "", (MAX_KEY_LENGTH_DECIMAL_WIDTH + 1) * MAX_KEY, 0))
+    goto error;
+  }
+
+  if (verify_prepare_field(result, 7, "ref", "", MYSQL_TYPE_VAR_STRING, "", "", "",
+                           NAME_CHAR_LEN*16, 0))
+    goto error;
+
+  if (verify_prepare_field(result, 8, "rows", "", MYSQL_TYPE_LONGLONG, "", "", "", 10, 0))
+    goto error;
+
+  if (verify_prepare_field(result, 9, "Extra", "", MYSQL_TYPE_VAR_STRING, "", "", "", 255, 0))
+    goto error;
+
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_explain");
+  check_mysql_rc(rc, mysql);
+  return OK;
+error:
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+  return FAIL;
+}
+
+static int test_sshort_bug(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[4];
+  short      short_value;
+  int32      long_value;
+  ulong      s_length, l_length, ll_length, t_length;
+  ulonglong  longlong_value;
+  int        rc;
+  uchar      tiny_value;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_sshort");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_sshort(a smallint signed, \
+                                                  b smallint signed, \
+                                                  c smallint unsigned, \
+                                                  d smallint unsigned)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_sshort VALUES(-5999, -5999, 35999, 200)");
+  check_mysql_rc(rc, mysql);
+
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT * FROM test_sshort"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[0].buffer= (void *)&short_value;
+  my_bind[0].length= &s_length;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[1].buffer= (void *)&long_value;
+  my_bind[1].length= &l_length;
+
+  my_bind[2].buffer_type= MYSQL_TYPE_LONGLONG;
+  my_bind[2].buffer= (void *)&longlong_value;
+  my_bind[2].length= &ll_length;
+
+  my_bind[3].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[3].buffer= (void *)&tiny_value;
+  my_bind[3].is_unsigned= TRUE;
+  my_bind[3].length= &t_length;
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(short_value == -5999, "sv != -5999");
+  FAIL_UNLESS(s_length == 2, "s_length != 2");
+
+  FAIL_UNLESS(long_value == -5999, "l_v != -5999");
+  FAIL_UNLESS(l_length == 4, "l_length != 4");
+
+  FAIL_UNLESS(longlong_value == 35999, "llv != 35999");
+  FAIL_UNLESS(ll_length == 8, "ll_length != 8");
+
+  FAIL_UNLESS(tiny_value == 200, "t_v != 200");
+  FAIL_UNLESS(t_length == 1, "t_length != 1");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_sshort");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+
+/* Test a misc tinyint-signed conversion bug */
+
+static int test_stiny_bug(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[4];
+  short      short_value;
+  int32      long_value;
+  ulong      s_length, l_length, ll_length, t_length;
+  ulonglong  longlong_value;
+  int        rc;
+  uchar      tiny_value;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_stiny");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_stiny(a tinyint signed, \
+                                                  b tinyint signed, \
+                                                  c tinyint unsigned, \
+                                                  d tinyint unsigned)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_stiny VALUES(-128, -127, 255, 0)");
+  check_mysql_rc(rc, mysql);
+
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL("SELECT * FROM test_stiny"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[0].buffer= (void *)&short_value;
+  my_bind[0].length= &s_length;
+
+  my_bind[1].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[1].buffer= (void *)&long_value;
+  my_bind[1].length= &l_length;
+
+  my_bind[2].buffer_type= MYSQL_TYPE_LONGLONG;
+  my_bind[2].buffer= (void *)&longlong_value;
+  my_bind[2].length= &ll_length;
+
+  my_bind[3].buffer_type= MYSQL_TYPE_TINY;
+  my_bind[3].buffer= (void *)&tiny_value;
+  my_bind[3].length= &t_length;
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(short_value == -128, "s_v != -128");
+  FAIL_UNLESS(s_length == 2, "s_length != 2");
+
+  FAIL_UNLESS(long_value == -127, "l_v != -127");
+  FAIL_UNLESS(l_length == 4, "l_length != 4");
+
+  FAIL_UNLESS(longlong_value == 255, "llv != 255");
+  FAIL_UNLESS(ll_length == 8, "ll_length != 8");
+
+  FAIL_UNLESS(tiny_value == 0, "t_v != 0");
+  FAIL_UNLESS(t_length == 1, "t_length != 1");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_stiny");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_bug53311(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  int i;
+  const char *query= "INSERT INTO bug53311 VALUES (1)";
+  SKIP_MAXSCALE;
+
+  rc= mysql_options(mysql, MYSQL_OPT_RECONNECT, "1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bug53311");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE bug53311 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  for (i=0; i < 2; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+  }
+
+  /* kill connection */
+  rc= mysql_kill(mysql, mysql_thread_id(mysql));
+
+  rc= mysql_stmt_execute(stmt);
+  FAIL_IF(rc == 0, "Error expected");
+  FAIL_IF(mysql_stmt_errno(stmt) == 0, "Errno != 0 expected");
+  rc= mysql_stmt_close(stmt);
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS bug53311");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+#define PREPARE_SQL "EXPLAIN SELECT t1.*, t2.* FROM test AS t1, test AS t2"
+
+#ifdef NOT_IN_USE
+static int test_metadata(MYSQL *mysql)
+{
+  int rc;
+
+	rc= mysql_query(mysql, "DROP TABLE IF EXISTS test");
+  check_mysql_rc(rc, mysql);
+	rc= mysql_query(mysql, "CREATE TABLE test(id INT, label CHAR(1), PRIMARY KEY(id)) ENGINE=MYISAM");
+  check_mysql_rc(rc, mysql);
+
+	rc= mysql_query(mysql, "INSERT INTO test(id, label) VALUES (1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')");
+  check_mysql_rc(rc, mysql);
+	printf("Client=%s\n", mysql_get_client_info());
+	printf("Server=%s\n", mysql_get_server_info(mysql));
+
+	{
+		MYSQL_STMT * stmt = mysql_stmt_init(mysql);
+		if (!stmt) {
+			fprintf(stderr, "Failed to init stmt: Error: %s\n", mysql_error(mysql));
+			goto end;
+		}
+		if (mysql_stmt_prepare(stmt, PREPARE_SQL, sizeof(PREPARE_SQL) - 1)) {
+			fprintf(stderr, "Failed to prepare stmt: Error: %s\n", mysql_stmt_error(stmt));
+			goto end2;
+		}
+		if (mysql_stmt_execute(stmt)) {
+			fprintf(stderr, "Failed to execute stmt: Error: %s\n", mysql_stmt_error(stmt));
+			goto end2;
+		}
+		{
+			MYSQL_FIELD * field = NULL;
+			MYSQL_RES * res = mysql_stmt_result_metadata(stmt);
+			if (!res) {
+				fprintf(stderr, "Failed to get metadata: Error: %s\n", mysql_stmt_error(stmt));
+				goto end2;
+			}
+			while ((field = mysql_fetch_field(res))) {
+				printf("name=%s\n", field->name);
+				printf("catalog=%s\n", field->catalog);
+			}
+			mysql_free_result(res);
+
+		}
+end2:
+		mysql_stmt_close(stmt);
+	}
+end:
+	return 0;
+}
+#endif
+
+static int test_conc_5(MYSQL *mysql)
+{
+  const char *query= "SELECT a FROM t1";
+  MYSQL_RES *res;
+  MYSQL_STMT *stmt;
+  MYSQL_FIELD *fields;
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, "couldn't allocate memory");
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  res= mysql_stmt_result_metadata(stmt);
+  FAIL_IF(!res, "Can't obtain resultset");
+
+  fields= mysql_fetch_fields(res);
+  FAIL_IF(!fields, "Can't obtain fields");
+
+  FAIL_IF(strcmp("def", fields[0].catalog), "unexpected value for field->catalog");
+
+  mysql_free_result(res);
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_conc141(MYSQL *mysql)
+{
+  int rc;
+  const char *query= "CALL p_conc141";
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc141");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE conc141 (KeyVal int not null primary key)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO conc141 VALUES(1)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p_conc141");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE PROCEDURE p_conc141()\n"
+                   "BEGIN\n"
+                     "select * from conc141;\n"
+                     "insert into conc141(KeyVal) VALUES(1);\n"
+                   "END");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  /* skip first result */
+  rc= mysql_stmt_next_result(stmt);
+  FAIL_IF(rc==-1, "No more results and error expected");
+  mysql_stmt_free_result(stmt);
+  FAIL_IF(mysql_stmt_errno(stmt), "No Error expected");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc141");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p_conc141");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_conc154(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  const char *stmtstr= "SELECT * FROM t1";
+  int rc;
+
+  /* 1st: empty result set without free_result */
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a varchar(20))");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  /* 2nd: empty result set with free_result */
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_free_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_free_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  /* 3rd: non empty result without free_result */
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES ('test_conc154')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  /* 4th non empty result set with free_result */
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_free_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_free_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_conc155(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind;
+  char buffer[50];
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a TEXT)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES ('zero terminated string')");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL("SELECT a FROM t1"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(buffer, 'X', 50);
+  memset(&bind, 0, sizeof(MYSQL_BIND));
+
+  bind.buffer= buffer;
+  bind.buffer_length= 50;
+  bind.buffer_type= MYSQL_TYPE_STRING;
+
+  rc= mysql_stmt_bind_result(stmt, &bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  if (strlen(buffer) != strlen("zero terminated string"))
+  {
+    diag("Wrong buffer length");
+    return FAIL;
+  }
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_conc168(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+
+  MYSQL_BIND bind;
+  char buffer[100];
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc168");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE conc168(a datetime(3))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO conc168 VALUES ('2016-03-09 07:51:49.000'),('2016-03-09 07:51:49.001'),('2016-03-09 07:51:49.010')");
+  check_mysql_rc(rc, mysql);
+
+  memset(&bind, 0, sizeof(MYSQL_BIND));
+  bind.buffer= buffer;
+  bind.buffer_type= MYSQL_TYPE_STRING;
+  bind.buffer_length= 100;
+
+  rc= mysql_stmt_prepare(stmt, SL("SELECT a FROM conc168"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, &bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_IF(strcmp(buffer, "2016-03-09 07:51:49.000"), "expected: 2016-03-09 07:51:49.000");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_IF(strcmp(buffer, "2016-03-09 07:51:49.001"), "expected: 2016-03-09 07:51:49.001");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_IF(strcmp(buffer, "2016-03-09 07:51:49.010"), "expected: 2016-03-09 07:51:49.010");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc168");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_conc167(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+
+  MYSQL_BIND bind[3];
+  char buffer[100];
+  int bit1=0, bit2=0;
+  int rc;
+  const char *stmt_str= "SELECT a,b,c FROM conc168";
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc168");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE conc168(a bit, b bit, c varchar(10))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO conc168 VALUES (1,0, 'test12345')");
+  check_mysql_rc(rc, mysql);
+
+  memset(bind, 0, 3 * sizeof(MYSQL_BIND));
+  bind[0].buffer= &bit1;
+  bind[0].buffer_type= MYSQL_TYPE_BIT;
+  bind[0].buffer_length= sizeof(int);
+  bind[1].buffer= &bit2;
+  bind[1].buffer_type= MYSQL_TYPE_BIT;
+  bind[1].buffer_length= sizeof(int);
+  bind[2].buffer= buffer;
+  bind[2].buffer_type= MYSQL_TYPE_STRING;
+  bind[2].buffer_length= 100;
+
+  rc= mysql_stmt_prepare(stmt, SL(stmt_str));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  diag("bit=%d %d char=%s", bit1, bit2, buffer);
+
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_conc177(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  MYSQL_BIND bind[2];
+  const char *stmt_str= "SELECT a,b FROM t1";
+  char buf1[128], buf2[128];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a double zerofill default 8.8,b float zerofill default 8.8)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (DEFAULT, DEFAULT)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmt_str));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, 2 * sizeof(MYSQL_BIND));
+  bind[0].buffer= &buf1;
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+  bind[0].buffer_length= 128;
+  bind[1].buffer= &buf2;
+  bind[1].buffer_type= MYSQL_TYPE_STRING;
+  bind[1].buffer_length= 128;
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  mysql_stmt_close(stmt);
+
+  diag("buf1 %s\nbuf2 %s", buf1, buf2);
+
+  FAIL_IF(strcmp(buf1, "00000000000000000008.8"), "Expected 00000000000000000008.8");
+  FAIL_IF(strcmp(buf2, "0000000008.8"), "Expected 0000000008.8");
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int(8) zerofill default 1, b int(4) zerofill default 1)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (DEFAULT, DEFAULT)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmt_str));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, 2 * sizeof(MYSQL_BIND));
+  bind[0].buffer= &buf1;
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+  bind[0].buffer_length= 128;
+  bind[1].buffer= &buf2;
+  bind[1].buffer_type= MYSQL_TYPE_STRING;
+  bind[1].buffer_length= 128;
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  mysql_stmt_close(stmt);
+
+  diag("buf1 %s\nbuf2 %s", buf1, buf2);
+
+  FAIL_IF(strcmp(buf1, "00000001"), "Expected 00000001");
+  FAIL_IF(strcmp(buf2, "0001"), "Expected 0001");
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_conc179(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  const char *stmtstr= "select 1 as ' '";
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  if (mysql_get_server_version(mysql) >= 100100)
+  {
+    FAIL_IF(mysql_warning_count(mysql) < 1, "expected 1 or more warnings");
+    FAIL_IF(mysql_stmt_warning_count(stmt) < 1, "expected 1 or more warnings");
+  }
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_conc182(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  MYSQL_BIND bind[2];
+  char buf1[22];
+  MYSQL_RES *result;
+  MYSQL_ROW row;
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mariadb_stmt_execute_direct(stmt, "DROP TABLE IF EXISTS t1", -1);
+  check_stmt_rc(rc, stmt);
+  rc= mariadb_stmt_execute_direct(stmt, "DROP TABLE IF EXISTS t1", -1);
+  check_stmt_rc(rc, stmt);
+  rc= mariadb_stmt_execute_direct(stmt, "SELECT 1", -1);
+  check_stmt_rc(rc, stmt);
+  rc= mariadb_stmt_execute_direct(stmt, "SELECT 1", -1);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_close(stmt);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT row_count()");
+  result= mysql_store_result(mysql);
+  row= mysql_fetch_row(result);
+  diag("buf: %s", row[0]);
+  mysql_free_result(result);
+
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, "SELECT row_count()", -1);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+
+  memset(bind, 0, 2 * sizeof(MYSQL_BIND));
+  bind[0].buffer= &buf1;
+  bind[0].buffer_length= bind[1].buffer_length= 20;
+  bind[0].buffer_type= bind[1].buffer_type= MYSQL_TYPE_STRING;
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+
+  while(!mysql_stmt_fetch(stmt))
+  diag("b1: %s", buf1);
+  rc= mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_conc181(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc;
+  MYSQL_BIND bind;
+  const char *stmt_str= "SELECT a FROM t1";
+  float f=1;
+  my_bool err= 0;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES(1073741825)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(stmt_str));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(&bind, 0, sizeof(MYSQL_BIND));
+  bind.buffer= &f;
+  bind.error= &err;
+  bind.buffer_type= MYSQL_TYPE_FLOAT;
+  rc= mysql_stmt_bind_result(stmt, &bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  diag("rc=%d err=%d float=%f, %d", rc, err, f, MYSQL_DATA_TRUNCATED);
+
+  rc= mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_conc198(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt1, *stmt2;
+  MYSQL_BIND my_bind[1];
+  int32 a;
+  int rc;
+  int num_rows= 0;
+  ulong type;
+  ulong prefetch_rows= 3;
+
+
+  mysql_query(mysql, "drop table if exists t1");
+  mysql_query(mysql, "create table t1 (id integer not null primary key)");
+  rc= mysql_query(mysql, "insert into t1 (id) values "
+                         " (1), (2), (3), (4), (5), (6), (7), (8), (9)");
+  check_mysql_rc(rc, mysql);
+
+  stmt1= mysql_stmt_init(mysql);
+  stmt2= mysql_stmt_init(mysql);
+  /* Not implemented in 5.0 */
+  type= (ulong) CURSOR_TYPE_SCROLLABLE;
+  rc= mysql_stmt_attr_set(stmt1, STMT_ATTR_CURSOR_TYPE, (void*) &type);
+  FAIL_UNLESS(rc, "Error expected");
+  rc= mysql_stmt_attr_set(stmt2, STMT_ATTR_CURSOR_TYPE, (void*) &type);
+  FAIL_UNLESS(rc, "Error expected");
+
+  type= (ulong) CURSOR_TYPE_READ_ONLY;
+  rc= mysql_stmt_attr_set(stmt1, STMT_ATTR_CURSOR_TYPE, (void*) &type);
+  check_stmt_rc(rc, stmt1);
+  rc= mysql_stmt_attr_set(stmt2, STMT_ATTR_CURSOR_TYPE, (void*) &type);
+  check_stmt_rc(rc, stmt2);
+  rc= mysql_stmt_attr_set(stmt1, STMT_ATTR_PREFETCH_ROWS,
+                          (void*) &prefetch_rows);
+  check_stmt_rc(rc, stmt1);
+  rc= mysql_stmt_attr_set(stmt2, STMT_ATTR_PREFETCH_ROWS,
+                          (void*) &prefetch_rows);
+  check_stmt_rc(rc, stmt2);
+  rc= mysql_stmt_prepare(stmt1, "SELECT * FROM t1 ORDER by id ASC" , -1);
+  check_stmt_rc(rc, stmt1);
+  rc= mysql_stmt_prepare(stmt2, "SELECT * FROM t1 ORDER by id DESC", -1);
+  check_stmt_rc(rc, stmt2);
+
+  rc= mysql_stmt_execute(stmt1);
+  check_stmt_rc(rc, stmt1);
+  rc= mysql_stmt_execute(stmt2);
+  check_stmt_rc(rc, stmt2);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void*) &a;
+  my_bind[0].buffer_length= sizeof(a);
+  mysql_stmt_bind_result(stmt1, my_bind);
+  mysql_stmt_bind_result(stmt2, my_bind);
+
+  while ((rc= mysql_stmt_fetch(stmt1)) == 0)
+    ++num_rows;
+  FAIL_UNLESS(num_rows == 9, "num_rows != 9");
+
+  num_rows= 0;
+  while ((rc= mysql_stmt_fetch(stmt2)) == 0)
+    ++num_rows;
+  FAIL_UNLESS(num_rows == 9, "num_rows != 9");
+
+  rc= mysql_stmt_close(stmt1);
+  rc= mysql_stmt_close(stmt2);
+  FAIL_UNLESS(rc == 0, "");
+
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_conc205(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[3];
+  char       data[8];
+  ulong      length[3];
+  int        rc, int_col;
+  short      smint_col;
+  my_bool    is_null[3];
+  const char *query = "SELECT text_col, smint_col, int_col FROM test_conc205";
+
+  rc= mysql_query(mysql, "drop table if exists test_conc205");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE test_conc205 (text_col TEXT, smint_col SMALLINT, int_col INT)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO test_conc205 VALUES('data01', 21893, 1718038908), ('data2', -25734, -1857802040)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)data;
+  my_bind[0].buffer_length= sizeof(data);
+  my_bind[0].is_null= &is_null[0];
+  my_bind[0].length= &length[0];
+
+  my_bind[1].buffer_type= MYSQL_TYPE_SHORT;
+  my_bind[1].buffer= &smint_col;
+  my_bind[1].buffer_length= 2;
+  my_bind[1].is_null= &is_null[1];
+  my_bind[1].length= &length[1];
+
+  my_bind[2].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[2].buffer= &int_col;
+  my_bind[2].buffer_length= 4;
+  my_bind[2].is_null= &is_null[2];
+  my_bind[2].length= &length[2];
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(length[0] != 6, "Wrong fetched string length");
+  FAIL_IF(length[1] != 2, "Wrong fetched short length");
+  FAIL_IF(length[2] != 4, "Wrong fetched int length");
+
+  FAIL_IF(strncmp(data, "data01", length[0] + 1) != 0, "Wrong string value");
+  FAIL_IF(smint_col != 21893, "Expected 21893");
+  FAIL_IF(int_col != 1718038908, "Expected 1718038908");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(length[0] != 5, "Wrong fetched string length");
+  FAIL_IF(length[1] != 2, "Wrong fetched short length");
+  FAIL_IF(length[2] != 4, "Wrong fetched int length");
+
+  FAIL_IF(strncmp(data, "data2", length[0] + 1) != 0, "Wrong string value");
+  FAIL_IF(smint_col != -25734, "Expected 21893");
+  FAIL_IF(int_col != -1857802040, "Expected 1718038908");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(rc != MYSQL_NO_DATA, "Expected MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "drop table test_conc205");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_conc217(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+
+  SKIP_MAXSCALE;
+  rc= mariadb_stmt_execute_direct(stmt, "SELECT 1 FROM nonexisting_table", -1);
+  FAIL_IF(rc==0, "Expected error\n");
+  rc= mysql_query(mysql, "drop table if exists t_count");
+  check_mysql_rc(rc, mysql);
+  mysql_stmt_close(stmt);
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_conc208(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+  int data;
+  MYSQL_BIND bind;
+
+  rc= mysql_stmt_prepare(stmt, "SELECT \"100\" UNION SELECT \"88\" UNION SELECT \"389789\"", -1);
+  check_stmt_rc(rc, stmt);
+
+  memset(&bind, 0, sizeof(MYSQL_BIND));
+  bind.buffer_type= MYSQL_TYPE_LONG;
+  bind.buffer= (void *)&data;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, &bind);
+
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+  {
+    diag("data=%d", data);
+    FAIL_IF(data != 100 && data != 88 && data != 389789, "Wrong value");
+  }
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_mdev14165(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_FIELD *fields;
+  MYSQL_RES *result;
+  my_bool val= 1;
+  MYSQL_BIND bind[1];
+  char buf1[52];
+
+  rc= mysql_options(mysql, MYSQL_REPORT_DATA_TRUNCATION, &val);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  rc= mysql_query(mysql, "CREATE TABLE t1 (i INT(20) ZEROFILL)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (2),(1)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_stmt_prepare(stmt, "SELECT i FROM t1", -1);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, sizeof(MYSQL_BIND));
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+  bind[0].buffer_length= 51;
+  bind[0].buffer= buf1;
+
+  mysql_stmt_bind_result(stmt, bind);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &val);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  result= mysql_stmt_result_metadata(stmt);
+
+  fields= mysql_fetch_fields(result);
+
+  FAIL_IF(fields[0].length < 20, "Expected length=20");
+  FAIL_IF(fields[0].max_length < 20, "Expected max_length=20");
+
+  mysql_stmt_fetch(stmt);
+
+  FAIL_UNLESS(strcmp(buf1, "00000000000000000002") == 0, "Wrong result");
+  mysql_free_result(result);
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_compress(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+
+  rc= mariadb_stmt_execute_direct(stmt, SL("SELECT 1 FROM DUAL"));
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int equal_MYSQL_TIME(MYSQL_TIME *tm1, MYSQL_TIME *tm2)
+{
+  return tm1->day==tm2->day && tm1->hour==tm2->hour && tm1->minute==tm2->minute &&
+    tm1->month==tm2->month && tm1->neg==tm2->neg && tm1->second==tm2->second &&
+    tm1->second_part==tm2->second_part && tm1->time_type==tm2->time_type && tm1->year==tm2->year;
+}
+
+static int test_str_to_int(MYSQL *mysql)
+{
+ int i;
+ struct st_atoi_test{
+    const char *str_value;
+    int int_value;
+    int rc;
+  } atoi_tests[]=
+  {
+    {"0", 0, 0},
+    {" 1",1, 0},
+    {"123 ",123, 0},
+    {"10.2",10, MYSQL_DATA_TRUNCATED},
+    {"a", 0, MYSQL_DATA_TRUNCATED},
+    {"1 2 3", 1, MYSQL_DATA_TRUNCATED},
+    {NULL, 0, 0}
+  };
+
+  for(i=0; atoi_tests[i].str_value; i++)
+  {
+    int rc;
+    MYSQL_STMT *stmt;
+    MYSQL_BIND bind[1];
+    struct st_atoi_test *test= &atoi_tests[i];
+    char sql[256];
+    int int_value;
+
+    snprintf(sql, sizeof(sql), "SELECT '%s'",test->str_value);
+
+    stmt= mysql_stmt_init(mysql);
+
+    rc= mysql_stmt_prepare(stmt, sql, (ulong)strlen(sql));
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_store_result(stmt);
+
+    memset(bind, 0, sizeof(MYSQL_BIND));
+    bind[0].buffer_type= MYSQL_TYPE_LONG;
+    bind[0].buffer= &int_value;
+    bind[0].buffer_length= sizeof(int_value);
+
+    rc= mysql_stmt_bind_result(stmt, bind);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_fetch(stmt);
+
+    diag("test: str='%s', expected/returned value =%d/%d, expected/returned rc=%d/%d",
+      test->str_value, test->int_value, int_value, test->rc, rc);
+    FAIL_UNLESS(rc == test->rc, "unexpected return code");
+    FAIL_UNLESS(int_value == test->int_value, "unexpected int value");
+    mysql_stmt_close(stmt);
+  }
+  return OK;
+}
+
+
+static int test_codbc138(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind[1];
+  MYSQL_TIME tm;
+  int i= 0;
+
+  struct st_time_test {
+    const char *statement;
+    MYSQL_TIME tm;
+  } time_test[]={
+    { "SELECT DATE_ADD('2018-02-01', INTERVAL -188 DAY)",
+  { 2017,7,28,0,0,0,0L,0, MYSQL_TIMESTAMP_DATE }
+    },
+  { "SELECT '2001-02-03 11:12:13.123456'",
+  { 2001,2,3,11,12,13,123456L,0, MYSQL_TIMESTAMP_DATETIME }
+  },
+  { "SELECT '2001-02-03 11:12:13.123'",
+  { 2001,2,3,11,12,13,123000L,0, MYSQL_TIMESTAMP_DATETIME }
+  },
+  { "SELECT '-11:12:13'",
+  { 0,0,0,11,12,13,0,1, MYSQL_TIMESTAMP_TIME }
+  },
+  { "SELECT ' '",
+  { 0,0,0,0,0,0,0,0, MYSQL_TIMESTAMP_ERROR }
+  },
+  { "SELECT '1--'",
+  { 0,0,0,0,0,0,0,0, MYSQL_TIMESTAMP_ERROR }
+  },
+  { "SELECT '-2001-01-01'",
+  { 0,0,0,0,0,0,0,0, MYSQL_TIMESTAMP_ERROR }
+  },
+  { "SELECT '-11:00'",
+  { 0,0,0,0,0,0,0,0, MYSQL_TIMESTAMP_ERROR }
+  },
+  {"SELECT '1972-04-22'",
+  {1972,4,22, 0,0,0, 0,0,MYSQL_TIMESTAMP_DATE}
+  },
+  {"SELECT ' 1972-04-22 '",
+  {1972,4,22, 0,0,0, 0,0,MYSQL_TIMESTAMP_DATE}
+  },
+  {"SELECT '1972-04-22a'",
+  {1972,4,22, 0,0,0, 0,0,MYSQL_TIMESTAMP_DATE}
+  },
+  {"SELECT '0000-00-00'",
+  {0,0,0, 0,0,0 ,0,0,MYSQL_TIMESTAMP_DATE}
+  },
+  {"SELECT '1970-01-00'",
+  {1970,1,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_DATE}
+  },
+  {"SELECT '0069-12-31'",
+  {69,12,31, 0,0,0, 0,0, MYSQL_TIMESTAMP_DATE}
+  },
+  {"SELECT '69-12-31'",
+  {2069,12,31, 0,0,0, 0,0, MYSQL_TIMESTAMP_DATE}
+  },
+  {"SELECT '68-12-31'",
+  {2068,12,31, 0,0,0, 0,0, MYSQL_TIMESTAMP_DATE}
+  },
+  {"SELECT '70-01-01'",
+  {1970,1,1, 0,0,0, 0,0, MYSQL_TIMESTAMP_DATE}
+  },
+  {"SELECT '2010-1-1'",
+  {2010,1,1, 0,0,0, 0,0, MYSQL_TIMESTAMP_DATE}
+  },
+
+  {"SELECT '10000-01-01'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR}
+  },
+  {"SELECT '1979-a-01'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR}
+  },
+  {"SELECT '1979-01-32'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR}
+  },
+  {"SELECT '1979-13-01'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR}
+  },
+  {"SELECT '1YYY-01-01'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR}
+  },
+  {"SELECT '1979-0M-01'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR}
+  },
+  {"SELECT '1979-00-'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR}
+  },
+  {"SELECT '1979-00'",
+  {0,0,0, 0,0,0, 0,0,MYSQL_TIMESTAMP_ERROR}
+  },
+  {"SELECT '1979'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR}
+  },
+  {"SELECT '79'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR}
+  },
+
+  {"SELECT '10:15:00'", 
+  {0,0,0, 10,15,0, 0,0, MYSQL_TIMESTAMP_TIME}
+  },
+  {"SELECT '10:15:01'",
+  {0,0,0, 10,15,1, 0,0, MYSQL_TIMESTAMP_TIME}
+  },
+  {"SELECT '00:00:00'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_TIME}
+  },
+  {"SELECT '0:0:0'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_TIME}
+  },
+  {"SELECT '10:15:01.'",
+  {0,0,0, 10,15,1, 0,0, MYSQL_TIMESTAMP_TIME},
+  },
+  {"SELECT '25:59:59'",
+  {0,0,0, 25,59,59, 0,0, MYSQL_TIMESTAMP_TIME},
+  },
+  {"SELECT '838:59:59'",
+  {0,0,0, 838,59,59, 0,0, MYSQL_TIMESTAMP_TIME},
+  },
+  {"SELECT '-838:59:59'",
+  {0,0,0, 838,59,59, 0, 1, MYSQL_TIMESTAMP_TIME},
+  },
+ 
+  {"SELECT '00:60:00'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR},
+  },
+  {"SELECT '00:60:00'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR},
+  },
+  {"SELECT '839:00:00'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR},
+  },
+  {"SELECT '-839:00:00'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR},
+  },
+  {"SELECT '-10:15:a'",
+  { 0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR },
+  },
+  {"SELECT '1999-12-31 23:59:59.9999999'",
+  {1999,12,31, 23,59,59, 999999, 0, MYSQL_TIMESTAMP_DATETIME},
+  },
+  {"SELECT '00-08-11 8:46:40'", 
+  {2000,8,11, 8,46,40, 0,0, MYSQL_TIMESTAMP_DATETIME},
+  },
+  {"SELECT '1999-12-31 25:59:59.999999'",
+  {0,0,0, 0,0,0, 0,0, MYSQL_TIMESTAMP_ERROR },
+  },
+  { NULL,{ 0 } }
+  };
+
+  while (time_test[i].statement)
+  {
+    stmt= mysql_stmt_init(mysql);
+    rc= mysql_stmt_prepare(stmt, SL(time_test[i].statement));
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_store_result(stmt);
+
+    memset(bind, 0, sizeof(MYSQL_BIND));
+    bind[0].buffer_type= MYSQL_TYPE_DATETIME;
+    bind[0].buffer= &tm;
+    bind[0].buffer_length= sizeof(MYSQL_TIME);
+
+    rc= mysql_stmt_bind_result(stmt, bind);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_fetch(stmt);
+    check_stmt_rc(rc, stmt);
+    diag("test: %s %d %d", time_test[i].statement, tm.time_type, time_test[i].tm.time_type);
+    if (time_test[i].tm.time_type == MYSQL_TIMESTAMP_ERROR)
+    {
+      FAIL_UNLESS(tm.time_type == MYSQL_TIMESTAMP_ERROR, "MYSQL_TIMESTAMP_ERROR expected");
+    }
+    else
+      FAIL_UNLESS(equal_MYSQL_TIME(&tm, &time_test[i].tm), "time_in != time_out");
+    mysql_stmt_close(stmt);
+    i++;
+  }
+
+  return OK;
+}
+
+static int test_conc334(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_RES *result;
+  MYSQL_FIELD *field;
+  int rc;
+
+  rc= mysql_stmt_prepare(stmt, SL("SHOW ENGINES"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  result= mysql_stmt_result_metadata(stmt);
+  if (!result)
+  {
+    diag("Couldn't retrieve result set");
+    mysql_stmt_close(stmt);
+    return FAIL;
+  }
+
+  mysql_field_seek(result, 0);
+
+  while ((field= mysql_fetch_field(result)))
+  {
+    FAIL_IF(field->name_length == 0, "Invalid name length (0)");
+    FAIL_IF(field->table_length == 0, "Invalid name length (0)");
+  }
+  mysql_free_result(result);
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+static int test_conc344(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+ 
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int, b int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1,1), (2,2),(3,3),(4,4),(5,5)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("SELECT * FROM t1 ORDER BY a"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  while (!mysql_stmt_fetch(stmt));
+  FAIL_IF(mysql_stmt_num_rows(stmt) != 5, "expected 5 rows");
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_fetch(stmt);
+  diag("num_rows: %lld", mysql_stmt_num_rows(stmt));
+  FAIL_IF(mysql_stmt_num_rows(stmt) != 1, "expected 1 row");
+
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+
+static int test_conc_fraction(MYSQL *mysql)
+{
+  MYSQL_TIME tm;
+  MYSQL_BIND bind[1];
+  char query[1024];
+  int i;
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+  unsigned long frac= 0;
+
+  for (i=0; i < 10; i++, frac=frac*10+i)
+  {
+    unsigned long expected= 0;
+    sprintf(query, "SELECT '2018-11-05 22:25:59.%ld'", frac);
+
+    diag("%d: %s", i, query);
+
+    rc= mysql_stmt_prepare(stmt, SL(query));
+    check_stmt_rc(rc, stmt);
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_store_result(stmt);
+
+    memset(bind, 0, sizeof(MYSQL_BIND));
+    bind[0].buffer_type= MYSQL_TYPE_DATETIME;
+    bind[0].buffer= &tm;
+    bind[0].buffer_length= sizeof(MYSQL_TIME);
+
+    rc= mysql_stmt_bind_result(stmt, bind);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_fetch(stmt);
+    check_stmt_rc(rc, stmt);
+
+    diag("second_part: %ld", tm.second_part);
+
+    expected= i > 6 ? 123456 : frac * (unsigned int)powl(10, (6 - i));
+
+    diag("tm.second_part=%ld expected=%ld", tm.second_part, expected);
+    FAIL_IF(tm.second_part != expected, "expected fractional part to be 900000");
+
+  }
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+static int test_zerofill_1byte(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  int rc;
+  MYSQL_BIND bind;
+  char buffer[3];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int zerofill)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES(1)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("SELECT a FROM t1"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(&bind, 0, sizeof(MYSQL_BIND));
+  bind.buffer_type= MYSQL_TYPE_STRING;
+  bind.buffer= buffer;
+  bind.buffer_length= 1;
+
+  rc= mysql_stmt_bind_result(stmt, &bind);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(rc != 101, "expected truncation warning");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_conc424(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  my_bool max_len= 1;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_table1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE test_table1 (test_int INT, b int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO test_table1 values(10,11),(11,12)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS testCursor");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE PROCEDURE testCursor()\n"
+                  "BEGIN\n"
+                  "DECLARE test_int INT;\n"
+                  "DECLARE b INT;\n"
+                  "DECLARE done INT DEFAULT FALSE;\n"
+                  "DECLARE testCursor CURSOR\n"
+                  "FOR\n"
+                  "SELECT test_int,b FROM test_table1;\n"
+                  "DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;\n"
+                  "OPEN testCursor;\n"
+
+                  " read_loop: LOOP\n"
+                  "   FETCH testCursor INTO test_int, b;\n"
+                  "   IF done THEN\n"
+                  "     LEAVE read_loop;\n"
+                  "   END IF;\n"
+                  "   SELECT test_int,b;"
+                  " END LOOP;\n"
+                  "CLOSE testCursor;\n"
+                  "END");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL("CALL testCursor()"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &max_len);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  do {
+    if (mysql_stmt_field_count(stmt))
+    {
+      MYSQL_RES *res= mysql_stmt_result_metadata(stmt);
+      rc= mysql_stmt_fetch(stmt);
+      FAIL_IF(rc, "Wrong return code");
+      mysql_free_result(res);
+    }
+    rc= mysql_stmt_next_result(stmt);
+
+  } while (!rc);
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP PROCEDURE testCursor");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE test_table1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_maxparam(MYSQL *mysql)
+{
+  const char *query= "INSERT INTO t1 VALUES (?)";
+  int rc;
+  char *buffer;
+  int i;
+  int val= 1;
+  size_t mem= strlen(query) + 1 + 4 * 65535 + 1;
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_BIND* bind;
+
+  bind = calloc(sizeof(MYSQL_BIND), 65535);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  buffer= calloc(1, mem);
+  strcpy(buffer, query);
+  for (i=0; i < 65534.; i++)
+    strcat(buffer, ",(?)");
+  rc= mysql_stmt_prepare(stmt, SL(buffer));
+  check_stmt_rc(rc, stmt);
+
+  for (i=0; i < 65534; i++)
+  {
+    bind[i].buffer_type= MYSQL_TYPE_LONG;
+    bind[i].buffer= &val;
+  }
+
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_affected_rows(stmt) != 65535, "Expected affected_rows=65535");
+
+  strcat(buffer, ",(?)");
+  rc= mysql_stmt_prepare(stmt, SL(buffer));
+  free(buffer);
+  FAIL_IF(!rc, "Error expected");
+  FAIL_IF(mysql_stmt_errno(stmt) != ER_PS_MANY_PARAM, "Expected ER_PS_MANY_PARAM error");
+
+  mysql_stmt_close(stmt);
+  free(bind);
+  return OK;
+}
+
+static int test_mdev_21920(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_BIND bind[1];
+  int rc;
+  char buffer[128];
+
+  rc= mysql_stmt_prepare(stmt, SL("SELECT ''"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  buffer[0]= 1;
+
+  memset(bind, 0, sizeof(MYSQL_BIND));
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+  bind[0].buffer= buffer;
+  bind[0].buffer_length= 127;
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(buffer[0] != 0, "Expected empty string");
+
+
+  mysql_stmt_close(stmt);
+
+  return OK; 
+}
+
+static int test_returning(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  MYSQL_RES *result;
+  int rc;
+
+  diag("MDEV-23768 not fixed yet");
+  mysql_stmt_close(stmt);
+  return SKIP;
+
+  rc= mysql_query(mysql, "CREATE TEMPORARY TABLE t1 (a int not null auto_increment primary key, b json)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 (a,b) VALUES (NULL, '[incorrect json]') RETURNING a");
+  check_mysql_rc(rc, mysql);
+
+  if (!rc) diag("should have fail");
+
+  result= mysql_store_result(mysql);
+  mysql_free_result(result);
+
+  diag("Error: %s", mysql_error(mysql));
+
+  rc= mysql_stmt_prepare(stmt, SL("INSERT INTO t1 (a,b) VALUES (NULL, '[incorrect json]') RETURNING a"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_conc504(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt= mysql_stmt_init(mysql);
+  const char *sp= "CREATE PROCEDURE p1()\n" \
+                  "BEGIN\n"\
+                  "  SELECT 1;\n"\
+                  "  SELECT 2;\n"\
+                  "  SELECT 3;\n"\
+                  "END";
+
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, sp);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL("CALL p1()"));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_store_result(stmt);
+  FAIL_IF(mysql_stmt_num_rows(stmt) != 1, "Expected 1 row");
+
+  mysql_stmt_next_result(stmt);
+  mysql_stmt_store_result(stmt);
+  FAIL_IF(mysql_stmt_num_rows(stmt) != 1, "Expected 1 row");
+
+  mysql_stmt_next_result(stmt);
+  mysql_stmt_store_result(stmt);
+  FAIL_IF(mysql_stmt_num_rows(stmt) != 1, "Expected 1 row");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP PROCEDURE p1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_conc512(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind;
+  float f;
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+
+  rc= mysql_real_query(mysql, SL("CREATE TABLE t1 (a int)"));
+
+  rc= mysql_real_query(mysql, SL("INSERT INTO t1 VALUES (1073741825)"));
+
+  stmt=  mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL("SELECT a FROM t1"));
+  check_stmt_rc(rc, stmt);
+
+  memset(&bind, 0, sizeof(MYSQL_BIND));
+  bind.buffer= &f;
+  bind.buffer_type= MYSQL_TYPE_FLOAT;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, &bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(rc != 101, "Truncation expected");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+struct my_tests_st my_tests[] = {
+  {"test_conc512", test_conc512, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc504", test_conc504, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_returning", test_returning, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_mdev_21920", test_mdev_21920, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_maxparam", test_maxparam, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_conc424", test_conc424, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_conc344", test_conc344, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_conc334", test_conc334, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_compress", test_compress, TEST_CONNECTION_NEW, CLIENT_COMPRESS, NULL, NULL},
+  {"test_zerofill_1byte", test_zerofill_1byte, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_codbc138", test_codbc138, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc208", test_conc208, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_mdev14165", test_mdev14165, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc208", test_conc208, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc217", test_conc217, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc205", test_conc205, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc198", test_conc198, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc182", test_conc182, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc181", test_conc181, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc179", test_conc179, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc177", test_conc177, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc167", test_conc167, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc168", test_conc168, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc155", test_conc155, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {"test_conc154", test_conc154, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_conc141", test_conc141, TEST_CONNECTION_NEW, 0, NULL , NULL},
+  {"test_conc67", test_conc67, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_conc_5", test_conc_5, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug1115", test_bug1115, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug1180", test_bug1180, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug1644", test_bug1644, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug11037", test_bug11037, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug11183", test_bug11183, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug12744", test_bug12744, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug1500", test_bug1500, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug15510", test_bug15510, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug15518", test_bug15518, TEST_CONNECTION_NEW | TEST_CONNECTION_DONT_CLOSE, CLIENT_MULTI_STATEMENTS, NULL , NULL},
+  {"test_bug15613", test_bug15613, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug16144", test_bug16144, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug1664", test_bug1664, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug1946", test_bug1946, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug2247", test_bug2247, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug2248", test_bug2248, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug20152", test_bug20152, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug23383", test_bug23383, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug27592", test_bug27592, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug28934", test_bug28934, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug36004", test_bug36004, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug3035", test_bug3035, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug3117", test_bug3117, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug3796", test_bug3796, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug4026", test_bug4026, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug4030", test_bug4030, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug4079", test_bug4079, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug4172", test_bug4172, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug4231", test_bug4231, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug4236", test_bug4236, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug5126", test_bug5126, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug5194", test_bug5194, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug5315", test_bug5315, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug5399", test_bug5399, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug6046", test_bug6046, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug6049", test_bug6049, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug6058", test_bug6058, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug6059", test_bug6059, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug6096", test_bug6096, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug7990", test_bug7990, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug8330", test_bug8330, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug8722", test_bug8722, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_ps_conj_select", test_ps_conj_select, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_ps_null_param", test_ps_null_param, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_ps_query_cache", test_ps_query_cache, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_ushort_bug", test_ushort_bug, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_field_misc", test_field_misc, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_mem_overun", test_mem_overun, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_decimal_bug", test_decimal_bug, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_explain_bug", test_explain_bug, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_sshort_bug", test_sshort_bug, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_stiny_bug", test_stiny_bug, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug53311", test_bug53311, TEST_CONNECTION_NEW, 0, NULL , NULL},
+  {"test_conc_fraction", test_conc_fraction, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_str_to_int", test_str_to_int, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/ps_new.c b/libmariadb/unittest/libmariadb/ps_new.c
new file mode 100644
index 00000000..9b89d6f9
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/ps_new.c
@@ -0,0 +1,511 @@
+/************************************************************************************
+  Copyright (C) 2012 Monty Program AB
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not see <http://www.gnu.org/licenses>
+  or write to the Free Software Foundation, Inc.,
+  51 Franklin St., Fifth Floor, Boston, MA 02110, USA
+ *************************************************************************************/
+
+#include "my_test.h"
+
+/* Utility function to verify the field members */
+
+
+static int test_multi_result(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND ps_params[3];  /* input parameter buffers */
+  MYSQL_BIND rs_bind[3];
+  int        int_data[3];   /* input/output values */
+  my_bool    is_null[3];    /* output value nullability */
+  int        rc, i;
+
+  /* set up stored procedure */
+  rc = mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+
+  rc = mysql_query(mysql,
+      "CREATE PROCEDURE p1("
+      "  IN p_in INT, "
+      "  OUT p_out INT, "
+      "  INOUT p_inout INT) "
+      "BEGIN "
+      "  SELECT p_in, p_out, p_inout; "
+      "  SET p_in = 100, p_out = 200, p_inout = 300; "
+      "  SELECT p_in, p_out, p_inout; "
+      "END");
+  check_mysql_rc(rc, mysql);
+
+  /* initialize and prepare CALL statement with parameter placeholders */
+  stmt = mysql_stmt_init(mysql);
+  if (!stmt)
+  {
+    diag("Could not initialize statement");
+    exit(1);
+  }
+  rc = mysql_stmt_prepare(stmt, "CALL p1(?, ?, ?)", 16);
+  check_stmt_rc(rc, stmt);
+
+  /* initialize parameters: p_in, p_out, p_inout (all INT) */
+  memset(ps_params, 0, sizeof (ps_params));
+
+  ps_params[0].buffer_type = MYSQL_TYPE_LONG;
+  ps_params[0].buffer = (char *) &int_data[0];
+  ps_params[0].length = 0;
+  ps_params[0].is_null = 0;
+
+  ps_params[1].buffer_type = MYSQL_TYPE_LONG;
+  ps_params[1].buffer = (char *) &int_data[1];
+  ps_params[1].length = 0;
+  ps_params[1].is_null = 0;
+
+  ps_params[2].buffer_type = MYSQL_TYPE_LONG;
+  ps_params[2].buffer = (char *) &int_data[2];
+  ps_params[2].length = 0;
+  ps_params[2].is_null = 0;
+
+  /* bind parameters */
+  rc = mysql_stmt_bind_param(stmt, ps_params);
+  check_stmt_rc(rc, stmt);
+
+  /* assign values to parameters and execute statement */
+  int_data[0]= 10;  /* p_in */
+  int_data[1]= 20;  /* p_out */
+  int_data[2]= 30;  /* p_inout */
+
+  rc = mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_field_count(stmt) != 3, "expected 3 fields");
+
+  memset(rs_bind, 0, sizeof (MYSQL_BIND) * 3);
+  for (i=0; i < 3; i++)
+  {
+    rs_bind[i].buffer = (char *) &(int_data[i]);
+    rs_bind[i].buffer_length = sizeof (int_data);
+    rs_bind[i].buffer_type = MYSQL_TYPE_LONG;
+    rs_bind[i].is_null = &is_null[i];
+  }
+  rc= mysql_stmt_bind_result(stmt, rs_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+ 
+  FAIL_IF(int_data[0] != 10 || int_data[1] != 20 || int_data[2] != 30,
+          "expected 10 20 30");
+  rc= mysql_stmt_next_result(stmt);
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_bind_result(stmt, rs_bind);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(mysql_stmt_field_count(stmt) != 3, "expected 3 fields");
+  FAIL_IF(int_data[0] != 100 || int_data[1] != 200 || int_data[2] != 300,
+          "expected 100 200 300");
+
+  FAIL_IF(mysql_stmt_next_result(stmt) != 0, "expected more results");
+  rc= mysql_stmt_bind_result(stmt, rs_bind);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_IF(mysql_stmt_field_count(stmt) != 2, "expected 2 fields");
+  FAIL_IF(int_data[0] != 200 || int_data[1] != 300,
+          "expected 100 200 300");
+  
+  FAIL_IF(mysql_stmt_next_result(stmt) != 0, "expected more results");
+  FAIL_IF(mysql_stmt_field_count(stmt) != 0, "expected 0 fields");
+
+  rc= mysql_stmt_close(stmt);
+  rc = mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+int test_sp_params(MYSQL *mysql)
+{
+  int i, rc;
+  MYSQL_STMT *stmt;
+  int a[] = {10,20,30};
+  MYSQL_BIND bind[3];
+  const char *stmtstr= "CALL P1(?,?,?)";
+  char res[3][20];
+
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE PROCEDURE p1(OUT p_out VARCHAR(19), IN p_in INT, INOUT p_inout INT)" 
+                         "BEGIN "
+                          "  SET p_in = 300, p_out := 'This is OUT param', p_inout = 200; "
+                          "  SELECT p_inout, p_in, substring(p_out, 9);"
+                         "END");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt,SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 3, "expected param_count=3");
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 3);
+  for (i=0; i < 3; i++)
+  {
+    bind[i].buffer= &a[i];
+    bind[i].buffer_type= MYSQL_TYPE_LONG;
+  }
+  bind[0].buffer_type= MYSQL_TYPE_NULL;
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(res, 0, 60);
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 3);
+  for (i=0; i < 3; i++)
+  {
+    bind[i].buffer_type= MYSQL_TYPE_STRING;
+    bind[i].buffer_length= 20;
+    bind[i].buffer= res[i];
+  }
+
+  do {
+    if (mysql->server_status & SERVER_PS_OUT_PARAMS)
+    {
+      diag("out param result set");
+      FAIL_IF(mysql_stmt_field_count(stmt) != 2, "expected 2 columns");
+      FAIL_IF(strcmp(stmt->fields[0].org_name, "p_out") != 0, "wrong field name");
+      FAIL_IF(strcmp(stmt->fields[1].org_name, "p_inout") != 0, "wrong field name");
+      rc= mysql_stmt_bind_result(stmt, bind);
+      check_stmt_rc(rc, stmt);
+      rc= mysql_stmt_fetch(stmt);
+      check_stmt_rc(rc, stmt);
+      FAIL_IF(strcmp(res[0],"This is OUT param") != 0, "comparison failed");
+      FAIL_IF(strcmp(res[1],"200") != 0, "comparison failed");
+    }
+    else
+    if (mysql_stmt_field_count(stmt))
+    {
+      diag("sp result set");
+      FAIL_IF(mysql_stmt_field_count(stmt) != 3, "expected 3 columns");
+      rc= mysql_stmt_bind_result(stmt, bind);
+      check_stmt_rc(rc, stmt);
+      rc= mysql_stmt_fetch(stmt);
+      check_stmt_rc(rc, stmt);
+      FAIL_IF(strcmp(res[0],"200") != 0, "comparison failed");
+      FAIL_IF(strcmp(res[1],"300") != 0, "comparison failed");
+      FAIL_IF(strcmp(res[2],"OUT param") != 0, "comparison failed");
+
+    }
+  } while (mysql_stmt_next_result(stmt) == 0);
+
+  rc= mysql_stmt_close(stmt);
+  return OK;
+}
+
+int test_sp_reset(MYSQL *mysql)
+{
+ int i, rc;
+  MYSQL_STMT *stmt;
+  int a[] = {10,20,30};
+  MYSQL_BIND bind[3];
+  const char *stmtstr= "CALL P1(?,?,?)";
+
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE PROCEDURE p1(OUT p_out VARCHAR(19), IN p_in INT, INOUT p_inout INT)" 
+                         "BEGIN "
+                          "  SET p_in = 300, p_out := 'This is OUT param', p_inout = 200; "
+                          "  SELECT p_inout, p_in, substring(p_out, 9);"
+                         "END");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt,SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  FAIL_IF(mysql_stmt_param_count(stmt) != 3, "expected param_count=3");
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 3);
+  for (i=0; i < 3; i++)
+  {
+    bind[i].buffer= &a[i];
+    bind[i].buffer_type= MYSQL_TYPE_LONG;
+  }
+  bind[0].buffer_type= MYSQL_TYPE_NULL;
+  rc= mysql_stmt_bind_param(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_reset(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /*connection shouldn't be blocked now */
+
+  rc= mysql_query(mysql, "DROP PROCEDURE p1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_close(stmt);
+  return OK;
+}
+
+int test_sp_reset1(MYSQL *mysql)
+{
+  int rc;
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind[1];
+
+  char tmp[20];
+  const char *stmtstr= "CALL P1(?)";
+
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE PROCEDURE p1(OUT p_out VARCHAR(19))" 
+                         "BEGIN "
+                          "  SET p_out = 'foo';"
+                          "  SELECT 'foo' FROM DUAL;"
+                          "  SELECT 'bar' FROM DUAL;"
+                         "END");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt,SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  memset(tmp, 0, sizeof(tmp));
+  memset(bind, 0, sizeof(MYSQL_BIND));
+  bind[0].buffer= tmp;
+  bind[0].buffer_type= MYSQL_TYPE_STRING;
+  bind[0].buffer_length= 4;
+
+  mysql_stmt_bind_param(stmt, bind);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_next_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /* mysql_stmt_reset should set statement in prepared state.
+   * this means: all subsequent result sets should be flushed.
+   * Let's try!
+   */ 
+  rc= mysql_stmt_reset(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "DROP PROCEDURE p1");
+  check_mysql_rc(rc, mysql);
+
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
+int test_sp_reset2(MYSQL *mysql)
+{
+  int rc, i;
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind[4];
+  long l[4];
+  const char *stmtstr= "CALL P1()";
+
+  memset(l, 0, sizeof(l));
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE PROCEDURE p1()" 
+                         "BEGIN "
+                          "  SET @a:=1;"
+                          "  INSERT INTO t1 VALUES(1);" 
+                          "  SELECT 1 FROM DUAL;"
+                          "  SELECT 2,3 FROM DUAL;"
+                          "  INSERT INTO t1 VALUES(2);" 
+                          "  SELECT 3,4,5 FROM DUAL;"
+                          "  SELECT 4,5,6,7 FROM DUAL;"
+                         "END");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt,SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, 0, sizeof(MYSQL_BIND) * 4);
+  for (i=0; i < 4; i++)
+  {
+    bind[i].buffer_type= MYSQL_TYPE_LONG;
+    bind[i].buffer= &l[i];
+  }
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  while (rc != MYSQL_NO_DATA)
+  { 
+    rc= mysql_stmt_fetch(stmt);
+    diag("l=%ld", l[0]);
+  }
+  
+  rc= mysql_stmt_next_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /* now rebind since we expect 2 columns */
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  while (rc != MYSQL_NO_DATA)
+  { 
+    rc= mysql_stmt_fetch(stmt);
+    diag("l=%ld l=%ld", l[0], l[1]);
+  }
+
+
+  rc= mysql_stmt_next_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  /* now rebind since we expect 2 columns */
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  while (rc != MYSQL_NO_DATA)
+  { 
+    rc= mysql_stmt_fetch(stmt);
+    diag("l=%ld l=%ld l=%ld", l[0], l[1], l[2]);
+  }
+
+  rc= mysql_stmt_close(stmt);
+
+
+  rc= mysql_query(mysql, "DROP PROCEDURE p1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+int test_query(MYSQL *mysql)
+{
+  int rc;
+  int i;
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind[1];
+
+  char tmp[20];
+  const char *stmtstr= "CALL P1(?)";
+
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE PROCEDURE p1(OUT p_out VARCHAR(19))" 
+                         "BEGIN "
+                          "  SET p_out = 'foo';"
+                          "  SELECT 1 FROM DUAL;"
+                         "END");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_stmt_prepare(stmt,SL(stmtstr));
+  check_stmt_rc(rc, stmt);
+
+  for (i=0; i < 1000; i++)
+  {
+    int status;
+    memset(tmp, 0, sizeof(tmp));
+    memset(bind, 0, sizeof(MYSQL_BIND));
+    bind[0].buffer= tmp;
+    bind[0].buffer_type= MYSQL_TYPE_STRING;
+    bind[0].buffer_length= 4;
+
+    mysql_stmt_bind_param(stmt, bind);
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    do {
+      if (stmt->field_count)
+      {
+        mysql_stmt_bind_result(stmt, bind);
+        rc= mysql_stmt_store_result(stmt);
+        check_stmt_rc(rc, stmt);
+        while(mysql_stmt_fetch(stmt) == 0);
+
+        rc= mysql_stmt_free_result(stmt);
+        check_stmt_rc(rc, stmt);
+      }
+      status= mysql_stmt_next_result(stmt);
+      if (status == 1)
+        check_stmt_rc(status, stmt);
+    } while (status == 0);
+
+    rc= mysql_stmt_reset(stmt);
+    if (rc)
+      diag("reset failed after %d iterations", i);
+    check_stmt_rc(rc, stmt);
+  }
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+struct my_tests_st my_tests[] = {
+  {"test_query", test_query, TEST_CONNECTION_DEFAULT, CLIENT_MULTI_RESULTS , NULL , NULL},
+  {"test_sp_params", test_sp_params, TEST_CONNECTION_DEFAULT, CLIENT_MULTI_STATEMENTS, NULL , NULL},
+  {"test_sp_reset", test_sp_reset, TEST_CONNECTION_DEFAULT, CLIENT_MULTI_STATEMENTS, NULL , NULL}, 
+  {"test_sp_reset1", test_sp_reset1, TEST_CONNECTION_DEFAULT, CLIENT_MULTI_STATEMENTS, NULL , NULL},
+  {"test_sp_reset2", test_sp_reset2, TEST_CONNECTION_DEFAULT, CLIENT_MULTI_STATEMENTS, NULL , NULL},
+  {"test_multi_result", test_multi_result, TEST_CONNECTION_DEFAULT, CLIENT_MULTI_STATEMENTS, NULL , NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/result.c b/libmariadb/unittest/libmariadb/result.c
new file mode 100644
index 00000000..13f40b2c
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/result.c
@@ -0,0 +1,1102 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+/**
+  Some basic tests of the client API.
+*/
+
+#include "my_test.h"
+
+static int client_store_result(MYSQL *mysql)
+{
+  MYSQL_RES *result;
+  int       rc, rowcount= 0;
+
+  rc= mysql_query(mysql, "SELECT 'foo' FROM DUAL UNION SELECT 'bar' FROM DUAL");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  /* since we use store result, we should be able execute other api calls */
+  rc= mysql_ping(mysql);
+  FAIL_IF(rc, "mysql_ping failed");
+
+  while (mysql_fetch_row(result))
+    rowcount++;
+
+  FAIL_IF(rowcount != 2, "rowcount != 2");
+  
+  mysql_free_result(result);
+
+  return OK;
+}
+
+static int client_use_result(MYSQL *mysql)
+{
+  MYSQL_RES *result;
+  int       rc, rowcount= 0;
+
+  rc= mysql_query(mysql, "SELECT 'foo' FROM DUAL UNION SELECT 'bar' FROM DUAL");
+  check_mysql_rc(rc, mysql);
+
+  /* get the result */
+  result= mysql_use_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  /* since we use use result, we shouldn't be able execute other api calls */
+  rc= mysql_ping(mysql);
+  FAIL_IF(!rc, "Error expected");
+
+  while (mysql_fetch_row(result))
+    rowcount++;
+
+  FAIL_IF(rowcount != 2, "rowcount != 2");
+  
+  mysql_free_result(result);
+
+  return OK;
+}
+
+static int test_free_result(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  char       c2[5];
+  ulong      bl1, l2;
+  int        rc, c1, bc1;
+  char       query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "drop table if exists test_free_result");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table test_free_result("
+                         "c1 int primary key auto_increment)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into test_free_result values(), (), ()");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "select * from test_free_result");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&bc1;
+  my_bind[0].length= &bl1;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  c2[0]= '\0'; l2= 0;
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)c2;
+  my_bind[0].buffer_length= 7;
+  my_bind[0].is_null= 0;
+  my_bind[0].length= &l2;
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 0, 0);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(strncmp(c2, "1", 1) == 0, "c2 != '1'");
+  FAIL_UNLESS(l2 == 1, "l2 != 1");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  c1= 0, l2= 0;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&c1;
+  my_bind[0].buffer_length= 0;
+  my_bind[0].is_null= 0;
+  my_bind[0].length= &l2;
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 0, 0);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(c1 == 2, "c1 != 2");
+  FAIL_UNLESS(l2 == 4, "l2 != 4");
+
+  rc= mysql_query(mysql, "drop table test_free_result");
+  FAIL_IF(!rc, "Error commands out of sync expected");
+
+  rc= mysql_stmt_free_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "drop table test_free_result");
+  check_mysql_rc(rc, mysql);  /* should be successful */
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+
+/* Test mysql_stmt_store_result() */
+
+static int test_free_store_result(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND my_bind[1];
+  char       c2[5];
+  ulong      bl1, l2;
+  int        rc, c1, bc1;
+  char       query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "drop table if exists test_free_result");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table test_free_result(c1 int primary key auto_increment)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "insert into test_free_result values(), (), ()");
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "select * from test_free_result");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&bc1;
+  my_bind[0].buffer_length= 0;
+  my_bind[0].is_null= 0;
+  my_bind[0].length= &bl1;
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  c2[0]= '\0'; l2= 0;
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (void *)c2;
+  my_bind[0].buffer_length= 7;
+  my_bind[0].is_null= 0;
+  my_bind[0].length= &l2;
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 0, 0);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(strncmp(c2, "1", 1) == 0, "c2 != '1'");
+  FAIL_UNLESS(l2 == 1, "l2 != 1");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  c1= 0, l2= 0;
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *)&c1;
+  my_bind[0].buffer_length= 0;
+  my_bind[0].is_null= 0;
+  my_bind[0].length= &l2;
+
+  rc= mysql_stmt_fetch_column(stmt, my_bind, 0, 0);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(c1 == 2, "c1 != 2");
+  FAIL_UNLESS(l2 == 4, "l2 != 4");
+
+  rc= mysql_stmt_free_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_query(mysql, "drop table test_free_result");
+  check_mysql_rc(rc, mysql);
+
+  mysql_stmt_close(stmt);
+
+  return OK;
+}
+
+static int test_store_result(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  int32      nData;
+  char       szData[100];
+  MYSQL_BIND my_bind[2];
+  ulong      length, length1;
+  my_bool    is_null[2];
+  char       query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_store_result");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_store_result(col1 int , col2 varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_store_result VALUES(10, 'venu'), (20, 'mysql')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_store_result(col2) VALUES('monty')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  /* fetch */
+  memset(my_bind, '\0', sizeof(my_bind));
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *) &nData;       /* integer data */
+  my_bind[0].length= &length;
+  my_bind[0].is_null= &is_null[0];
+
+  length= 0;
+  my_bind[1].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[1].buffer= szData;                /* string data */
+  my_bind[1].buffer_length= sizeof(szData);
+  my_bind[1].length= &length1;
+  my_bind[1].is_null= &is_null[1];
+  length1= 0;
+
+  strcpy(query, "SELECT * FROM test_store_result");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(nData == 10, "nData != 10");
+  FAIL_UNLESS(strcmp(szData, "venu") == 0, "szData != 'Venu'");
+  FAIL_UNLESS(length1 == 4, "length1 != 4");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(nData == 20, "nData != 20");
+  FAIL_UNLESS(strcmp(szData, "mysql") == 0, "szDaza != 'mysql'");
+  FAIL_UNLESS(length1 == 5, "length1 != 5");
+
+  length= 99;
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(is_null[0], "isnull set");
+  FAIL_UNLESS(strcmp(szData, "monty") == 0, "szData != 'monty'");
+  FAIL_UNLESS(length1 == 5, "length1 != 5");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(nData == 10, "nData != 10");
+  FAIL_UNLESS(strcmp(szData, "venu") == 0, "szData != 'Venu'");
+  FAIL_UNLESS(length1 == 4, "length1 != 4");
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(nData == 20, "nData != 20");
+  FAIL_UNLESS(strcmp(szData, "mysql") == 0, "szDaza != 'mysql'");
+  FAIL_UNLESS(length1 == 5, "length1 != 5");
+
+  length= 99;
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(is_null[0], "isnull set");
+  FAIL_UNLESS(strcmp(szData, "monty") == 0, "szData != 'monty'");
+  FAIL_UNLESS(length1 == 5, "length1 != 5");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_store_result");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+/* Test simple bind store result */
+
+static int test_store_result1(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  char       query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_store_result");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_store_result(col1 int , col2 varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_store_result VALUES(10, 'venu'), (20, 'mysql')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_store_result(col2) VALUES('monty')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  strcpy(query, "SELECT * FROM test_store_result");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+  FAIL_UNLESS(rc == 3, "rowcount != 3");
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= 0;
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rc++;
+  FAIL_UNLESS(rc == 3, "rowcount != 3");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_store_result");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+/* Another test for bind and store result */
+
+static int test_store_result2(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int        rc;
+  int        nData;
+  ulong      length;
+  MYSQL_BIND my_bind[1];
+  char query[MAX_TEST_QUERY_LENGTH];
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_store_result");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_store_result(col1 int , col2 varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_store_result VALUES(10, 'venu'), (20, 'mysql')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_store_result(col2) VALUES('monty')");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_commit(mysql);
+  check_mysql_rc(rc, mysql);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+
+  my_bind[0].buffer_type= MYSQL_TYPE_LONG;
+  my_bind[0].buffer= (void *) &nData;      /* integer data */
+  my_bind[0].length= &length;
+  my_bind[0].is_null= 0;
+
+  strcpy((char *)query , "SELECT col1 FROM test_store_result where col1= ?");
+  stmt= mysql_stmt_init(mysql);
+  FAIL_IF(!stmt, mysql_error(mysql));
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  nData= 10; length= 0;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  nData= 0;
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(nData == 10, "nData != 10");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+
+  nData= 20;
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  nData= 0;
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+
+  FAIL_UNLESS(nData == 20, "nData != 20");
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(rc == MYSQL_NO_DATA, "rc != MYSQL_NO_DATA");
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_store_result");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug11718(MYSQL *mysql)
+{
+  MYSQL_RES	*res;
+  int rc;
+  const char *query= "select str_to_date(concat(f3),'%Y%m%d') from t1,t2 "
+                     "where f1=f2 order by f1";
+
+  rc= mysql_query(mysql, "drop table if exists t1, t2");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (f1 int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t2 (f2 int, f3 numeric(8))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 values (1), (2)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t2 values (1,20050101), (2,20050202)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+  res = mysql_store_result(mysql);
+
+  FAIL_UNLESS(res->fields[0].type == MYSQL_TYPE_DATE, "type != MYSQL_TYPE_DATE");
+  mysql_free_result(res);
+  rc= mysql_query(mysql, "drop table t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug19671(MYSQL *mysql)
+{
+  MYSQL_RES *result;
+  int rc;
+
+  mysql_query(mysql, "set sql_mode=''");
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "drop view if exists v1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1(f1 int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create view v1 as select va.* from t1 va");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_list_fields(mysql, "v1", NULL);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS(rc == 0, "");
+
+  if (verify_prepare_field(result, 0, "f1", "f1", MYSQL_TYPE_LONG,
+                       "v1", "v1", schema, 11, "0")) {
+    mysql_free_result(result);
+    diag("verify_prepare_field failed");
+    return FAIL;
+  }
+
+  mysql_free_result(result);
+  check_mysql_rc(mysql_query(mysql, "drop view v1"), mysql);
+  check_mysql_rc(mysql_query(mysql, "drop table t1"), mysql);
+  return OK;
+}
+
+/*
+  Bug#21726: Incorrect result with multiple invocations of
+  LAST_INSERT_ID
+
+  Test that client gets updated value of insert_id on UPDATE that uses
+  LAST_INSERT_ID(expr).
+  select_query added to test for bug
+    #26921 Problem in mysql_insert_id() Embedded C API function
+*/
+static int test_bug21726(MYSQL *mysql)
+{
+  const char *create_table[]=
+  {
+    "DROP TABLE IF EXISTS t1",
+    "CREATE TABLE t1 (i INT)",
+    "INSERT INTO t1 VALUES (1)",
+  };
+  const char *update_query= "UPDATE t1 SET i= LAST_INSERT_ID(i + 1)";
+  int rc;
+  unsigned long long insert_id;
+  const char *select_query= "SELECT * FROM t1";
+  MYSQL_RES  *result;
+
+  rc= mysql_query(mysql, create_table[0]);
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, create_table[1]);
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, create_table[2]);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, update_query);
+  check_mysql_rc(rc, mysql);
+  insert_id= mysql_insert_id(mysql);
+  FAIL_UNLESS(insert_id == 2, "insert_id != 2");
+
+  rc= mysql_query(mysql, update_query);
+  check_mysql_rc(rc, mysql);
+  insert_id= mysql_insert_id(mysql);
+  FAIL_UNLESS(insert_id == 3, "insert_id != 3");
+
+  rc= mysql_query(mysql, select_query);
+  check_mysql_rc(rc, mysql);
+  insert_id= mysql_insert_id(mysql);
+  FAIL_UNLESS(insert_id == 3, "insert_id != 3");
+  result= mysql_store_result(mysql);
+  mysql_free_result(result);
+
+  return OK;
+}
+
+/* Bug#6761 - mysql_list_fields doesn't work */
+
+static int test_bug6761(MYSQL *mysql)
+{
+  const char *stmt_text;
+  MYSQL_RES *res;
+  int rc;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  stmt_text= "CREATE TABLE t1 (a int, b char(255), c decimal)";
+  rc= mysql_real_query(mysql, stmt_text, (unsigned long)strlen(stmt_text));
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_list_fields(mysql, "t1", "%");
+  FAIL_UNLESS(res && mysql_num_fields(res) == 3, "num_fields != 3");
+  mysql_free_result(res);
+
+  stmt_text= "DROP TABLE t1";
+  rc= mysql_real_query(mysql, stmt_text, (unsigned long)strlen(stmt_text));
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test field flags (verify .NET provider) */
+
+static int test_field_flags(MYSQL *mysql)
+{
+  int          rc;
+  MYSQL_RES    *result;
+  MYSQL_FIELD  *field;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_field_flags");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_field_flags(id int NOT NULL AUTO_INCREMENT PRIMARY KEY, \
+                                                        id1 int NOT NULL, \
+                                                        id2 int UNIQUE, \
+                                                        id3 int, \
+                                                        id4 int NOT NULL, \
+                                                        id5 int, \
+                                                        KEY(id3, id4))");
+  check_mysql_rc(rc, mysql);
+
+  /* with table name included with TRUE column name */
+  rc= mysql_query(mysql, "SELECT * FROM test_field_flags");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_use_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  mysql_field_seek(result, 0);
+
+  field= mysql_fetch_field(result);
+  FAIL_UNLESS(field->flags & NOT_NULL_FLAG && 
+              field->flags & PRI_KEY_FLAG &&
+              field->flags & AUTO_INCREMENT_FLAG, "Wrong flags for field 0");
+
+  field= mysql_fetch_field(result);
+  FAIL_UNLESS(field->flags & NOT_NULL_FLAG, "Wrong flags for field 1");
+
+  field= mysql_fetch_field(result);
+  FAIL_UNLESS(field->flags & UNIQUE_KEY_FLAG, "Wrong flags for field 2");
+
+  field= mysql_fetch_field(result);
+  FAIL_UNLESS(field->flags & MULTIPLE_KEY_FLAG, "Wrong flags for field 3");
+
+  field= mysql_fetch_field(result);
+  FAIL_UNLESS(field->flags & NOT_NULL_FLAG, "Wrong flags for field 4");
+
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_field_flags");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test real and alias names */
+
+static int test_field_names(MYSQL *mysql)
+{
+  int        rc;
+  MYSQL_RES  *result;
+
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_field_names1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_field_names2");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_field_names1(id int, name varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_field_names2(id int, name varchar(50))");
+  check_mysql_rc(rc, mysql);
+
+  /* with table name included with TRUE column name */
+  rc= mysql_query(mysql, "SELECT id as 'id-alias' FROM test_field_names1");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_use_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS(rc == 0, "rowcount != 0");
+  mysql_free_result(result);
+
+  /* with table name included with TRUE column name */
+  rc= mysql_query(mysql, "SELECT t1.id as 'id-alias', test_field_names2.name FROM test_field_names1 t1, test_field_names2");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_use_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS(rc == 0, "rowcount != 0");
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_field_names1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_field_names2");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test FUNCTION field info / DATE_FORMAT() table_name . */
+
+static int test_func_fields(MYSQL *mysql)
+{
+  int        rc;
+  MYSQL_RES  *result;
+  MYSQL_FIELD *field;
+
+
+  rc= mysql_autocommit(mysql, TRUE);
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_dateformat");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE test_dateformat(id int, \
+                                                       ts timestamp)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO test_dateformat(id) values(10)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT ts FROM test_dateformat");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  field= mysql_fetch_field(result);
+  FAIL_IF(!field, "Invalid field");
+  FAIL_UNLESS(strcmp(field->table, "test_dateformat") == 0, "field->table != 'test_dateformat'");
+
+  field= mysql_fetch_field(result);
+  FAIL_IF(field, "no more fields expected");
+
+  mysql_free_result(result);
+
+  /* DATE_FORMAT */
+  rc= mysql_query(mysql, "SELECT DATE_FORMAT(ts, '%Y') AS 'venu' FROM test_dateformat");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  field= mysql_fetch_field(result);
+  FAIL_IF(!field, "Invalid field");
+  FAIL_UNLESS(field->table[0] == '\0', "field->table != ''");
+
+  field= mysql_fetch_field(result);
+  FAIL_IF(field, "no more fields expected");
+
+  mysql_free_result(result);
+
+  /* FIELD ALIAS TEST */
+  rc= mysql_query(mysql, "SELECT DATE_FORMAT(ts, '%Y')  AS 'YEAR' FROM test_dateformat");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  field= mysql_fetch_field(result);
+  FAIL_IF(!field, "Invalid field");
+  FAIL_UNLESS(strcmp(field->name, "YEAR") == 0, "name != 'YEAR'");
+  FAIL_UNLESS(field->org_name[0] == '\0', "org_name != ''");
+
+  field= mysql_fetch_field(result);
+  FAIL_IF(field, "no more fields expected");
+
+  mysql_free_result(result);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_dateformat");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+/* Test mysql_list_fields() */
+
+static int test_list_fields(MYSQL *mysql)
+{
+  MYSQL_RES *result;
+  int rc;
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1(c1 int primary key auto_increment, c2 char(10) default 'mysql')");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_list_fields(mysql, "t1", NULL);
+  FAIL_IF(!result, "Invalid result set");
+
+  rc= 0;
+  while (mysql_fetch_row(result))
+    rc++;
+  FAIL_UNLESS(rc == 0, "rowcount != 0");
+
+  if (verify_prepare_field(result, 0, "c1", "c1", MYSQL_TYPE_LONG,
+                       "t1", "t1",
+                       schema, 11, "0"))
+    goto error;
+
+  if (verify_prepare_field(result, 1, "c2", "c2", MYSQL_TYPE_STRING,
+                       "t1", "t1",
+                       schema, 10, "mysql"))
+    goto error;
+
+  mysql_free_result(result);
+  check_mysql_rc(mysql_query(mysql, "drop table t1"), mysql);
+  return OK;
+
+error:
+  mysql_free_result(result);
+  check_mysql_rc(mysql_query(mysql, "drop table t1"), mysql);
+  return FAIL;
+}
+
+/* Test correct max length for MEDIUMTEXT and LONGTEXT columns */
+
+static int test_bug9735(MYSQL *mysql)
+{
+  MYSQL_RES *res;
+  int rc;
+
+
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (a mediumtext, b longtext) "
+                         "character set latin1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "select * from t1");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  if (verify_prepare_field(res, 0, "a", "a", MYSQL_TYPE_BLOB,
+                       "t1", "t1", schema, (1U << 24)-1, 0)) 
+    goto error;
+  if (verify_prepare_field(res, 1, "b", "b", MYSQL_TYPE_BLOB,
+                       "t1", "t1", schema, ~0U, 0))
+    goto error;
+  mysql_free_result(res);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+  return OK;
+error:
+  mysql_free_result(res);
+  rc= mysql_query(mysql, "drop table t1");
+  return FAIL;
+}
+
+/*
+  Check that mysql_next_result works properly in case when one of
+  the statements used in a multi-statement query is erroneous
+*/
+
+static int test_bug9992(MYSQL *mysql)
+{
+  MYSQL_RES* res ;
+  int   rc;
+
+  /* Sic: SHOW DATABASE is incorrect syntax. */
+  rc= mysql_query(mysql, "SHOW TABLES; SHOW DATABASE; SELECT 1;");
+  check_mysql_rc(rc, mysql);
+  
+  res= mysql_store_result(mysql);
+  FAIL_UNLESS(res, "Invalid resultset");
+  mysql_free_result(res);
+  rc= mysql_next_result(mysql);
+  FAIL_UNLESS(rc == 1, "Error expected");                         /* Got errors, as expected */
+
+  return OK;
+}
+
+/* Test the support of multi-statement executions */
+
+static int test_multi_statements(MYSQL *mysql)
+{
+  MYSQL *mysql_local;
+  MYSQL_RES *result;
+  int    rc;
+
+  const char *query= "\
+DROP TABLE IF EXISTS test_multi_tab;\
+CREATE TABLE test_multi_tab(id int, name char(20));\
+INSERT INTO test_multi_tab(id) VALUES(10), (20);\
+INSERT INTO test_multi_tab VALUES(20, 'insert;comma');\
+SELECT * FROM test_multi_tab;\
+UPDATE test_multi_tab SET name='new;name' WHERE id=20;\
+DELETE FROM test_multi_tab WHERE name='new;name';\
+SELECT * FROM test_multi_tab;\
+DELETE FROM test_multi_tab WHERE id=10;\
+SELECT * FROM test_multi_tab;\
+DROP TABLE test_multi_tab;\
+select 1;\
+DROP TABLE IF EXISTS test_multi_tab";
+  uint count, exp_value;
+  uint rows[]= {0, 0, 2, 1, 3, 2, 2, 1, 1, 0, 0, 1, 0};
+  my_bool reconnect= 1;
+
+  SKIP_SKYSQL;
+  SKIP_MAXSCALE;
+
+  /*
+    First test that we get an error for multi statements
+    (Because default connection is not opened with CLIENT_MULTI_STATEMENTS)
+  */
+  mysql_local= mysql;
+  mysql = test_connect(NULL);
+  rc= mysql_query(mysql, query); /* syntax error */
+  FAIL_IF(!rc, "Error expected");
+
+  rc= mysql_next_result(mysql);
+  FAIL_UNLESS(rc == -1, "rc != -1");
+  rc= mysql_more_results(mysql);
+  FAIL_UNLESS(rc == 0, "rc != 0");
+
+  mysql_close(mysql);
+  mysql= mysql_local;
+
+  mysql_options(mysql_local, MYSQL_OPT_RECONNECT, &reconnect);
+
+  rc= mysql_query(mysql_local, query);
+  check_mysql_rc(rc, mysql);
+
+  for (count= 0 ; count < array_elements(rows) ; count++)
+  {
+    if ((result= mysql_store_result(mysql_local)))
+    {
+      mysql_free_result(result);
+    }
+
+    exp_value= (uint) mysql_affected_rows(mysql_local);
+    FAIL_IF(rows[count] !=  exp_value, "row[count] != exp_value");
+    if (count != array_elements(rows) -1)
+    {
+      rc= mysql_more_results(mysql_local);
+      FAIL_IF(!rc, "More results expected");
+      rc= mysql_next_result(mysql_local);
+      check_mysql_rc(rc, mysql_local);
+    }
+    else
+    {
+      rc= mysql_more_results(mysql_local);
+      FAIL_UNLESS(rc == 0, "rc != 0");
+      rc= mysql_next_result(mysql_local);
+      FAIL_UNLESS(rc == -1, "rc != -1");
+    }
+  }
+
+  /* check that errors abort multi statements */
+
+  rc= mysql_query(mysql_local, "select 1+1+a;select 1+1");
+  FAIL_IF(!rc, "Error expected");
+  rc= mysql_more_results(mysql_local);
+  FAIL_UNLESS(rc == 0, "rc != 0");
+  rc= mysql_next_result(mysql_local);
+  FAIL_UNLESS(rc == -1, "rc != -1");
+
+  rc= mysql_query(mysql_local, "select 1+1;select 1+1+a;select 1");
+  check_mysql_rc(rc, mysql);
+  result= mysql_store_result(mysql_local);
+  FAIL_IF(!result, "Invalid result set");
+  mysql_free_result(result);
+  rc= mysql_more_results(mysql_local);
+  FAIL_UNLESS(rc == 1, "rc != 1");
+  rc= mysql_next_result(mysql_local);
+  FAIL_UNLESS(rc > 0, "rc <= 0");
+
+  /*
+    Ensure that we can now do a simple query (this checks that the server is
+    not trying to send us the results for the last 'select 1'
+  */
+  rc= mysql_query(mysql_local, "select 1+1+1");
+  check_mysql_rc(rc, mysql);
+  result= mysql_store_result(mysql_local);
+  FAIL_IF(!result, "Invalid result set");
+  mysql_free_result(result);
+
+  /*
+    Check if errors in one of the queries handled properly.
+  */
+  rc= mysql_query(mysql_local, "select 1; select * from not_existing_table");
+  check_mysql_rc(rc, mysql);
+  result= mysql_store_result(mysql_local);
+  mysql_free_result(result);
+
+  rc= mysql_next_result(mysql_local);
+  FAIL_UNLESS(rc > 0, "rc <= 0");
+
+  rc= mysql_next_result(mysql_local);
+  FAIL_UNLESS(rc < 0, "rc >= 0");
+
+  return OK;
+}
+
+static int test_conc160(MYSQL *mysql)
+{
+  MYSQL_RES *result;
+  MYSQL_FIELD *field;
+  int rc;
+
+  rc= mysql_query(mysql, "SELECT cast(1.234 AS DECIMAL)");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  field= mysql_fetch_field(result);
+
+  FAIL_UNLESS(field->flags & NUM_FLAG, "Numceric flag not set");
+
+  mysql_free_result(result);
+  return OK;
+}
+
+
+
+struct my_tests_st my_tests[] = {
+  {"test_conc160", test_conc160, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"client_store_result", client_store_result, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"client_use_result", client_use_result, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_free_result", test_free_result, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_free_store_result", test_free_store_result, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_store_result", test_store_result, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_store_result1", test_store_result1, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_store_result2", test_store_result2, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_bug11718", test_bug11718, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_bug19671", test_bug19671, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_bug21726", test_bug21726, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_bug6761", test_bug6761, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_field_flags", test_field_flags, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_field_names", test_field_names, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_func_fields", test_func_fields, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_list_fields", test_list_fields, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_bug9735", test_bug9735, TEST_CONNECTION_DEFAULT, 0,  NULL,  NULL},
+  {"test_bug9992", test_bug9992, TEST_CONNECTION_NEW, CLIENT_MULTI_STATEMENTS,  NULL,  NULL},
+  {"test_multi_statements", test_multi_statements, TEST_CONNECTION_NEW, CLIENT_MULTI_STATEMENTS,  NULL,  NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/rpl_api.c b/libmariadb/unittest/libmariadb/rpl_api.c
new file mode 100644
index 00000000..e7ff31ac
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/rpl_api.c
@@ -0,0 +1,74 @@
+/*
+Copyright (c) 2018 MariaDB Corporation AB
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+/**
+  Some basic tests of the client API.
+*/
+
+#include "my_test.h"
+#include "mariadb_rpl.h"
+
+static int test_rpl_01(MYSQL *mysql)
+{
+  MARIADB_RPL_EVENT *event= NULL;
+  MARIADB_RPL *rpl= mariadb_rpl_init(mysql);
+  mysql_query(mysql, "SET @mariadb_slave_capability=4");
+  mysql_query(mysql, "SET NAMES latin1");
+  mysql_query(mysql, "SET @slave_gtid_strict_mode=1");
+  mysql_query(mysql, "SET @slave_gtid_ignore_duplicates=1");
+  mysql_query(mysql, "SET NAMES utf8");
+  mysql_query(mysql, "SET @master_binlog_checksum= @@global.binlog_checksum");
+  rpl->server_id= 12;
+  rpl->start_position= 4;
+  rpl->flags= MARIADB_RPL_BINLOG_SEND_ANNOTATE_ROWS;
+
+  if (mariadb_rpl_open(rpl))
+    return FAIL;
+
+  while((event= mariadb_rpl_fetch(rpl, event)))
+  {
+    diag("event: %d\n", event->event_type);
+  }
+  mariadb_free_rpl_event(event);
+  mariadb_rpl_close(rpl);
+  return OK;
+}
+
+
+struct my_tests_st my_tests[] = {
+  {"test_rpl_01", test_rpl_01, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/sp.c b/libmariadb/unittest/libmariadb/sp.c
new file mode 100644
index 00000000..6aeb557e
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/sp.c
@@ -0,0 +1,91 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+#include "my_test.h"
+
+/* Bug#15752 "Lost connection to MySQL server when calling a SP from C API" */
+
+static int test_bug15752(MYSQL *mysql)
+{
+  int rc, i;
+  const int ITERATION_COUNT= 100;
+  const char *query= "CALL p1()";
+
+
+  rc= mysql_query(mysql, "drop procedure if exists p1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create procedure p1() select 1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_real_query(mysql, SL(query));
+  check_mysql_rc(rc, mysql);
+  mysql_free_result(mysql_store_result(mysql));
+
+  rc= mysql_real_query(mysql, SL(query));
+  FAIL_UNLESS(rc && mysql_errno(mysql) == CR_COMMANDS_OUT_OF_SYNC, "Error expected");
+
+  rc= mysql_next_result(mysql);
+  check_mysql_rc(rc, mysql);
+
+  mysql_free_result(mysql_store_result(mysql));
+
+  rc= mysql_next_result(mysql);
+  FAIL_IF(rc != -1, "rc != -1");
+
+  for (i = 0; i < ITERATION_COUNT; i++)
+  {
+    rc= mysql_real_query(mysql, SL(query));
+    check_mysql_rc(rc, mysql);
+    mysql_free_result(mysql_store_result(mysql));
+    rc= mysql_next_result(mysql);
+    check_mysql_rc(rc, mysql);
+    mysql_free_result(mysql_store_result(mysql));
+    rc= mysql_next_result(mysql);
+    FAIL_IF(rc != -1, "rc != -1");
+
+  }
+  rc= mysql_query(mysql, "drop procedure p1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+
+
+struct my_tests_st my_tests[] = {
+  {"test_bug15752", test_bug15752, TEST_CONNECTION_NEW, 0, NULL , NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/ssl.c b/libmariadb/unittest/libmariadb/ssl.c
new file mode 100644
index 00000000..0cabe7c4
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/ssl.c
@@ -0,0 +1,1424 @@
+/************************************************************************************
+  Copyright (C) 2012 Monty Program AB
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not see <http://www.gnu.org/licenses>
+  or write to the Free Software Foundation, Inc.,
+  51 Franklin St., Fifth Floor, Boston, MA 02110, USA
+ *************************************************************************************/
+#if defined(WIN32) && defined(HEAP_CHECK)
+#define _CRTDBG_MAP_ALLOC
+#include <stdlib.h>
+#include <crtdbg.h>
+#endif
+
+#include "my_test.h"
+#include <ma_pthread.h>
+#ifdef HAVE_OPENSSL
+#include <openssl/opensslv.h>
+#include <openssl/ssl.h>
+#endif
+
+#define FNLEN 4096
+
+static int skip_ssl= 1;
+static uchar have_openssl= 1;
+static unsigned char have_tls13= 0;
+
+const char *ssluser= "ssluser";
+const char *sslpw= "sslpw";
+char sslhost[128];
+char sslcert[FNLEN];
+char sslcombined[FNLEN];
+char sslkey[FNLEN];
+char sslkey_enc[FNLEN];
+char sslca[FNLEN];
+char sslcrl[FNLEN];
+char ssl_cert_finger_print[129]= {0};
+char bad_cert_finger_print[]= "00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:01:23:45:67";
+
+pthread_mutex_t LOCK_test;
+
+void read_fingerprint()
+{
+  FILE *f= fopen(CERT_PATH "/server-cert.sha1", "r");
+  if (f)
+  {
+    if (!fscanf(f, "%128s", ssl_cert_finger_print))
+      ssl_cert_finger_print[0]= 0;
+    fclose(f);
+  }
+}
+
+int check_skip_ssl()
+{
+  const char *ssldir= NULL;
+#ifndef HAVE_TLS
+  diag("client library built without OpenSSL support -> skip");
+  return 1;
+#endif
+  if (skip_ssl)
+  {
+    diag("server doesn't support SSL -> skip");
+    return 1;
+  }
+  if (!(ssldir= getenv("SECURE_LOAD_PATH")))
+  {
+    ssldir= CERT_PATH;
+    if (!strlen(ssldir))
+    {
+      diag("certificate directory not found");
+      return 1;
+    }
+  }
+  snprintf(sslcert, FNLEN - 1, "%s/%s", ssldir, "client-cert.pem");
+  snprintf(sslcombined, FNLEN - 1, "%s/%s", ssldir, "client-certkey.pem");
+  snprintf(sslkey, FNLEN - 1, "%s/%s", ssldir, "client-key.pem");
+  snprintf(sslkey_enc, FNLEN - 1, "%s/%s", ssldir, "client-key-enc.pem");
+  snprintf(sslca, FNLEN - 1, "%s/%s", ssldir, "cacert.pem");
+  return 0;
+}
+
+static int check_cipher(MYSQL *mysql)
+{
+  char *cipher= (char *)mysql_get_ssl_cipher(mysql);
+  if (!cipher)
+    return 1;
+  diag("cipher: %s", cipher);
+
+  return 0;
+}
+
+static int create_ssl_user(const char *ssluser, my_bool is_X509)
+{
+  int rc;
+  char query[1024];
+  MYSQL *mysql= mysql_init(NULL);
+
+  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(mysql));
+
+  sprintf(query, "DROP USER '%s'@'%s'", ssluser, this_host);
+  rc= mysql_query(mysql, query);
+
+  sprintf(query, "CREATE USER '%s'@'%s' IDENTIFIED BY '%s'", ssluser, this_host, sslpw);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc,mysql);
+
+  sprintf(query, "GRANT ALL ON %s.* TO  '%s'@'%s' REQUIRE %s", schema, ssluser, this_host, is_X509 ? "X509" : "SSL");
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc,mysql);
+  rc= mysql_query(mysql, "FLUSH PRIVILEGES");
+  check_mysql_rc(rc,mysql);
+
+  mysql_close(mysql);
+
+  return rc;
+}
+
+static int test_ssl(MYSQL *mysql)
+{
+  int rc;
+  unsigned int iversion;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  char *tls_library;
+  MYSQL *my= mysql_init(NULL);
+
+  mysql_ssl_set(my,0, 0, 0, 0, 0);
+
+  create_ssl_user("ssluser", 0);
+
+  FAIL_IF(!mysql_real_connect(my, hostname, ssluser, sslpw, schema,
+                         ssl_port, socketname, 0), mysql_error(my));
+
+  mariadb_get_infov(my, MARIADB_CONNECTION_TLS_VERSION_ID, &iversion);
+  diag("iversion: %d", iversion);
+  if (iversion == 4)
+    have_tls13= 1;
+
+  mysql_close(my);
+
+  rc= mysql_query(mysql, "SELECT @@have_ssl, @@have_openssl");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+  FAIL_IF(!res, mysql_error(mysql));
+
+  while ((row= mysql_fetch_row(res)))
+  {
+    if (!strcmp(row[0], "YES"))
+      skip_ssl= 0;
+    if (strcmp(row[1], "YES"))
+      have_openssl= 0;
+    diag("SSL: %s", row[0]);
+  }
+  mysql_free_result(res);
+
+  /* In MySQL we need to check tls_version */
+  if (!mariadb_connection(mysql))
+  {
+    rc= mysql_query(mysql, "select locate('v1.2', @@tls_version) > 0");
+    check_mysql_rc(rc, mysql);
+
+    res= mysql_store_result(mysql);
+    FAIL_IF(!res, mysql_error(mysql));
+
+    if ((row= mysql_fetch_row(res)))
+    {
+      if (row[0] && row[0][0] == '0')
+        have_openssl= 0;
+    }
+    mysql_free_result(res);
+  }
+  diag("OpenSSL: %d", have_openssl);
+
+  mariadb_get_infov(NULL, MARIADB_TLS_LIBRARY, &tls_library);
+  diag("SSL library: %s", tls_library);
+
+  sslhost[0]= 0;
+
+  if (!skip_ssl)
+  {
+    char *p;
+
+    rc= mysql_query(mysql, "SELECT CURRENT_USER()");
+    check_mysql_rc(rc, mysql);
+    res= mysql_store_result(mysql);
+    row= mysql_fetch_row(res);
+    diag("user: %s", row[0]);
+    if ((p= strchr(row[0], '@')))
+      strcpy(sslhost, p+1);
+    mysql_free_result(res);
+  }
+
+  return OK;
+}
+
+static int test_ssl_cipher(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *my;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  int rc;
+  
+  if (check_skip_ssl())
+    return SKIP;
+
+  my= mysql_init(NULL);
+  FAIL_IF(!my, "mysql_init() failed");
+
+  mysql_ssl_set(my,0, 0, sslca, 0, 0);
+
+  FAIL_IF(!mysql_real_connect(my, hostname, ssluser, sslpw, schema,
+                         ssl_port, socketname, 0), mysql_error(my));
+
+  rc= mysql_query(my, "SHOW session status like 'Ssl_version'");
+  check_mysql_rc(rc, my);
+  res= mysql_store_result(my);
+  row= mysql_fetch_row(res);
+  diag("%s: %s", row[0], row[1]);
+  diag("cipher: %s", mysql_get_ssl_cipher(my));
+  mysql_free_result(res);
+
+  FAIL_IF(check_cipher(my) != 0, "Invalid cipher");
+  mysql_close(my);
+  return OK;
+}
+
+static int test_conc95(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  create_ssl_user("ssluser1", 1);
+
+  mysql= mysql_init(NULL);
+  mysql_ssl_set(mysql, 
+                sslkey, 
+                sslcert, 
+                NULL,
+                NULL, 
+                NULL);
+
+  if (!mysql_real_connect(mysql, hostname, "ssluser1", sslpw, schema,
+                          ssl_port, socketname, 0))
+  {
+    diag("could not establish x509 connection. Error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+    return FAIL;
+  }
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_multi_ssl_connections(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql[50], *my;
+  int i, rc;
+  int old_connections= 0, new_connections= 0;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  diag("Test doesn't work with yassl");
+  return SKIP;
+
+  create_ssl_user(ssluser, 0);
+
+  my= mysql_init(NULL);
+  FAIL_IF(!my,"mysql_init() failed");
+  FAIL_IF(!mysql_real_connect(my, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0), mysql_error(my));
+
+  rc= mysql_query(my, "SHOW STATUS LIKE 'Ssl_accepts'");
+  check_mysql_rc(rc, my);
+
+  res= mysql_store_result(my);
+  if ((row= mysql_fetch_row(res)))
+    old_connections= atoi(row[1]);
+  mysql_free_result(res);
+
+  for (i=0; i < 50; i++)
+  {
+    mysql[i]= mysql_init(NULL);
+    FAIL_IF(!mysql[i],"mysql_init() failed");
+
+    mysql_ssl_set(mysql[i], 0, 0, sslca, 0, 0);
+
+    mysql_real_connect(mysql[i], hostname, ssluser, sslpw, schema,
+                         ssl_port, socketname, 0);
+    if (mysql_errno(mysql[i]))
+    {
+      diag("loop: %d error: %d %s", i, mysql_errno(mysql[i]), mysql_error(mysql[i]));
+      return FAIL;
+    }
+
+    FAIL_IF(check_cipher(mysql[i]) != 0, "Invalid cipher");
+  }
+  for (i=0; i < 50; i++)
+    mysql_close(mysql[i]);
+
+  rc= mysql_query(my, "SHOW STATUS LIKE 'Ssl_accepts'");
+  check_mysql_rc(rc, my);
+
+  res= mysql_store_result(my);
+  if ((row= mysql_fetch_row(res)))
+    new_connections= atoi(row[1]);
+  mysql_free_result(res);
+
+  mysql_close(my);
+
+  diag("%d SSL connections processed", new_connections - old_connections);
+  FAIL_IF(new_connections - old_connections < 50, "new_connections should be at least old_connections + 50");
+  return OK;
+}
+
+#ifndef WIN32
+static void ssl_thread(void *unused __attribute__((unused)))
+#else
+DWORD WINAPI ssl_thread(void *dummy)
+#endif
+{
+  MYSQL *mysql= NULL;
+
+  mysql_thread_init();
+  
+  if (!(mysql= mysql_init(NULL)))
+  {
+    goto end;
+  }
+  mysql_ssl_set(mysql, 0, 0, sslca, 0, 0);
+
+  if(!mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+          ssl_port, socketname, 0))
+  {
+    diag(">Error: %s", mysql_error(mysql));
+    goto end;
+  }
+
+  pthread_mutex_lock(&LOCK_test);
+  mysql_query(mysql, "UPDATE ssltest SET a=a+1");
+  pthread_mutex_unlock(&LOCK_test);
+
+end:
+  if(mysql)
+    mysql_close(mysql);
+  mysql_thread_end();
+#ifdef _WIN32
+  return 0;
+#endif
+}
+
+static int test_ssl_threads(MYSQL *mysql)
+{
+  int i, rc;
+#ifndef WIN32
+  pthread_t threads[50];
+#else
+  HANDLE hthreads[50];
+  DWORD dthreads[50];
+#endif
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  
+  if (check_skip_ssl())
+    return SKIP;
+
+  rc= mysql_query(mysql, "DROP TABLE IF exists ssltest");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE ssltest (a int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT into ssltest VALUES (0)");
+  check_mysql_rc(rc, mysql);
+  pthread_mutex_init(&LOCK_test, NULL);
+
+  pthread_mutex_init(&LOCK_test, NULL);
+
+  for (i=0; i < 50; i++)
+  {
+#ifndef WIN32
+    pthread_create(&threads[i], NULL, (void *)ssl_thread, NULL);
+#else
+    hthreads[i]= CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ssl_thread, NULL, 0, &dthreads[i]);
+    if (hthreads[i]==NULL)
+      diag("error while starting thread");
+#endif
+  }
+  for (i=0; i < 50; i++)
+#ifndef WIN32
+    pthread_join(threads[i], NULL);
+#else
+    WaitForSingleObject(hthreads[i], INFINITE);
+#endif
+
+  pthread_mutex_destroy(&LOCK_test);
+
+  rc= mysql_query(mysql, "SELECT a FROM ssltest");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+  diag("Found: %s", row[0]);
+  FAIL_IF(strcmp(row[0], "50") != 0, "Expected 50");
+  mysql_free_result(res);
+  rc= mysql_query(mysql, "DROP TABLE IF exists ssltest");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_phpbug51647(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL* mysql;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, sslkey, 
+                       sslcert,
+                       sslca, 0, 0);
+
+  FAIL_IF(!mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0), mysql_error(mysql));
+  diag("%s", mysql_get_ssl_cipher(mysql));
+  mysql_close(mysql);
+
+  return OK;
+}
+
+static int test_password_protected(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL* mysql;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, sslkey_enc,
+                       sslcert,
+                       sslca, 0, 0);
+
+  mysql_options(mysql, MARIADB_OPT_TLS_PASSPHRASE, "qwerty");
+
+  FAIL_IF(!mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0), mysql_error(mysql));
+  diag("%s", mysql_get_ssl_cipher(mysql));
+  mysql_close(mysql);
+
+  return OK;
+}
+
+
+static int test_conc50(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, NULL, NULL, "./non_exisiting_cert.pem", NULL, NULL);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  diag("Error: %d %s", mysql_errno(mysql), mysql_error(mysql));
+  FAIL_IF(mysql_errno(mysql) != 2026, "Expected errno 2026");
+  mysql_close(mysql);
+
+  return OK;
+}
+
+static int test_conc50_1(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  if (!have_openssl)
+  {
+    diag("Server with OpenSSL required");
+    return SKIP;
+  }
+
+  create_ssl_user(ssluser, 0);
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, NULL, NULL, sslca, NULL, NULL);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  if (mysql_errno(mysql))
+    diag("Error: %d %s", mysql_errno(mysql), mysql_error(mysql));
+  FAIL_IF(mysql_errno(mysql), "No error expected");
+
+  mysql_close(mysql);
+
+  return OK;
+}
+
+static int test_conc50_2(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, NULL, NULL, "./non_exisiting_cert.pem", NULL, NULL);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  FAIL_IF(mysql_errno(mysql) != 2026, "Expected errno 2026");
+  mysql_close(mysql);
+
+  return OK;
+}
+
+static int test_conc127(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+
+  diag("test disabled - for testing disable other tests or run this test as first test");
+  return SKIP;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, NULL, NULL, "./non_exisiting.pem", NULL, NULL);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  diag("Error: %s", mysql_error(mysql));
+  FAIL_IF(mysql_errno(mysql) == 0, "Error expected (invalid certificate)");
+  mysql_close(mysql);
+
+  return OK;
+}
+
+static int test_conc50_3(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  create_ssl_user(ssluser, 0);
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  FAIL_IF(!mysql_errno(mysql), "Error expected, SSL connection required!");
+  mysql_close(mysql);
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, NULL, NULL, sslca, NULL, NULL);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  diag("Error: %s<", mysql_error(mysql));
+  FAIL_IF(mysql_errno(mysql), "No error expected");
+  mysql_close(mysql);
+
+  return OK;
+}
+
+static int test_conc50_4(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, NULL, sslca, NULL, NULL, NULL);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  FAIL_IF(!mysql_errno(mysql) , "Error expected");
+  mysql_close(mysql);
+
+  return OK;
+}
+
+static int verify_ssl_server_cert(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+  uint verify= 1;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  if (!hostname || !strcmp(hostname, "localhost"))
+    return SKIP;
+
+  SKIP_TRAVIS();
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, NULL, NULL, sslca, NULL, NULL);
+  mysql_options(mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, &verify);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+
+  FAIL_IF(!mysql_errno(mysql), "Expected error");
+  diag("Error (expected): %s", mysql_error(mysql));
+  mysql_close(mysql);
+
+  return OK;
+}
+
+static int test_bug62743(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, "dummykey", NULL, NULL, NULL, NULL);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  diag("Error: %s", mysql_error(mysql));
+  FAIL_IF(mysql_errno(mysql) != 2026, "Expected errno 2026");
+  mysql_close(mysql);
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, sslkey, NULL, NULL, NULL, NULL);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  diag("Error with key: %s", mysql_error(mysql));
+  FAIL_IF(mysql_errno(mysql) != 2026, "Expected errno 2026");
+  mysql_close(mysql);
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, sslkey,
+                       sslcert, NULL, NULL, NULL);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  FAIL_IF(mysql_errno(mysql) != 0, "Expected no error");
+  mysql_close(mysql);
+
+  mysql= mysql_init(NULL);
+  FAIL_IF(!mysql, "Can't allocate memory");
+
+  mysql_ssl_set(mysql, sslkey, "blablubb", NULL, NULL, NULL);
+
+  mysql_real_connect(mysql, hostname, ssluser, sslpw, schema,
+           ssl_port, socketname, 0);
+  diag("Error with cert: %s", mysql_error(mysql));
+  FAIL_IF(mysql_errno(mysql) == 0, "Expected error");
+  mysql_close(mysql);
+
+  return OK;
+}
+
+#ifndef WIN32
+int thread_conc102(void)
+#else
+DWORD WINAPI thread_conc102(void)
+#endif
+{
+  MYSQL *mysql;
+  int rc;
+  MYSQL_RES *res;
+  mysql_thread_init();
+  mysql= mysql_init(NULL);
+
+  mysql_ssl_set(mysql, sslkey,
+                       sslcert,
+                       sslca,
+                        NULL, NULL);
+  mysql_ssl_set(mysql,0, 0, sslca, 0, 0);
+
+  if(!mysql_real_connect(mysql, hostname, username, password, schema,
+          ssl_port, socketname, 0))
+  {
+    diag(">Error: %s", mysql_error(mysql));
+    goto end;
+  }
+  if (!mysql_get_ssl_cipher(mysql))
+  {
+    diag("Error: No ssl connection");
+    goto end;
+  }
+  pthread_mutex_lock(&LOCK_test);
+  rc= mysql_query(mysql, "UPDATE t_conc102 SET a=a+1");
+  check_mysql_rc(rc, mysql);
+  pthread_mutex_unlock(&LOCK_test);
+  check_mysql_rc(rc, mysql);
+  if ((res= mysql_store_result(mysql)))
+    mysql_free_result(res);
+end:
+  mysql_close(mysql);
+  mysql_thread_end();
+  return 0;
+}
+
+static int test_conc_102(MYSQL *mysql)
+{
+
+  int rc;
+  int i;
+  MYSQL_ROW row;
+  MYSQL_RES *res;
+#ifndef WIN32
+  pthread_t threads[50];
+#else
+  HANDLE hthreads[50];
+  DWORD threads[50];
+#endif
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t_conc102");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t_conc102 ( a int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t_conc102 VALUES (0)");
+  check_mysql_rc(rc, mysql);
+  pthread_mutex_init(&LOCK_test, NULL);
+
+  for (i=0; i < 50; i++)
+  {
+#ifndef WIN32
+    pthread_create(&threads[i], NULL, (void *)thread_conc102, NULL);
+#else
+    hthreads[i]= CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread_conc102, NULL, 0, &threads[i]);
+    if (hthreads[i]==NULL)
+      diag("error while starting thread");
+#endif
+  }
+  for (i=0; i < 50; i++)
+  {
+#ifndef WIN32
+    pthread_join(threads[i], NULL);
+#else
+    WaitForSingleObject(hthreads[i], INFINITE);
+#endif
+  } 
+  pthread_mutex_destroy(&LOCK_test);
+  rc= mysql_query(mysql, "SELECT a FROM t_conc102");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  row= mysql_fetch_row(res);
+  diag("Found: %s", row[0]);
+  FAIL_IF(strcmp(row[0], "50") != 0, "Expected 50");
+  mysql_free_result(res);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t_conc102");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_ssl_fp(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *my;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  int rc;
+  
+  if (check_skip_ssl())
+    return SKIP;
+
+  my= mysql_init(NULL);
+  FAIL_IF(!my, "mysql_init() failed");
+
+  mysql_ssl_set(my,0, 0, sslca, 0, 0);
+
+  mysql_options(my, MARIADB_OPT_SSL_FP, bad_cert_finger_print);
+
+  FAIL_IF(mysql_real_connect(my, hostname, username, password, schema,
+                             ssl_port, socketname, 0), mysql_error(my));
+
+  mysql_options(my, MARIADB_OPT_SSL_FP, ssl_cert_finger_print);
+
+  FAIL_IF(!mysql_real_connect(my, hostname, username, password, schema,
+                         ssl_port, socketname, 0), mysql_error(my));
+  
+  FAIL_IF(check_cipher(my) != 0, "Invalid cipher");
+
+  rc= mysql_query(my, "SET @a:=1");
+  check_mysql_rc(rc, my);
+
+  rc= mysql_query(my, "SELECT @a");
+  check_mysql_rc(rc, my);
+
+  if ((res= mysql_store_result(my)))
+  {
+    row= mysql_fetch_row(res);
+    diag("@a:=%s", row[0]);
+    mysql_free_result(res);
+  }
+
+  mysql_close(my);
+  return OK;
+}
+
+static int test_ssl_fp_list(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *my;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  my= mysql_init(NULL);
+  FAIL_IF(!my, "mysql_init() failed");
+
+  mysql_ssl_set(my,0, 0, sslca, 0, 0);
+
+  mysql_options(my, MARIADB_OPT_SSL_FP_LIST, CERT_PATH "/server-cert.sha1");
+
+  if(!mysql_real_connect(my, hostname, username, password, schema,
+                         ssl_port, socketname, 0))
+  {
+    diag("Error: %s", mysql_error(my));
+    mysql_close(my);
+    return FAIL;
+  }
+
+  FAIL_IF(check_cipher(my) != 0, "Invalid cipher");
+  mysql_close(my);
+  return OK;
+}
+
+static int test_ssl_version(MYSQL *unused __attribute__((unused)))
+{
+  unsigned int iversion;
+  char *version, *library;
+  MYSQL *my;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  my= mysql_init(NULL);
+  FAIL_IF(!my, "mysql_init() failed");
+
+  mysql_ssl_set(my,0, 0, sslca, 0, 0);
+  FAIL_IF(!mysql_real_connect(my, hostname, ssluser, sslpw, schema,
+                         ssl_port, socketname, 0), mysql_error(my));
+
+  diag("cipher: %s", mysql_get_ssl_cipher(my));
+  mariadb_get_infov(my, MARIADB_CONNECTION_TLS_VERSION_ID, &iversion);
+  diag("protocol: %d", iversion);
+  mariadb_get_infov(my, MARIADB_CONNECTION_TLS_VERSION, &version);
+  diag("protocol: %s", version);
+
+  mariadb_get_infov(my, MARIADB_TLS_LIBRARY, &library);
+  diag("library: %s", library);
+
+  mysql_close(my);
+
+  return OK;
+}
+
+#ifdef HAVE_SCHANNEL
+static int test_schannel_cipher(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *my;
+  unsigned int cipher_strength= 256;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  my= mysql_init(NULL);
+  FAIL_IF(!my, "mysql_init() failed");
+
+  mysql_ssl_set(my,0, 0, sslca, 0, 0);
+  mysql_options(my, MARIADB_OPT_TLS_CIPHER_STRENGTH, &cipher_strength);
+  FAIL_IF(!mysql_real_connect(my, hostname, ssluser, sslpw, schema,
+                         ssl_port, socketname, 0), mysql_error(my));
+
+  diag("cipher: %s", mysql_get_ssl_cipher(my));
+
+  mysql_close(my);
+
+  return OK;
+}
+
+#endif
+
+#if defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
+
+static int test_cipher_mapping(MYSQL *unused __attribute__((unused)))
+{
+  unsigned int i=0;
+  const char *ciphers[]= { "DHE-RSA-AES256-GCM-SHA384", "DHE-RSA-AES256-SHA256", "DHE-RSA-AES256-SHA",
+#ifdef TEST_CAMELLIA_CIPHER
+                           "DHE-RSA-CAMELLIA256-SHA", "CAMELLIA256-SHA",
+                           "DHE-RSA-CAMELLIA128-SHA", "CAMELLIA128-SHA",
+#endif
+#ifdef TEST_DES_CIPHER
+                           "EDH-RSA-DES-CBC3-SHA",
+                           "DES-CBC3-SHA",
+#endif
+                           "AES256-GCM-SHA384", "AES256-SHA256", "AES256-SHA",
+                           "DHE-RSA-AES128-GCM-SHA256", "DHE-RSA-AES128-SHA256", "DHE-RSA-AES128-SHA",
+                           "AES128-GCM-SHA256", "AES128-SHA256", "AES128-SHA",
+                           "DHE-RSA-AES256-SHA", "AES256-SHA",
+                           NULL };
+
+  diag("This test depends on OpenSSL version - since several ciphers might not be available");
+  return SKIP;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  if (!have_openssl)
+  {
+    diag("test requires Server with OpenSSL");
+    return SKIP;
+  }
+
+  while (ciphers[i] != NULL)
+  {
+    MYSQL *mysql= mysql_init(NULL);
+    MYSQL_ROW row;
+    MYSQL_RES *res;
+    char c[100];
+    int rc;
+    const char *cipher;
+
+    mysql_options(mysql, MYSQL_OPT_TLS_VERSION, "TLSv1.0,TLSv1.1,TLSv1.2");
+    mysql_ssl_set(mysql, NULL, NULL, NULL, NULL, ciphers[i]);
+    diag("%s", ciphers[i]);
+    
+    mysql->options.use_ssl= 1;
+    FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+                         ssl_port, socketname, 0), mysql_error(mysql));
+    if (!(cipher= mysql_get_ssl_cipher(mysql)) ||
+        strcmp(ciphers[i], cipher) != 0)
+    {
+      diag("cipher %s differs: (%s)", ciphers[i], cipher);
+      mysql_close(mysql);
+      goto cont;
+    }
+    else
+    {
+      rc= mysql_query(mysql, "SHOW STATUS LIKE 'ssl_cipher'");
+      check_mysql_rc(rc, mysql);
+      res= mysql_store_result(mysql);
+      row= mysql_fetch_row(res);
+      strcpy(c, row[1]);
+      mysql_free_result(res);
+      mysql_close(mysql);
+      if (strcmp(ciphers[i], c) != 0)
+      {
+        diag("expected: %s instead of %s", ciphers[i], c);
+        /* depending if server supports ECC, ciphers may differ,
+           so we don't return failure here */
+      }
+    }
+cont:
+    i++;
+  }
+  return OK;
+}
+#endif  
+
+static int test_openssl_1(MYSQL *mysql)
+{
+  int rc;
+  MYSQL *my;
+  uchar val= 1;
+  char query[1024];
+  int i;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  if (have_tls13)
+    return SKIP;
+
+  if (!mariadb_connection(mysql))
+    return SKIP;
+
+  for (i=1; i < 6; i++)
+  {
+    sprintf(query, "DROP USER 'ssluser%d'@'%s'", i, this_host);
+    rc= mysql_query(mysql, query);
+    sprintf(query, "CREATE USER 'ssluser%d'@'%s'", i, this_host);
+    rc= mysql_query(mysql, query);
+    check_mysql_rc(rc, mysql);
+  }
+  rc= mysql_query(mysql, "FLUSH PRIVILEGES");
+  check_mysql_rc(rc, mysql);
+  diag("sslusers created");
+
+  diag("ssluser1");
+  sprintf(query, "grant select on %s.* to 'ssluser1'@'%s' require ssl", schema, this_host);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+
+  my= mysql_init(NULL);
+  mysql_ssl_set(my, NULL, NULL, NULL, NULL, "AES128-SHA");
+  FAIL_IF(!mysql_real_connect(my, hostname, "ssluser1", NULL, schema,
+                         ssl_port, socketname, 0), mysql_error(my));
+  FAIL_IF(!mysql_get_ssl_cipher(my), "No TLS connection");
+  mysql_close(my);
+
+  my= mysql_init(NULL);
+  mysql_options(my, MYSQL_OPT_SSL_ENFORCE, &val);
+  FAIL_IF(!mysql_real_connect(my, hostname, "ssluser1", NULL, schema,
+                         ssl_port, socketname, 0), mysql_error(my));
+  FAIL_IF(!mysql_get_ssl_cipher(my), "No TLS connection");
+  mysql_close(my);
+
+  diag("ssluser2");
+  sprintf(query, "grant select on %s.* to 'ssluser2'@'%s' require cipher 'AES256-SHA'", schema, this_host);
+  rc= mysql_query(mysql, query);
+  check_mysql_rc(rc, mysql);
+
+#ifdef TEST_RANDOM_RESULT
+/* ssl_user2: connect with enforce should work */
+  my= mysql_init(NULL);
+  mysql_options(my, MYSQL_OPT_SSL_ENFORCE, &val);
+  mysql_real_connect(my, hostname, "ssluser2", NULL, schema,
+                         ssl_port, socketname, 0);
+  if (!mysql_error(my) &&
+       strcmp(mysql_get_ssl_cipher(my), "AES256-SHA"))
+  {
+    diag("Expected error or correct cipher");
+    return FAIL;
+  }
+  mysql_close(my);
+#endif
+  /* ssl_user2: connect with correct cipher */
+  diag("ssluser2");
+  if (mysql_get_server_version(mysql) >= 100100)
+  {
+    my= mysql_init(NULL);
+    mysql_ssl_set(my, NULL, NULL, NULL, NULL, "AES256-SHA");
+    FAIL_IF(!mysql_real_connect(my, hostname, "ssluser2", NULL, schema,
+                           ssl_port, socketname, 0), mysql_error(my));
+    FAIL_IF(strcmp("AES256-SHA", mysql_get_ssl_cipher(my)) != 0, "expected cipher AES256-SHA");
+    mysql_close(my);
+  }
+
+  /* ssl_user2: connect with wrong cipher should not work */
+  diag("ssluser2");
+  my= mysql_init(NULL);
+  mysql_ssl_set(my, NULL, NULL, NULL, NULL, "AES128-SHA");
+  FAIL_IF(mysql_real_connect(my, hostname, "ssluser2", NULL, schema,
+                         ssl_port, socketname, 0), "Error expected");
+  mysql_close(my);
+
+
+  if (!travis_test)
+  {
+    sprintf(query, "grant select on %s.* to 'ssluser3'@'%s' require cipher 'AES256-SHA' AND "
+                 " SUBJECT '/C=FI/ST=Helsinki/L=Helsinki/O=MariaDB/CN=client'", schema, this_host);
+    rc= mysql_query(mysql, query);
+    check_mysql_rc(rc, mysql);
+
+    /* ssluser3: connect with cipher only */
+    my= mysql_init(NULL);
+    mysql_ssl_set(my, NULL, NULL, NULL, NULL, "AES256-SHA");
+    FAIL_IF(mysql_real_connect(my, hostname, "ssluser3", NULL, schema,
+                               ssl_port, socketname, 0), "Error expected");
+    mysql_close(my);
+
+    /* ssluser3 connect with cipher and certs */
+    my= mysql_init(NULL);
+    mysql_ssl_set(my, sslkey, 
+                  sslcert, 
+                  sslca, 
+                  NULL, 
+                  "AES256-SHA");
+    FAIL_IF(!mysql_real_connect(my, hostname, "ssluser3", NULL, schema,
+                           ssl_port, socketname, 0), mysql_error(my));
+
+    mysql_close(my);
+
+    sprintf(query, "grant select on %s.* to 'ssluser4'@'%s' require cipher 'AES256-SHA' AND "
+                   " ISSUER '/CN=cacert/C=FI/ST=Helsinki/L=Helsinki/O=MariaDB'", schema, this_host);
+    rc= mysql_query(mysql, query);
+    check_mysql_rc(rc, mysql);
+
+    /* ssluser4: connect with cipher only */
+    my= mysql_init(NULL);
+    mysql_ssl_set(my, NULL, NULL, NULL, NULL, "AES256-SHA");
+    FAIL_IF(mysql_real_connect(my, hostname, "ssluser4", NULL, schema,
+                           ssl_port, socketname, 0), "Error expected");
+    mysql_close(my);
+
+    /* ssluser4 connect with cipher and certs */
+    my= mysql_init(NULL);
+    mysql_ssl_set(my, sslkey,
+                  sslcert,
+                  sslca,
+                  NULL,
+                  "AES256-SHA");
+    FAIL_IF(!mysql_real_connect(my, hostname, "ssluser4", NULL, schema,
+                           ssl_port, socketname, 0), mysql_error(my));
+    mysql_close(my);
+  }
+  diag("drop users");
+  for (i=1; i < 6; i++)
+  {
+    sprintf(query, "DROP USER 'ssluser%d'@'%s'", i, this_host);
+    rc= mysql_query(mysql, query);
+  }
+
+  return OK;
+}
+
+static int test_ssl_timeout(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql;
+  my_bool enforce= 1;
+  int read_timeout= 1;
+  int rc;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_OPT_SSL_ENFORCE, &enforce);
+  mysql_options(mysql, MYSQL_OPT_READ_TIMEOUT, &read_timeout);
+  mysql->options.use_ssl= 1;
+  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+                         ssl_port, socketname, 0), mysql_error(mysql));
+  diag("cipher: %s\n", mysql_get_ssl_cipher(mysql));
+  rc= mysql_query(mysql, "SELECT SLEEP(600)");
+  if (!rc)
+  {
+    diag("error expected (timeout)");
+    return FAIL;
+  }
+
+  mysql_close(mysql);
+  return OK;
+}
+
+static int drop_ssl_user(MYSQL *mysql)
+{
+  int rc;
+
+  rc= mysql_query(mysql, "DELETE FROM mysql.user where user like 'ssl%'");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DELETE FROM mysql.db where user like 'ssl%'");
+  check_mysql_rc(rc, mysql);
+  return OK;
+}
+
+static int test_conc286(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *my;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  my= mysql_init(NULL);
+  FAIL_IF(!my, "mysql_init() failed");
+
+  mysql_options(my, MARIADB_OPT_SSL_FP, ssl_cert_finger_print);
+
+  FAIL_IF(!mysql_real_connect(my, hostname, username, password, schema,
+                         ssl_port, socketname, 0), mysql_error(my));
+  
+  FAIL_IF(check_cipher(my) != 0, "Invalid cipher");
+
+  mysql_close(my);
+  return OK;
+}
+
+static int test_mdev14027(MYSQL *mysql __attribute__((unused)))
+{
+  char *tls_library;
+  const char *check_library=
+#if defined(HAVE_OPENSSL)
+#if defined(HAVE_LIBRESSL)
+    "LibreSSL";
+#else
+    "OpenSSL";
+#endif
+#elif defined(HAVE_GNUTLS)
+    "GnuTLS";
+#elif defined(HAVE_SCHANNEL)
+    "Schannel";
+#else
+    "Off";
+#endif
+  mariadb_get_infov(NULL, MARIADB_TLS_LIBRARY, &tls_library);
+  diag("TLS/SSL library in use: %s\n", tls_library);
+  if (!strstr(tls_library, check_library))
+  {
+    diag("expected %s, got %s", check_library, tls_library);
+    return FAIL;
+  }
+  return OK;
+}
+
+static int test_mdev14101(MYSQL *my __attribute__((unused)))
+{
+  struct {
+    bool do_yassl;
+    const char *opt_tls_version;
+    const char *expected;
+  } combinations[]= {
+    {1, "TLSv1.1", "TLSv1.1"},
+    {1, "TLSv1,TLSv1.1", "TLSv1.1"},
+    {0, "TLSv1.2", "TLSv1.2"},
+    {0, "TLSv1.1,TLSv1.2", "TLSv1.2"},
+    {1, NULL, NULL}
+  };
+
+  int i;
+#ifdef HAVE_SCHANNEL
+  bool skip_tlsv12= 1;
+#else
+  bool skip_tlsv12= !have_openssl;
+#endif
+
+#if defined(HAVE_OPENSSL) && defined(TLS1_3_VERSION)
+  diag("Test fails with TLS v1.3");
+  return(SKIP);
+#endif
+
+  for (i=0; combinations[i].expected; i++)
+  {
+    MYSQL *mysql;
+    bool val=1;
+    char *tls_version;
+
+    if (!combinations[i].do_yassl && skip_tlsv12)
+      break;
+
+    diag("combination %d: %s", i, combinations[i].opt_tls_version);
+
+    mysql= mysql_init(NULL);
+    mysql_options(mysql, MYSQL_OPT_SSL_ENFORCE, &val);
+    mysql_options(mysql, MARIADB_OPT_TLS_VERSION, combinations[i].opt_tls_version);
+    FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+                         ssl_port, socketname, 0), mysql_error(mysql));
+    mariadb_get_infov(mysql, MARIADB_CONNECTION_TLS_VERSION, &tls_version);
+    diag("options: %s", combinations[i].opt_tls_version);
+    diag("protocol: %s expected: %s", tls_version, combinations[i].expected);
+    FAIL_IF(strcmp(combinations[i].expected, tls_version), "Wrong tls_version");
+    mysql_close(mysql);
+  }
+  return OK;
+}
+
+static int test_conc386(MYSQL *mysql)
+{
+  mysql= mysql_init(NULL);
+  mysql_ssl_set(mysql,
+                sslcombined,
+                NULL,
+                NULL,
+                NULL,
+                NULL);
+  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+                         ssl_port, socketname, 0), mysql_error(mysql));
+  FAIL_IF(check_cipher(mysql) != 0, "Invalid cipher");
+  mysql_close(mysql);
+  return OK;
+}
+
+#ifndef HAVE_SCHANNEL
+static int test_ssl_verify(MYSQL *my __attribute__((unused)))
+{
+  MYSQL *mysql;
+  my_bool verify= 1, enforce= 1;
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  /* verify, using system ca should fail with self signed certificate */
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_OPT_SSL_ENFORCE, &enforce);
+  mysql_options(mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, &verify);
+  FAIL_IF(mysql_real_connect(mysql, hostname, username, password, schema,
+                         ssl_port, socketname, 0), "Error expected");
+  diag("error expected: %s\n", mysql_error(mysql));
+  mysql_close(mysql);
+
+  /* verify, using system ca should pass */
+
+  /* Disable this for now, since for some unknown reason it fails on travis
+  setenv("SSL_CERT_DIR", CERT_PATH, 1);
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_OPT_SSL_ENFORCE, &enforce);
+  mysql_options(mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, &verify);
+  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(mysql));
+  mysql_close(mysql);
+  unsetenv("SSL_CERT_DIR");
+  */
+
+  /* verify against local ca, this should pass */
+  mysql= mysql_init(NULL);
+  mysql_ssl_set(mysql,0, 0, sslca, 0, 0);
+  mysql_options(mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, &verify);
+  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+                         ssl_port, socketname, 0), mysql_error(mysql));
+  mysql_close(mysql);
+
+  mysql= mysql_init(NULL);
+  mysql_options(mysql, MYSQL_OPT_SSL_ENFORCE, &enforce);
+  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+                         ssl_port, socketname, 0), mysql_error(mysql));
+
+  diag("cipher: %s", mysql_get_ssl_cipher(mysql));
+  mysql_close(mysql);
+  return OK;
+}
+#endif
+
+struct my_tests_st my_tests[] = {
+  {"test_ssl", test_ssl, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+#ifndef HAVE_SCHANNEL
+  {"test_ssl_verify", test_ssl_verify, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+#endif
+  {"test_mdev14101", test_mdev14101, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_mdev14027", test_mdev14027, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_conc286", test_conc286, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_ssl_timeout", test_ssl_timeout, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_openssl_1", test_openssl_1, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+#ifndef HAVE_SCHANNEL
+  {"test_cipher_mapping", test_cipher_mapping, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+#endif
+  {"test_conc127", test_conc127, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+/* Both tests work with GNU tls, however we can't create fingerprints with
+   gnutls-cli in CMakeLists.txt */
+#ifndef HAVE_SCHANNEL
+  {"test_ssl_fp", test_ssl_fp, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_ssl_fp_list", test_ssl_fp_list, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+#endif
+  {"test_conc50", test_conc50, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_conc50_1", test_conc50_1, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_conc50_2", test_conc50_2, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_conc50_3", test_conc50_3, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_conc50_4", test_conc50_4, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_conc95", test_conc95, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"verify_ssl_server_cert", verify_ssl_server_cert, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_bug62743", test_bug62743, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"test_phpbug51647", test_phpbug51647, TEST_CONNECTION_NONE, 0, NULL, NULL},
+  {"test_ssl_cipher", test_ssl_cipher, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {"test_multi_ssl_connections", test_multi_ssl_connections, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {"test_conc_102", test_conc_102, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_ssl_version", test_ssl_version, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_ssl_threads", test_ssl_threads, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+#ifndef HAVE_SCHANNEL
+  {"test_password_protected", test_password_protected, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+#else
+  {"test_schannel_cipher", test_schannel_cipher, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+#endif
+  {"test_conc386", test_conc386, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {"drop_ssl_user", drop_ssl_user, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+
+int main(int argc, char **argv)
+{
+#if defined(WIN32) && defined(HEAP_CHECK)
+   _CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
+   _CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDOUT );
+   _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
+   _CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDOUT );
+   _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
+   _CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDOUT );
+#endif
+
+  get_envvars();
+  read_fingerprint();
+
+  if (argc > 1)
+    get_options(argc, argv);
+  run_tests(my_tests);
+
+  mysql_server_end();
+#if defined(WIN32) && defined(HEAP_CHECK)
+  _CrtDumpMemoryLeaks();
+#endif
+  return(exit_status());
+}
+
diff --git a/libmariadb/unittest/libmariadb/t_aurora.c b/libmariadb/unittest/libmariadb/t_aurora.c
new file mode 100644
index 00000000..655b84e1
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/t_aurora.c
@@ -0,0 +1,164 @@
+/*
+*/
+
+#include "my_test.h"
+#include "ma_pvio.h"
+
+static int aurora1(MYSQL *unused __attribute__((unused)))
+{
+  int rc;
+  my_bool read_only= 1;
+  char *primary, *my_schema;
+  MYSQL_RES *res;
+  MYSQL *mysql= mysql_init(NULL);
+
+  if (!mysql_real_connect(mysql, hostname, username, password, schema, port, NULL, 0))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+    return FAIL;
+  }
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int, b varchar(20))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1, 'foo'), (2, 'bar')");
+  check_mysql_rc(rc, mysql);
+
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_HOST, &primary);
+  diag("primary: %s", primary);
+
+  mysql_options(mysql, MARIADB_OPT_CONNECTION_READ_ONLY, &read_only);
+
+  /* ensure, that this is a replica, so INSERT should fail */
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (3, 'error')");
+  if (rc)
+    diag("Expected error: %s", mysql_error(mysql));
+
+  rc= mysql_query(mysql, "SELECT a, b FROM t1");
+  check_mysql_rc(rc, mysql);
+
+  res= mysql_store_result(mysql);
+
+  diag("Num_rows: %lld", mysql_num_rows(res));
+  mysql_free_result(res);
+
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_SCHEMA, &my_schema);
+  diag("db: %s", my_schema);
+
+  mysql_close(mysql);
+
+  return OK;
+}
+
+static int test_wrong_user(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql= mysql_init(NULL);
+
+  if (mysql_real_connect(mysql, hostname, "wrong_user", NULL, NULL, 0, NULL, 0))
+  {
+    diag("Error expected");
+    mysql_close(mysql);
+    return FAIL;
+  }
+  mysql_close(mysql);
+  return OK;
+}
+
+static int test_reconnect(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL *mysql= mysql_init(NULL);
+  MYSQL_RES *res;
+  my_bool read_only= 1;
+  int rc;
+  my_bool reconnect= 1;
+  char *aurora_host;
+
+  mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+
+  if (!mysql_real_connect(mysql, hostname, username, password, schema, port, NULL, 0))
+  {
+    diag("Error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+    return FAIL;
+  }
+
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_HOST, &aurora_host);
+  diag("host: %s", aurora_host);
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS tx01");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE tx01 (a int)");
+  check_mysql_rc(rc, mysql);
+
+  /* we force cluster restart and promoting new primary:
+   * we wait for 50 seconds - however there is no guarantee that
+   * cluster was restarted already - so this test might fail */
+  rc= system("/usr/local/aws/bin/aws rds failover-db-cluster --db-cluster-identifier instance-1-cluster");
+
+  diag("aws return code: %d", rc);
+
+  sleep(50);
+  diag("Q1");
+  rc= mysql_query(mysql, "INSERT INTO tx01 VALUES (1)");
+  if (!rc)
+    diag("error expected!");
+  diag("Error: %s", mysql_error(mysql));
+
+  diag("Q2");
+  rc= mysql_query(mysql, "INSERT INTO tx01 VALUES (1)");
+  if (rc)
+  {  
+    diag("no error expected!");
+    diag("Error: %s", mysql_error(mysql));
+    diag("host: %s", mysql->host);
+  }
+  else
+  {
+    mariadb_get_infov(mysql, MARIADB_CONNECTION_HOST, &aurora_host);
+    diag("host: %s", aurora_host);
+  }
+
+  mysql_options(mysql, MARIADB_OPT_CONNECTION_READ_ONLY, &read_only);
+
+  rc= mysql_query(mysql, "SELECT * from tx01");
+  check_mysql_rc(rc, mysql);
+
+  if ((res= mysql_store_result(mysql)))
+  {
+    diag("num_rows: %lld", mysql_num_rows(res));
+    mysql_free_result(res);
+  }
+
+  mariadb_get_infov(mysql, MARIADB_CONNECTION_HOST, &aurora_host);
+  diag("host: %s", aurora_host);
+
+  mysql_close(mysql); 
+  return OK;
+}
+
+struct my_tests_st my_tests[] = {
+  {"aurora1", aurora1, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {"test_wrong_user", test_wrong_user, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {"test_reconnect", test_reconnect, TEST_CONNECTION_NONE, 0, NULL, NULL}, 
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+
+int main(int argc, char **argv)
+{
+  mysql_library_init(0,0,NULL);
+
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  mysql_server_end();
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/t_conc173.c b/libmariadb/unittest/libmariadb/t_conc173.c
new file mode 100644
index 00000000..0bcaebcc
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/t_conc173.c
@@ -0,0 +1,72 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+/**
+  Some basic tests of the client API.
+*/
+
+#include "my_test.h"
+
+static int test_conc_173(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL mysql;
+  int arg;
+  int i=0;
+
+  for (;;)
+  {
+    mysql_init(&mysql);
+    mysql_options(&mysql, MYSQL_READ_DEFAULT_GROUP, "client");
+    mysql_options(&mysql, MYSQL_OPT_COMPRESS, 0);
+
+    mysql_options(&mysql, MYSQL_OPT_NAMED_PIPE, 0);
+
+    arg = MYSQL_PROTOCOL_SOCKET;
+
+    mysql_options(&mysql, MYSQL_OPT_PROTOCOL, &arg);
+
+    if(!mysql_real_connect(&mysql, hostname, username, password, schema, 0, 0, 0))  {
+      fprintf(stderr, "Failed to connect to database after %d iterations: Error: %s\n", i, mysql_error(&mysql));
+      return 1;
+    }
+    mysql_close(&mysql);
+  }
+  return OK;
+}
+
+struct my_tests_st my_tests[] = {
+  {"test_conc_173", test_conc_173, TEST_CONNECTION_DEFAULT, 0, NULL,  NULL},
+};
+
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/thread.c b/libmariadb/unittest/libmariadb/thread.c
new file mode 100644
index 00000000..6fae38a8
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/thread.c
@@ -0,0 +1,180 @@
+/*
+*/
+
+#include "my_test.h"
+#include <ma_pthread.h>
+
+static int basic_connect(MYSQL *unused __attribute__((unused)))
+{
+  MYSQL_ROW row;
+  MYSQL_RES *res;
+  MYSQL_FIELD *field;
+  int rc;
+
+  MYSQL *my= mysql_init(NULL);
+  FAIL_IF(!my, "mysql_init() failed");
+
+  FAIL_IF(!my_test_connect(my, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(my));
+
+  rc= mysql_query(my, "SELECT @@version");
+  check_mysql_rc(rc, my);
+
+  res= mysql_store_result(my);
+  FAIL_IF(!res, mysql_error(my));
+  field= mysql_fetch_fields(res);
+  FAIL_IF(!field, "Couldn't fetch fields");
+
+  while ((row= mysql_fetch_row(res)) != NULL)
+  {
+    FAIL_IF(mysql_num_fields(res) != 1, "Got the wrong number of fields");
+  }
+  FAIL_IF(mysql_errno(my), mysql_error(my));
+
+  mysql_free_result(res);
+  mysql_close(my);
+
+
+  return OK;
+}
+
+pthread_mutex_t LOCK_test;
+
+#ifndef _WIN32
+int thread_conc27(void);
+#else
+DWORD WINAPI thread_conc27(void);
+#endif
+
+#define THREAD_NUM 100 
+
+/* run this test as root and increase the number of handles (ulimit -n) */
+static int test_conc_27(MYSQL *mysql)
+{
+
+  int rc;
+  int i;
+  MYSQL_ROW row;
+  MYSQL_RES *res;
+#ifndef _WIN32
+  pthread_t threads[THREAD_NUM];
+#else
+  HANDLE hthreads[THREAD_NUM];
+  DWORD threads[THREAD_NUM];
+#endif
+
+  diag("please run this test manually as root");
+  return SKIP;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t_conc27");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "CREATE TABLE t_conc27(a int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "INSERT INTO t_conc27 VALUES(0)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SET @a:=@@max_connections");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SET GLOBAL max_connections=100000");
+  check_mysql_rc(rc, mysql);
+
+  pthread_mutex_init(&LOCK_test, NULL);
+  for (i=0; i < THREAD_NUM; i++)
+  {
+#ifndef _WIN32
+    pthread_create(&threads[i], NULL, (void *)thread_conc27, NULL);
+#else
+    hthreads[i]= CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread_conc27, NULL, 0, &threads[i]);
+    if (hthreads[i]==NULL)
+      diag("error while starting thread");
+#endif
+  }
+  for (i=0; i < THREAD_NUM; i++)
+  {
+#ifndef _WIN32
+    pthread_join(threads[i], NULL);
+#else
+    WaitForSingleObject(hthreads[i], INFINITE);
+#endif
+  }
+
+  pthread_mutex_destroy(&LOCK_test);
+ 
+  rc= mysql_query(mysql, "SET GLOBAL max_connections=@a");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT a FROM t_conc27");
+  check_mysql_rc(rc,mysql);
+
+  res= mysql_store_result(mysql);
+  FAIL_IF(!res, "invalid result");
+
+  row= mysql_fetch_row(res);
+  FAIL_IF(!row, "can't fetch row");
+
+  diag("row=%s", row[0]);
+  FAIL_IF(atoi(row[0]) != THREAD_NUM, "expected value THREAD_NUM");
+  mysql_free_result(res);
+  rc= mysql_query(mysql, "DROP TABLE t_conc27");
+  check_mysql_rc(rc,mysql);
+
+  return OK;
+}
+
+#ifndef _WIN32
+int thread_conc27(void)
+#else
+DWORD WINAPI thread_conc27(void)
+#endif
+{
+  MYSQL *mysql;
+  int rc;
+  MYSQL_RES *res;
+  mysql_thread_init();
+  mysql= mysql_init(NULL);
+  if(!my_test_connect(mysql, hostname, username, password, schema,
+          port, socketname, 0))
+  {
+    diag(">Error: %s", mysql_error(mysql));
+    mysql_close(mysql);
+    mysql_thread_end();
+    goto end;
+  }
+  pthread_mutex_lock(&LOCK_test);
+  rc= mysql_query(mysql, "UPDATE t_conc27 SET a=a+1");
+  check_mysql_rc(rc, mysql);
+  pthread_mutex_unlock(&LOCK_test);
+  check_mysql_rc(rc, mysql);
+  if ((res= mysql_store_result(mysql)))
+    mysql_free_result(res);
+  mysql_close(mysql);
+end:
+  mysql_thread_end();
+  return 0;
+}
+
+struct my_tests_st my_tests[] = {
+  {"basic_connect", basic_connect, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+  {"test_conc_27", test_conc_27, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+
+int main(int argc, char **argv)
+{
+
+  mysql_library_init(0,0,NULL);
+
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  mysql_server_end();
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/libmariadb/view.c b/libmariadb/unittest/libmariadb/view.c
new file mode 100644
index 00000000..10d6f3ef
--- /dev/null
+++ b/libmariadb/unittest/libmariadb/view.c
@@ -0,0 +1,697 @@
+/*
+Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+
+The MySQL Connector/C is licensed under the terms of the GPLv2
+<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
+MySQL Connectors. There are special exceptions to the terms and
+conditions of the GPLv2 as it is applied to this software, see the
+FLOSS License Exception
+<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published
+by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+#include "my_test.h"
+
+static int test_view(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  MYSQL_BIND      my_bind[1];
+  char            str_data[50];
+  ulong           length = 0L;
+  my_bool         is_null = 0;
+  const char *query=
+    "SELECT COUNT(*) FROM v1 WHERE SERVERNAME=?";
+
+  rc = mysql_query(mysql, "DROP TABLE IF EXISTS t1,t2,t3,v1");
+  check_mysql_rc(rc, mysql);
+
+  rc = mysql_query(mysql, "DROP VIEW IF EXISTS v1,t1,t2,t3");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"CREATE TABLE t1 ("
+                        " SERVERGRP varchar(20) NOT NULL default '', "
+                        " DBINSTANCE varchar(20) NOT NULL default '', "
+                        " PRIMARY KEY  (SERVERGRP)) "
+                        " CHARSET=latin1 collate=latin1_bin");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"CREATE TABLE t2 ("
+                        " SERVERNAME varchar(20) NOT NULL, "
+                        " SERVERGRP varchar(20) NOT NULL, "
+                        " PRIMARY KEY (SERVERNAME)) "
+                        " CHARSET=latin1 COLLATE latin1_bin");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "CREATE TABLE t3 ("
+                  " SERVERGRP varchar(20) BINARY NOT NULL, "
+                  " TABNAME varchar(30) NOT NULL, MAPSTATE char(1) NOT NULL, "
+                  " ACTSTATE char(1) NOT NULL , "
+                  " LOCAL_NAME varchar(30) NOT NULL, "
+                  " CHG_DATE varchar(8) NOT NULL default '00000000', "
+                  " CHG_TIME varchar(6) NOT NULL default '000000', "
+                  " MXUSER varchar(12) NOT NULL default '', "
+                  " PRIMARY KEY (SERVERGRP, TABNAME, MAPSTATE, ACTSTATE, "
+                  " LOCAL_NAME)) CHARSET=latin1 COLLATE latin1_bin");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"CREATE VIEW v1 AS select sql_no_cache"
+                  " T0001.SERVERNAME AS SERVERNAME, T0003.TABNAME AS"
+                  " TABNAME,T0003.LOCAL_NAME AS LOCAL_NAME,T0002.DBINSTANCE AS"
+                  " DBINSTANCE from t2 T0001 join t1 T0002 join t3 T0003 where"
+                  " ((T0002.SERVERGRP = T0001.SERVERGRP) and"
+                  " (T0002.SERVERGRP = T0003.SERVERGRP)"
+                  " and (T0003.MAPSTATE = _latin1'A') and"
+                  " (T0003.ACTSTATE = _latin1' '))");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  strcpy(str_data, "TEST");
+  memset(my_bind, '\0', sizeof(MYSQL_BIND));
+  my_bind[0].buffer_type= MYSQL_TYPE_STRING;
+  my_bind[0].buffer= (char *)&str_data;
+  my_bind[0].buffer_length= 50;
+  my_bind[0].length= &length;
+  length= 4;
+  my_bind[0].is_null= &is_null;
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  for (i= 0; i < 3; i++)
+  {
+    int rowcount= 0;
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+
+    while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+      rowcount++; 
+    FAIL_IF(rowcount != 1, "Expected 1 row");
+  }
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1,t2,t3");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW v1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+static int test_view_where(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  const char *query=
+    "select v1.c,v2.c from v1, v2";
+
+  rc = mysql_query(mysql, "DROP TABLE IF EXISTS t1,v1,v2");
+  check_mysql_rc(rc, mysql);
+
+  rc = mysql_query(mysql, "DROP VIEW IF EXISTS v1,v2,t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"CREATE TABLE t1 (a int, b int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"insert into t1 values (1,2), (1,3), (2,4), (2,5), (3,10)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"create view v1 (c) as select b from t1 where a<3");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"create view v2 (c) as select b from t1 where a>=3");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  for (i= 0; i < 3; i++)
+  {
+    int rowcount= 0;
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+      rowcount++;
+    FAIL_UNLESS(4 == rowcount, "Expected 4 rows");
+  }
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW v1, v2");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+static int test_view_2where(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  MYSQL_BIND      my_bind[8];
+  char            params[8][100];
+  ulong           length[8];
+  const char *query=
+    "select relid, report, handle, log_group, username, variant, type, "
+    "version, erfdat, erftime, erfname, aedat, aetime, aename, dependvars, "
+    "inactive from V_LTDX where mandt = ? and relid = ? and report = ? and "
+    "handle = ? and log_group = ? and username in ( ? , ? ) and type = ?";
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS LTDX");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW IF EXISTS V_LTDX");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "CREATE TABLE LTDX (MANDT char(3) NOT NULL default '000', "
+                  " RELID char(2) NOT NULL, REPORT varchar(40) NOT NULL,"
+                  " HANDLE varchar(4) NOT NULL, LOG_GROUP varchar(4) NOT NULL,"
+                  " USERNAME varchar(12) NOT NULL,"
+                  " VARIANT varchar(12) NOT NULL,"
+                  " TYPE char(1) NOT NULL, SRTF2 int(11) NOT NULL,"
+                  " VERSION varchar(6) NOT NULL default '000000',"
+                  " ERFDAT varchar(8) NOT NULL default '00000000',"
+                  " ERFTIME varchar(6) NOT NULL default '000000',"
+                  " ERFNAME varchar(12) NOT NULL,"
+                  " AEDAT varchar(8) NOT NULL default '00000000',"
+                  " AETIME varchar(6) NOT NULL default '000000',"
+                  " AENAME varchar(12) NOT NULL,"
+                  " DEPENDVARS varchar(10) NOT NULL,"
+                  " INACTIVE char(1) NOT NULL, CLUSTR smallint(6) NOT NULL,"
+                  " CLUSTD blob,"
+                  " PRIMARY KEY (MANDT, RELID, REPORT, HANDLE, LOG_GROUP, "
+                                "USERNAME, VARIANT, TYPE, SRTF2))"
+                 " CHARSET=latin1 COLLATE latin1_bin");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "CREATE VIEW V_LTDX AS select T0001.MANDT AS "
+                  " MANDT,T0001.RELID AS RELID,T0001.REPORT AS "
+                  " REPORT,T0001.HANDLE AS HANDLE,T0001.LOG_GROUP AS "
+                  " LOG_GROUP,T0001.USERNAME AS USERNAME,T0001.VARIANT AS "
+                  " VARIANT,T0001.TYPE AS TYPE,T0001.VERSION AS "
+                  " VERSION,T0001.ERFDAT AS ERFDAT,T0001.ERFTIME AS "
+                  " ERFTIME,T0001.ERFNAME AS ERFNAME,T0001.AEDAT AS "
+                  " AEDAT,T0001.AETIME AS AETIME,T0001.AENAME AS "
+                  " AENAME,T0001.DEPENDVARS AS DEPENDVARS,T0001.INACTIVE AS "
+                  " INACTIVE from LTDX T0001 where (T0001.SRTF2 = 0)");
+  check_mysql_rc(rc, mysql);
+  memset(my_bind, '\0', sizeof(MYSQL_BIND));
+  for (i=0; i < 8; i++) {
+    strcpy(params[i], "1");
+    my_bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
+    my_bind[i].buffer = (char *)&params[i];
+    my_bind[i].buffer_length = 1;
+    my_bind[i].is_null = 0;
+    length[i] = 1;
+    my_bind[i].length = &length[i];
+  }
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  FAIL_UNLESS(MYSQL_NO_DATA == rc, "Expected 0 rows");
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP VIEW V_LTDX");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE LTDX");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+static int test_view_star(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  MYSQL_BIND      my_bind[8];
+  char            params[8][100];
+  ulong           length[8];
+  const char *query= "SELECT * FROM vt1 WHERE a IN (?,?)";
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, vt1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW IF EXISTS t1, vt1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE VIEW vt1 AS SELECT a FROM t1");
+  check_mysql_rc(rc, mysql);
+  memset(my_bind, '\0', sizeof(MYSQL_BIND));
+  for (i= 0; i < 2; i++) {
+    sprintf((char *)&params[i], "%d", i);
+    my_bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
+    my_bind[i].buffer = (char *)&params[i];
+    my_bind[i].buffer_length = 100;
+    my_bind[i].is_null = 0;
+    my_bind[i].length = &length[i];
+    length[i] = 1;
+  }
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  for (i= 0; i < 3; i++)
+  {
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    rc= mysql_stmt_fetch(stmt);
+    FAIL_UNLESS(MYSQL_NO_DATA == rc, "Expected 0 rows");
+  }
+
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW vt1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+static int test_view_insert(MYSQL *mysql)
+{
+  MYSQL_STMT *insert_stmt, *select_stmt;
+  int rc, i;
+  MYSQL_BIND      my_bind[1];
+  int             my_val = 0;
+  ulong           my_length = 0L;
+  my_bool         my_null = 0;
+  const char *query=
+    "insert into v1 values (?)";
+
+  rc = mysql_query(mysql, "DROP TABLE IF EXISTS t1,v1");
+  check_mysql_rc(rc, mysql);
+  rc = mysql_query(mysql, "DROP VIEW IF EXISTS t1,v1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql,"create table t1 (a int, primary key (a))");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create view v1 as select a from t1 where a>=1");
+  check_mysql_rc(rc, mysql);
+
+  insert_stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(insert_stmt, SL(query));
+  check_stmt_rc(rc, insert_stmt);
+  query= "select * from t1";
+  select_stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(select_stmt, SL(query));
+  check_stmt_rc(rc, select_stmt);
+
+  memset(my_bind, '\0', sizeof(MYSQL_BIND));
+  my_bind[0].buffer_type = MYSQL_TYPE_LONG;
+  my_bind[0].buffer = (char *)&my_val;
+  my_bind[0].length = &my_length;
+  my_bind[0].is_null = &my_null;
+  rc= mysql_stmt_bind_param(insert_stmt, my_bind);
+  check_stmt_rc(rc, select_stmt);
+
+  for (i= 0; i < 3; i++)
+  {
+    int rowcount= 0;
+    my_val= i;
+
+    rc= mysql_stmt_execute(insert_stmt);
+    check_stmt_rc(rc, insert_stmt);;
+
+    rc= mysql_stmt_execute(select_stmt);
+    check_stmt_rc(rc, select_stmt);;
+    while (mysql_stmt_fetch(select_stmt) != MYSQL_NO_DATA)
+      rowcount++;
+    FAIL_UNLESS((i+1) == rowcount, "rowcount != i+1");
+  }
+  mysql_stmt_close(insert_stmt);
+  mysql_stmt_close(select_stmt);
+
+  rc= mysql_query(mysql, "DROP VIEW v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+static int test_left_join_view(MYSQL *mysql)
+{
+  MYSQL_STMT *stmt;
+  int rc, i;
+  const char *query=
+    "select t1.a, v1.x from t1 left join v1 on (t1.a= v1.x);";
+
+  rc = mysql_query(mysql, "DROP TABLE IF EXISTS t1,v1");
+  check_mysql_rc(rc, mysql);
+
+  rc = mysql_query(mysql, "DROP VIEW IF EXISTS v1,t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"insert into t1 values (1), (2), (3)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,"create view v1 (x) as select a from t1 where a > 1");
+  check_mysql_rc(rc, mysql);
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+
+  for (i= 0; i < 3; i++)
+  {
+    int rowcount= 0;
+
+    rc= mysql_stmt_execute(stmt);
+    check_stmt_rc(rc, stmt);
+    while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+      rowcount++;
+    FAIL_UNLESS(3 == rowcount, "Expected 3 rows");
+  }
+  mysql_stmt_close(stmt);
+
+  rc= mysql_query(mysql, "DROP VIEW v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+static int test_view_insert_fields(MYSQL *mysql)
+{
+  MYSQL_STMT    *stmt;
+  char          parm[11][1000];
+  ulong         l[11];
+  int           rc, i;
+  int           rowcount= 0;
+  MYSQL_BIND    my_bind[11];
+  const char    *query= "INSERT INTO `v1` ( `K1C4` ,`K2C4` ,`K3C4` ,`K4N4` ,`F1C4` ,`F2I4` ,`F3N5` ,`F7F8` ,`F6N4` ,`F5C8` ,`F9D8` ) VALUES( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? )";
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW IF EXISTS t1, v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "CREATE TABLE t1 (K1C4 varchar(4) NOT NULL,"
+                  "K2C4 varchar(4) NOT NULL, K3C4 varchar(4) NOT NULL,"
+                  "K4N4 varchar(4) NOT NULL default '0000',"
+                  "F1C4 varchar(4) NOT NULL, F2I4 int(11) NOT NULL,"
+                  "F3N5 varchar(5) NOT NULL default '00000',"
+                  "F4I4 int(11) NOT NULL default '0', F5C8 varchar(8) NOT NULL,"
+                  "F6N4 varchar(4) NOT NULL default '0000',"
+                  "F7F8 double NOT NULL default '0',"
+                  "F8F8 double NOT NULL default '0',"
+                  "F9D8 decimal(8,2) NOT NULL default '0.00',"
+                  "PRIMARY KEY (K1C4,K2C4,K3C4,K4N4))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql,
+                  "CREATE VIEW v1 AS select sql_no_cache "
+                  " K1C4 AS K1C4, K2C4 AS K2C4, K3C4 AS K3C4, K4N4 AS K4N4, "
+                  " F1C4 AS F1C4, F2I4 AS F2I4, F3N5 AS F3N5,"
+                  " F7F8 AS F7F8, F6N4 AS F6N4, F5C8 AS F5C8, F9D8 AS F9D8"
+                  " from t1 T0001");
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  for (i= 0; i < 11; i++)
+  {
+    l[i]= 20;
+    my_bind[i].buffer_type= MYSQL_TYPE_STRING;
+    my_bind[i].is_null= 0;
+    my_bind[i].buffer= (char *)&parm[i];
+
+    strcpy(parm[i], "1");
+    my_bind[i].buffer_length= 2;
+    my_bind[i].length= &l[i];
+  }
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_bind_param(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  mysql_stmt_close(stmt);
+
+  query= "select * from t1";
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+  while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+    rowcount++;
+  FAIL_UNLESS(1 == rowcount, "Expected 1 row");
+
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "DROP VIEW v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE t1");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_view_sp_list_fields(MYSQL *mysql)
+{
+  int           rc;
+  MYSQL_RES     *res;
+  MYSQL_ROW     row;
+  int           skip;
+
+  /* skip this test if bin_log is on */
+  rc= mysql_query(mysql, "SHOW VARIABLES LIKE 'log_bin'");
+  check_mysql_rc(rc, mysql);
+  res= mysql_store_result(mysql);
+  FAIL_IF(!res, "empty/invalid resultset");
+  row = mysql_fetch_row(res);
+  skip= (strcmp((char *)row[1], "ON") == 0);
+  mysql_free_result(res);
+
+  if (skip) {
+    diag("bin_log is ON -> skip");
+    return SKIP;
+  }
+
+  rc= mysql_query(mysql, "DROP FUNCTION IF EXISTS f1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS v1, t1, t2");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW IF EXISTS v1, t1, t2");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create function f1 () returns int return 5");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (s1 char,s2 char)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t2 (s1 int);");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create view v1 as select s2,sum(s1) - \
+count(s2) as vx from t1 group by s2 having sum(s1) - count(s2) < (select f1() \
+from t2);");
+  check_mysql_rc(rc, mysql);
+  res= mysql_list_fields(mysql, "v1", NullS);
+  FAIL_UNLESS(res != 0 && mysql_num_fields(res) != 0, "0 Fields");
+  rc= mysql_query(mysql, "DROP FUNCTION f1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP TABLE t1, t2");
+  mysql_free_result(res);
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+static int test_bug19671(MYSQL *mysql)
+{
+  MYSQL_RES *result;
+  MYSQL_FIELD *field;
+  int rc, retcode= OK;
+
+
+  rc= mysql_query(mysql, "set sql_mode=''");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "drop table if exists t1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "drop view if exists v1");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create table t1(f1 int)");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "create view v1 as select va.* from t1 va");
+  check_mysql_rc(rc, mysql);
+
+  rc= mysql_query(mysql, "SELECT * FROM v1");
+  check_mysql_rc(rc, mysql);
+
+  result= mysql_store_result(mysql);
+  FAIL_IF(!result, "Invalid result set");
+
+  field= mysql_fetch_field(result);
+  FAIL_IF(!field, "Can't fetch field");
+
+  if (strcmp(field->table, "v1") != 0) {
+    diag("Wrong value '%s' for field_table. Expected 'v1'. (%s: %d)", field->table, __FILE__, __LINE__);
+    retcode= FAIL;
+  }
+
+  mysql_free_result(result);
+
+  rc= mysql_query(mysql, "drop view v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "drop table t1");
+  check_mysql_rc(rc, mysql);
+
+  return retcode;
+}
+
+/*
+  Bug#11111: fetch from view returns wrong data
+*/
+
+static int test_bug11111(MYSQL *mysql)
+{
+  MYSQL_STMT    *stmt;
+  MYSQL_BIND    my_bind[2];
+  char          buf[2][20];
+  ulong         len[2];
+  int i;
+  int rc;
+  const char *query= "SELECT DISTINCT f1,ff2 FROM v1";
+
+  rc= mysql_query(mysql, "drop table if exists t1, t2, v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "drop view if exists t1, t2, v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t1 (f1 int, f2 int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create table t2 (ff1 int, ff2 int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "create view v1 as select * from t1, t2 where f1=ff1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t1 values (1,1), (2,2), (3,3)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "insert into t2 values (1,1), (2,2), (3,3)");
+  check_mysql_rc(rc, mysql);
+
+  stmt= mysql_stmt_init(mysql);
+
+  rc= mysql_stmt_prepare(stmt, SL(query));
+  check_stmt_rc(rc, stmt);
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  memset(my_bind, '\0', sizeof(my_bind));
+  for (i=0; i < 2; i++)
+  {
+    my_bind[i].buffer_type= MYSQL_TYPE_STRING;
+    my_bind[i].buffer= (uchar* *)&buf[i];
+    my_bind[i].buffer_length= 20;
+    my_bind[i].length= &len[i];
+  }
+
+  rc= mysql_stmt_bind_result(stmt, my_bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_fetch(stmt);
+  check_stmt_rc(rc, stmt);
+  FAIL_UNLESS(!strcmp(buf[1],"1"), "buf[1] != '1'");
+  mysql_stmt_close(stmt);
+  rc= mysql_query(mysql, "drop view v1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "drop table t1, t2");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+/**
+  Bug#29306 Truncated data in MS Access with decimal (3,1) columns in a VIEW
+*/
+
+static int test_bug29306(MYSQL *mysql)
+{
+  MYSQL_FIELD *field;
+  int rc;
+  MYSQL_RES *res;
+
+  rc= mysql_query(mysql, "DROP TABLE IF EXISTS tab17557");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW IF EXISTS view17557");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE tab17557 (dd decimal (3,1))");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE VIEW view17557 as SELECT dd FROM tab17557");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO tab17557 VALUES (7.6)");
+  check_mysql_rc(rc, mysql);
+
+  /* Checking the view */
+  res= mysql_list_fields(mysql, "view17557", NULL);
+  while ((field= mysql_fetch_field(res)))
+  {
+    FAIL_UNLESS(field->decimals == 1, "field->decimals != 1");
+  }
+  mysql_free_result(res);
+
+  rc= mysql_query(mysql, "DROP TABLE tab17557");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "DROP VIEW view17557");
+  check_mysql_rc(rc, mysql);
+
+  return OK;
+}
+
+
+struct my_tests_st my_tests[] = {
+  {"test_view", test_view, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_view_where", test_view_where, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_view_2where", test_view_2where, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_view_star", test_view_star, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_view_insert", test_view_insert, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_left_join_view", test_left_join_view, TEST_CONNECTION_DEFAULT, 0, NULL , NULL}, 
+  {"test_view_insert_fields", test_view_insert_fields, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_view_sp_list_fields", test_view_sp_list_fields,TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug19671", test_bug19671, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug29306", test_bug29306, TEST_CONNECTION_DEFAULT, 0, NULL , NULL},
+  {"test_bug11111", test_bug11111, TEST_CONNECTION_DEFAULT, 0, NULL , NULL}, 
+  {NULL, NULL, 0, 0, NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  if (argc > 1)
+    get_options(argc, argv);
+
+  get_envvars();
+
+  run_tests(my_tests);
+
+  return(exit_status());
+}
diff --git a/libmariadb/unittest/mytap/CMakeLists.txt b/libmariadb/unittest/mytap/CMakeLists.txt
new file mode 100644
index 00000000..1a03d7ac
--- /dev/null
+++ b/libmariadb/unittest/mytap/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Copyright (C) 2007 MySQL AB
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+INCLUDE_DIRECTORIES(${CC_SOURCE_DIR}/include ${CC_SOURCE_DIR}/zlib
+                    ${CC_BINARY_DIR}/include)
+ADD_LIBRARY(cctap tap.c)
diff --git a/libmariadb/unittest/mytap/Doxyfile b/libmariadb/unittest/mytap/Doxyfile
new file mode 100644
index 00000000..1b1c82b4
--- /dev/null
+++ b/libmariadb/unittest/mytap/Doxyfile
@@ -0,0 +1,1156 @@
+# Doxyfile 1.3.8
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = 
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         = 
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = 
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 
+# 4096 sub-directories (in 2 levels) under the output directory of each output 
+# format and will distribute the generated files over these directories. 
+# Enabling this option can be useful when feeding doxygen a huge amount of source 
+# files, where putting all generated files in the same directory would otherwise 
+# cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, 
+# Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese, 
+# Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian, 
+# Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, 
+# Swedish, and Ukrainian.
+
+OUTPUT_LANGUAGE        = English
+
+# This tag can be used to specify the encoding used in the generated output. 
+# The encoding is not always determined by the language that is chosen, 
+# but also whether or not the output is meant for Windows or non-Windows users. 
+# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES 
+# forces the Windows encoding (this is the default for the Windows binary), 
+# whereas setting the tag to NO uses a Unix-style encoding (the default for 
+# all platforms other than Windows).
+
+USE_WINDOWS_ENCODING   = NO
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator 
+# that is used to form the text in various listings. Each string 
+# in this list, if found as the leading text of the brief description, will be 
+# stripped from the text and the result after processing the whole list, is used 
+# as the annotated text. Otherwise, the brief description is used as-is. If left 
+# blank, the following values are used ("$name" is automatically replaced with the 
+# name of the entity): "The $name class" "The $name widget" "The $name file" 
+# "is" "provides" "specifies" "contains" "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = 
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all inherited 
+# members of a class in the documentation of that class as if those members were 
+# ordinary class members. Constructors, destructors and assignment operators of 
+# the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user-defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. The tag can be used to show relative paths in the file list. 
+# If left blank the directory from which doxygen is run is used as the 
+# path to strip.
+
+STRIP_FROM_PATH        = 
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of 
+# the path mentioned in the documentation of a class, which tells 
+# the reader which header file to include in order to use a class. 
+# If left blank only the name of the header file containing the class 
+# definition is used. Otherwise one should specify the include paths that 
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    = 
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
+# (but less readable) file names. This can be useful is your file systems 
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the JavaDoc 
+# comments will behave just like the Qt-style comments (thus requiring an 
+# explicit @brief command for a brief description.
+
+JAVADOC_AUTOBRIEF      = YES
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen 
+# treat a multi-line C++ special comment block (i.e. a block of //! or /// 
+# comments) as a brief description. This used to be the default behaviour. 
+# The new default is to treat a multi-line C++ comment block as a detailed 
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the DETAILS_AT_TOP tag is set to YES then Doxygen 
+# will output the detailed description near the top, like JavaDoc.
+# If set to NO, the detailed description appears after the member 
+# documentation.
+
+DETAILS_AT_TOP         = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 8
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user-defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = 
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources 
+# only. Doxygen will then generate output that is more tailored for C. 
+# For instance, some of the names that are used will be different. The list 
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = YES
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java sources 
+# only. Doxygen will then generate output that is more tailored for Java. 
+# For instance, namespaces will be presented as packages, qualified scopes 
+# will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of 
+# the same type (for instance a group of public functions) to be put as a 
+# subgroup of that type (e.g. under the Public Functions section). Set it to 
+# NO to prevent subgrouping. Alternatively, this can be done per class using 
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = YES
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
+# defined locally in source files will be included in the documentation. 
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local 
+# methods, which are defined in the implementation section but not in 
+# the interface are included in the documentation. 
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these classes will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
+# friend (class|struct|union) declarations. 
+# If set to NO (the default) these declarations will be included in the 
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any 
+# documentation blocks found inside the body of a function. 
+# If set to NO (the default) these blocks will be appended to the 
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower-case letters. If set to YES upper-case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put a list of the files that are included by a file in the documentation 
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the 
+# brief documentation of file, namespace and class members alphabetically 
+# by member name. If set to NO (the default) the members will appear in 
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be 
+# sorted by fully-qualified names, including namespaces. If set to 
+# NO (the default), the class list will be sorted only by class name, 
+# not including the namespace part. 
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the 
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or 
+# disable (NO) the bug list. This list is created by putting \bug 
+# commands in the documentation.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or 
+# disable (NO) the deprecated list. This list is created by putting 
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       = 
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
+# the initial value of a variable or define consists of for it to appear in 
+# the documentation. If the initializer consists of more lines than specified 
+# here it will be hidden. Use a value of 0 to hide initializers completely. 
+# The appearance of the initializer of individual variables and defines in the 
+# documentation can be controlled using \showinitializer or \hideinitializer 
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
+# at the bottom of the documentation of classes and structs. If set to YES the 
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for 
+# potential errors in the documentation, such as not documenting some 
+# parameters in a documented function, or documenting parameters that 
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning 
+# and error messages should be written. If left blank the output is written 
+# to stderr.
+
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories
+# that contain documented source files. You may enter file names like
+# "myfile.cpp" or directories like "/usr/src/myproject". Separate the
+# files or directories with spaces.
+
+INPUT                  = 
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like
+# *.cpp and *.h) to filter out the source-files in the directories. If
+# left blank the following patterns are tested: *.c *.cc *.cxx *.cpp
+# *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp *.h++
+# *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm
+
+FILE_PATTERNS          = 
+
+# The RECURSIVE tag can be used to turn specify whether or not
+# subdirectories should be searched for input files as well. Possible
+# values are YES and NO.  If left blank NO is used.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that
+# should excluded from the INPUT source files. This way you can easily
+# exclude a subdirectory from a directory tree whose root is specified
+# with the INPUT tag.
+
+EXCLUDE                = 
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix filesystem feature) are
+# excluded from the input.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to
+# exclude certain files from those directories.
+
+EXCLUDE_PATTERNS       = 
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command).
+
+EXAMPLE_PATH           = e
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = *.c
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be 
+# searched for input files to be used with the \include or \dontinclude 
+# commands irrespective of the value of the RECURSIVE tag. 
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command).
+
+IMAGE_PATH             = 
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output.  If FILTER_PATTERNS is specified, this tag will be 
+# ignored.
+
+INPUT_FILTER           = 
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern 
+# basis.  Doxygen will compare the file name with each pattern and apply the 
+# filter if there is a match.  The filters are a list of the form: 
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further 
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER 
+# is applied to all files.
+
+FILTER_PATTERNS        = 
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
+# INPUT_FILTER) will be used to filter the input files when producing source 
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+# Note: To get rid of all source code in the generated output, make sure also 
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES (the default) 
+# then for each documented function all documented 
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES (the default) 
+# then for each documented function all documented entities 
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = YES
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for 
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank 
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = 
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = 
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet. Note that doxygen will try to copy 
+# the style sheet file to the HTML output directory, so don't put your own 
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        = 
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) 
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can 
+# be used to specify the file name of the resulting .chm file. You 
+# can add a path in front of the file if the result should not be 
+# written to the html output directory.
+
+CHM_FILE               = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can 
+# be used to specify the location (absolute path including file name) of 
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run 
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
+# controls if a separate .chi index file is generated (YES) or that 
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
+# controls whether a binary table of contents is generated (YES) or a 
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members 
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# This tag can be used to set the number of enum values (range [1..20]) 
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
+# generated containing a tree-like index structure (just like the one that 
+# is generated for HTML Help). For this to work a browser that supports 
+# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, 
+# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are 
+# probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW      = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
+# used to set the initial width (in pixels) of the frame in which the tree 
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be 
+# invoked. If left blank `latex' will be used as the default command name.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to 
+# generate index for LaTeX. If left blank `makeindex' will be used as the 
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, a4wide, letter, legal and 
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = NO
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = NO
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE        = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not 
+# include the index chapters (such as File Index, Compound Index, etc.) 
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimized for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using WORD or other 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assignments. You only have to provide 
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    = 
+
+# Set optional variables used in the generation of an rtf document. 
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output, 
+# then it will generate one additional man file for each entity 
+# documented in the real man page(s). These additional files 
+# only source the real man page, but without them the man command 
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will 
+# generate an XML file that captures the structure of 
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_SCHEMA             = 
+
+# The XML_DTD tag can be used to specify an XML DTD, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_DTD                = 
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will 
+# dump the program listings (including syntax highlighting 
+# and cross-referencing information) to the XML output. Note that 
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will 
+# generate an AutoGen Definitions (see autogen.sf.net) file 
+# that captures the structure of the code including all 
+# documentation. Note that this feature is still experimental 
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will 
+# generate a Perl module file that captures the structure of 
+# the code including all documentation. Note that this 
+# feature is still experimental and incomplete at the 
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate 
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able 
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be 
+# nicely formatted so it can be parsed by a human reader.  This is useful 
+# if you want to understand what is going on.  On the other hand, if this 
+# tag is set to NO the size of the Perl module output will be much smaller 
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file 
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. 
+# This is useful so different doxyrules.make files included by the same 
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_PREDEFINED tags.
+
+EXPAND_ONLY_PREDEF     = YES
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor.
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more
+# wildcard patterns (like *.h and *.hpp) to filter out the
+# header-files in the directories. If left blank, the patterns
+# specified with FILE_PATTERNS will be used.
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names
+# that are defined before the preprocessor is started (similar to the
+# -D option of gcc). The argument of the tag is a list of macros of
+# the form: name or name=definition (no spaces). If the definition and
+# the = are omitted =1 is assumed.
+
+PREDEFINED             = 
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES
+# then this tag can be used to specify a list of macro names that
+# should be expanded.  The macro definition that is found in the
+# sources will be used.  Use the PREDEFINED tag if you want to use a
+# different macro definition.
+
+EXPAND_AS_DEFINED      = __attribute__
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all function-like macros that are
+# alone on a line, have an all uppercase name, and do not end with a
+# semicolon. Such function macros are typically used for boiler-plate
+# code, and will confuse the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references   
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. 
+# Optionally an initial location of the external documentation 
+# can be added for each tagfile. The format of a tag file without 
+# this location is as follows: 
+#   TAGFILES = file1 file2 ... 
+# Adding location for the tag files is done as follows: 
+#   TAGFILES = file1=loc1 "file2 = loc2" ... 
+# where "loc1" and "loc2" can be relative or absolute paths or 
+# URLs. If a location is present for each tag, the installdox tool 
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen 
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed 
+# in the modules index. If set to NO, only the current project's groups will 
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base or 
+# super classes. Setting the tag to NO turns the diagrams off. Note that this 
+# option is superseded by the HAVE_DOT option below. This is only a fallback. It is 
+# recommended to install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# If set to YES, the inheritance and collaboration graphs will hide 
+# inheritance and usage relations if the target is undocumented 
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = NO
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and 
+# collaboration diagrams in a style similar to the OMG's Unified Modeling 
+# Language.
+
+UML_LOOK               = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the 
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT 
+# tags are set to YES then doxygen will generate a graph for each documented 
+# file showing the direct and indirect include dependencies of the file with 
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and 
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each 
+# documented header file showing the documented files that directly or 
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will 
+# generate a call dependency graph for every global function or class method. 
+# Note that enabling this option will significantly increase the time of a run. 
+# So in most cases it will be better to enable call graphs for selected 
+# functions only using the \callgraph command.
+
+CALL_GRAPH             = YES
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images 
+# generated by dot. Possible values are png, jpg, or gif
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found on the path.
+
+DOT_PATH               = 
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that 
+# contain dot files that are included in the documentation (see the 
+# \dotfile command).
+
+DOTFILE_DIRS           = 
+
+# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width 
+# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
+# this value, doxygen will try to truncate the graph, so that it fits within 
+# the specified constraint. Beware that most browsers cannot cope with very 
+# large images.
+
+MAX_DOT_GRAPH_WIDTH    = 1024
+
+# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height 
+# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
+# this value, doxygen will try to truncate the graph, so that it fits within 
+# the specified constraint. Beware that most browsers cannot cope with very 
+# large images.
+
+MAX_DOT_GRAPH_HEIGHT   = 1024
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the 
+# graphs generated by dot. A depth value of 3 means that only nodes reachable 
+# from the root by following a path via at most 3 edges will be shown. Nodes that 
+# lay further from the root node will be omitted. Note that setting this option to 
+# 1 or 2 may greatly reduce the computation time needed for large code bases. Also 
+# note that a graph may be further truncated if the graph's image dimensions are 
+# not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH and MAX_DOT_GRAPH_HEIGHT). 
+# If 0 is used for the depth value (the default), the graph is not depth-constrained.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
+# generate a legend page explaining the meaning of the various boxes and 
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
+# remove the intermediate dot files that are used to generate 
+# the various graphs.
+
+DOT_CLEANUP            = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine   
+#---------------------------------------------------------------------------
+
+# The SEARCHENGINE tag specifies whether or not a search engine should be 
+# used. If set to NO the values of all tags below this one will be ignored.
+
+SEARCHENGINE           = NO
diff --git a/libmariadb/unittest/mytap/t/basic-t.c b/libmariadb/unittest/mytap/t/basic-t.c
new file mode 100644
index 00000000..c0ceb5bf
--- /dev/null
+++ b/libmariadb/unittest/mytap/t/basic-t.c
@@ -0,0 +1,33 @@
+/* Copyright (C) 2006 MySQL AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
+
+#include "my_config.h"
+
+#include <stdlib.h>
+#include "../tap.h"
+
+int main() {
+  plan(5);
+  ok(1 == 1, "testing basic functions");
+  ok(2 == 2, " ");
+  ok(3 == 3, NULL);
+  if (1 == 1)
+    skip(2, "Sensa fragoli");
+  else {
+    ok(1 == 2, "Should not be run at all");
+    ok(1, "This one neither");
+  }
+  return exit_status();
+}
diff --git a/libmariadb/unittest/mytap/tap.c b/libmariadb/unittest/mytap/tap.c
new file mode 100644
index 00000000..d0b52f4d
--- /dev/null
+++ b/libmariadb/unittest/mytap/tap.c
@@ -0,0 +1,600 @@
+/* Copyright (C) 2006 MySQL AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+   MA 02111-1301, USA
+
+   Library for providing TAP support for testing C and C++ was written
+   by Mats Kindahl <mats@mysql.com>.
+*/
+
+#include "tap.h"
+
+#include "ma_global.h"
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+
+/*
+  Visual Studio 2003 does not know vsnprintf but knows _vsnprintf.
+  We don't put this #define in config-win.h because we prefer
+  ma_vsnprintf everywhere instead, except when linking with libmysys
+  is not desirable - the case here.
+*/
+#if defined(_MSC_VER) && ( _MSC_VER == 1310 )
+#define vsnprintf _vsnprintf
+#endif
+
+/**
+   @defgroup MyTAP_Internal MyTAP Internals
+
+   Internal functions and data structures for the MyTAP implementation.
+*/
+
+/**
+   Test data structure.
+
+   Data structure containing all information about the test suite.
+
+   @ingroup MyTAP_Internal
+ */
+static TEST_DATA g_test = { 0, 0, 0, "" };
+
+/**
+   Output stream for test report message.
+
+   The macro is just a temporary solution.
+
+   @ingroup MyTAP_Internal
+ */
+#define tapout stdout
+
+/**
+  Emit the beginning of a test line, that is: "(not) ok", test number,
+  and description.
+
+  To emit the directive, use the emit_dir() function
+
+  @ingroup MyTAP_Internal
+
+  @see emit_dir
+
+  @param pass  'true' if test passed, 'false' otherwise
+  @param fmt   Description of test in printf() format.
+  @param ap    Vararg list for the description string above.
+ */
+static void
+vemit_tap(int pass, char const *fmt, va_list ap)
+{
+  fprintf(tapout, "%sok %d%s",
+          pass ? "" : "not ",
+          ++g_test.last,
+          (fmt && *fmt) ? " - " : "");
+  if (fmt && *fmt)
+    vfprintf(tapout, fmt, ap);
+}
+
+
+/**
+   Emit a TAP directive.
+
+   TAP directives are comments after that have the form:
+
+   @code
+   ok 1 # skip reason for skipping
+   not ok 2 # todo some text explaining what remains
+   @endcode
+
+   @ingroup MyTAP_Internal
+
+   @param dir  Directive as a string
+   @param why  Explanation string
+ */
+static void
+emit_dir(const char *dir, const char *why)
+{
+  fprintf(tapout, " # %s %s", dir, why);
+}
+
+
+/**
+   Emit a newline to the TAP output stream.
+
+   @ingroup MyTAP_Internal
+ */
+static void
+emit_endl()
+{
+  fprintf(tapout, "\n");
+}
+
+static void
+handle_core_signal(int signo)
+{
+  BAIL_OUT("Signal %d thrown", signo);
+}
+
+void
+BAIL_OUT(char const *fmt, ...)
+{
+  va_list ap;
+  va_start(ap, fmt);
+  fprintf(tapout, "Bail out! ");
+  vfprintf(tapout, fmt, ap);
+  emit_endl();
+  va_end(ap);
+  exit(255);
+}
+
+
+void
+diag(char const *fmt, ...)
+{
+  va_list ap;
+  va_start(ap, fmt);
+  fprintf(tapout, "# ");
+  vfprintf(tapout, fmt, ap);
+  emit_endl();
+  va_end(ap);
+}
+
+typedef struct signal_entry {
+  int signo;
+  void (*handler)(int);
+} signal_entry;
+
+static signal_entry install_signal[]= {
+#ifdef SIGQUIT
+  { SIGQUIT, handle_core_signal },
+#endif
+  { SIGILL,  handle_core_signal },
+  { SIGABRT, handle_core_signal },
+  { SIGFPE,  handle_core_signal },
+  { SIGSEGV, handle_core_signal }
+#ifdef SIGBUS
+  , { SIGBUS,  handle_core_signal }
+#endif
+#ifdef SIGXCPU
+  , { SIGXCPU, handle_core_signal }
+#endif
+#ifdef SIGXCPU
+  , { SIGXFSZ, handle_core_signal }
+#endif
+#ifdef SIGXCPU
+  , { SIGSYS,  handle_core_signal }
+#endif
+#ifdef SIGXCPU
+  , { SIGTRAP, handle_core_signal }
+#endif
+};
+
+int skip_big_tests= 1;
+
+void
+plan(int const count)
+{
+  char *config= getenv("MYTAP_CONFIG");
+  size_t i;
+
+  if (config)
+    skip_big_tests= strcmp(config, "big");
+
+  setvbuf(tapout, 0, _IONBF, 0);  /* provide output at once */
+  /*
+    Install signal handler
+  */
+
+  for (i= 0; i < sizeof(install_signal)/sizeof(*install_signal); ++i)
+    signal(install_signal[i].signo, install_signal[i].handler);
+
+  g_test.plan= count;
+  switch (count)
+  {
+  case NO_PLAN:
+    break;
+  default:
+    if (count > 0)
+      fprintf(tapout, "1..%d\n", count);
+    break;
+  }
+}
+
+
+void
+skip_all(char const *reason, ...)
+{
+  va_list ap;
+  va_start(ap, reason);
+  fprintf(tapout, "1..0 # skip ");
+  vfprintf(tapout, reason, ap);
+  va_end(ap);
+  exit(0);
+}
+
+void
+ok(int const pass, char const *fmt, ...)
+{
+  va_list ap;
+  va_start(ap, fmt);
+
+  if (!pass && *g_test.todo == '\0')
+    ++g_test.failed;
+
+  vemit_tap(pass, fmt, ap);
+  va_end(ap);
+  if (*g_test.todo != '\0')
+    emit_dir("todo", g_test.todo);
+  emit_endl();
+}
+
+
+void
+skip(int how_many, char const *const fmt, ...)
+{
+  char reason[80];
+  if (fmt && *fmt)
+  {
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(reason, sizeof(reason), fmt, ap);
+    va_end(ap);
+  }
+  else
+    reason[0] = '\0';
+
+  while (how_many-- > 0)
+  {
+    va_list ap;
+    memset((char*) &ap, 0, sizeof(ap));         /* Keep compiler happy */
+    vemit_tap(1, NULL, ap);
+    emit_dir("skip", reason);
+    emit_endl();
+  }
+}
+
+void
+todo_start(char const *message, ...)
+{
+  va_list ap;
+  va_start(ap, message);
+  vsnprintf(g_test.todo, sizeof(g_test.todo), message, ap);
+  va_end(ap);
+}
+
+void
+todo_end()
+{
+  *g_test.todo = '\0';
+}
+
+int exit_status() {
+  /*
+    If there were no plan, we write one last instead.
+  */
+  if (g_test.plan == NO_PLAN)
+    plan(g_test.last);
+
+  if (g_test.plan != g_test.last)
+  {
+    diag("%d tests planned but%s %d executed",
+         g_test.plan, (g_test.plan > g_test.last ? " only" : ""), g_test.last);
+    return EXIT_FAILURE;
+  }
+
+  if (g_test.failed > 0)
+  {
+    diag("Failed %d tests!", g_test.failed);
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}
+
+/**
+   @mainpage Testing C and C++ using MyTAP
+
+   @section IntroSec Introduction
+
+   Unit tests are used to test individual components of a system. In
+   contrast, functional tests usually test the entire system.  The
+   rationale is that each component should be correct if the system is
+   to be correct.  Unit tests are usually small pieces of code that
+   tests an individual function, class, a module, or other unit of the
+   code.
+
+   Observe that a correctly functioning system can be built from
+   "faulty" components.  The problem with this approach is that as the
+   system evolves, the bugs surface in unexpected ways, making
+   maintenance harder.
+
+   The advantages of using unit tests to test components of the system
+   are several:
+
+   - The unit tests can make a more thorough testing than the
+     functional tests by testing correctness even for pathological use
+     (which shouldn't be present in the system).  This increases the
+     overall robustness of the system and makes maintenance easier.
+
+   - It is easier and faster to find problems with a malfunctioning
+     component than to find problems in a malfunctioning system.  This
+     shortens the compile-run-edit cycle and therefore improves the
+     overall performance of development.
+
+   - The component has to support at least two uses: in the system and
+     in a unit test.  This leads to more generic and stable interfaces
+     and in addition promotes the development of reusable components.
+
+   For example, the following are typical functional tests:
+   - Does transactions work according to specifications?
+   - Can we connect a client to the server and execute statements?
+
+   In contrast, the following are typical unit tests:
+
+   - Can the 'String' class handle a specified list of character sets?
+   - Does all operations for 'my_bitmap' produce the correct result?
+   - Does all the NIST test vectors for the AES implementation encrypt
+     correctly?
+
+
+   @section UnitTest Writing unit tests
+
+   The purpose of writing unit tests is to use them to drive component
+   development towards a solution that passes the tests.  This means that the
+   unit tests has to be as complete as possible, testing at least:
+
+   - Normal input
+   - Borderline cases
+   - Faulty input
+   - Error handling
+   - Bad environment
+
+   @subsection NormalSubSec Normal input
+
+   This is to test that the component have the expected behaviour.
+   This is just plain simple: test that it works.  For example, test
+   that you can unpack what you packed, adding gives the sum, pincing
+   the duck makes it quack.
+
+   This is what everybody does when they write tests.
+
+
+   @subsection BorderlineTests Borderline cases
+
+   If you have a size anywhere for your component, does it work for
+   size 1? Size 0? Sizes close to <code>UINT_MAX</code>?
+
+   It might not be sensible to have a size 0, so in this case it is
+   not a borderline case, but rather a faulty input (see @ref
+   FaultyInputTests).
+
+
+   @subsection FaultyInputTests Faulty input
+
+   Does your bitmap handle 0 bits size? Well, it might not be designed
+   for it, but is should <em>not</em> crash the application, but
+   rather produce an error.  This is called defensive programming.
+
+   Unfortunately, adding checks for values that should just not be
+   entered at all is not always practical: the checks cost cycles and
+   might cost more than it's worth.  For example, some functions are
+   designed so that you may not give it a null pointer.  In those
+   cases it's not sensible to pass it <code>NULL</code> just to see it
+   crash.
+
+   Since every experienced programmer add an <code>assert()</code> to
+   ensure that you get a proper failure for the debug builds when a
+   null pointer passed (you add asserts too, right?), you will in this
+   case instead have a controlled (early) crash in the debug build.
+
+
+   @subsection ErrorHandlingTests Error handling
+
+   This is testing that the errors your component is designed to give
+   actually are produced.  For example, testing that trying to open a
+   non-existing file produces a sensible error code.
+
+
+   @subsection BadEnvironmentTests Environment
+
+   Sometimes, modules has to behave well even when the environment
+   fails to work correctly.  Typical examples are when the computer is
+   out of dynamic memory or when the disk is full.  You can emulate
+   this by replacing, e.g., <code>malloc()</code> with your own
+   version that will work for a while, but then fail.  Some things are
+   worth to keep in mind here:
+
+   - Make sure to make the function fail deterministically, so that
+     you really can repeat the test.
+
+   - Make sure that it doesn't just fail immediately.  The unit might
+     have checks for the first case, but might actually fail some time
+     in the near future.
+
+
+   @section UnitTest How to structure a unit test
+
+   In this section we will give some advice on how to structure the
+   unit tests to make the development run smoothly.  The basic
+   structure of a test is:
+
+   - Plan
+   - Test
+   - Report
+
+
+   @subsection TestPlanning Plan the test
+
+   Planning the test means telling how many tests there are.  In the
+   event that one of the tests causes a crash, it is then possible to
+   see that there are fewer tests than expected, and print a proper
+   error message.
+
+   To plan a test, use the @c plan() function in the following manner:
+
+   @code
+   int main(int argc, char *argv[])
+   {
+     plan(5);
+         .
+         .
+         .
+   }
+   @endcode
+
+   If you don't call the @c plan() function, the number of tests
+   executed will be printed at the end.  This is intended to be used
+   while developing the unit and you are constantly adding tests.  It
+   is not indented to be used after the unit has been released.
+
+
+   @subsection TestRunning Execute the test
+
+   To report the status of a test, the @c ok() function is used in the
+   following manner:
+
+   @code
+   int main(int argc, char *argv[])
+   {
+     plan(5);
+     ok(ducks == paddling_ducks,
+        "%d ducks did not paddle", ducks - paddling_ducks);
+             .
+             .
+             .
+   }
+   @endcode
+
+   This will print a test result line on the standard output in TAP
+   format, which allows TAP handling frameworks (like Test::Harness)
+   to parse the status of the test.
+
+   @subsection TestReport  Report the result of the test
+
+   At the end, a complete test report should be written, with some
+   statistics. If the test returns EXIT_SUCCESS, all tests were
+   successful, otherwise at least one test failed.
+
+   To get a TAP compliant output and exit status, report the exit
+   status in the following manner:
+
+   @code
+   int main(int argc, char *argv[])
+   {
+     plan(5);
+     ok(ducks == paddling_ducks,
+        "%d ducks did not paddle", ducks - paddling_ducks);
+             .
+             .
+             .
+     return exit_status();
+   }
+   @endcode
+
+   @section DontDoThis Ways to not do unit testing
+
+   In this section, we'll go through some quite common ways to write
+   tests that are <em>not</em> a good idea.
+
+   @subsection BreadthFirstTests Doing breadth-first testing
+
+   If you're writing a library with several functions, don't test all
+   functions using size 1, then all functions using size 2, etc.  If a
+   test for size 42 fails, you have no easy way of tracking down why
+   it failed.
+
+   It is better to concentrate on getting one function to work at a
+   time, which means that you test each function for all sizes that
+   you think is reasonable.  Then you continue with the next function,
+   doing the same. This is usually also the way that a library is
+   developed (one function at a time) so stick to testing that is
+   appropriate for now the unit is developed.
+
+   @subsection JustToBeSafeTest Writing unnecessarily large tests
+
+   Don't write tests that use parameters in the range 1-1024 unless
+   you have a very good reason to believe that the component will
+   succeed for 562 but fail for 564 (the numbers picked are just
+   examples).
+
+   It is very common to write extensive tests "just to be safe."
+   Having a test suite with a lot of values might give you a warm
+   fuzzy feeling, but it doesn't really help you find the bugs.  Good
+   tests fail; seriously, if you write a test that you expect to
+   succeed, you don't need to write it.  If you think that it
+   <em>might</em> fail, <em>then</em> you should write it.
+
+   Don't take this as an excuse to avoid writing any tests at all
+   "since I make no mistakes" (when it comes to this, there are two
+   kinds of people: those who admit they make mistakes, and those who
+   don't); rather, this means that there is no reason to test that
+   using a buffer with size 100 works when you have a test for buffer
+   size 96.
+
+   The drawback is that the test suite takes longer to run, for little
+   or no benefit.  It is acceptable to do a exhaustive test if it
+   doesn't take too long to run and it is quite common to do an
+   exhaustive test of a function for a small set of values.
+   Use your judgment to decide what is excessive: your milage may
+   vary.
+*/
+
+/**
+   @example simple.t.c
+
+   This is an simple example of how to write a test using the
+   library.  The output of this program is:
+
+   @code
+   1..1
+   # Testing basic functions
+   ok 1 - Testing gcs()
+   @endcode
+
+   The basic structure is: plan the number of test points using the
+   plan() function, perform the test and write out the result of each
+   test point using the ok() function, print out a diagnostics message
+   using diag(), and report the result of the test by calling the
+   exit_status() function.  Observe that this test does excessive
+   testing (see @ref JustToBeSafeTest), but the test point doesn't
+   take very long time.
+*/
+
+/**
+   @example todo.t.c
+
+   This example demonstrates how to use the <code>todo_start()</code>
+   and <code>todo_end()</code> function to mark a sequence of tests to
+   be done.  Observe that the tests are assumed to fail: if any test
+   succeeds, it is considered a "bonus".
+*/
+
+/**
+   @example skip.t.c
+
+   This is an example of how the <code>SKIP_BLOCK_IF</code> can be
+   used to skip a predetermined number of tests. Observe that the
+   macro actually skips the following statement, but it's not sensible
+   to use anything than a block.
+*/
+
+/**
+   @example skip_all.t.c
+
+   Sometimes, you skip an entire test because it's testing a feature
+   that doesn't exist on the system that you're testing. To skip an
+   entire test, use the <code>skip_all()</code> function according to
+   this example.
+ */
diff --git a/libmariadb/unittest/mytap/tap.h b/libmariadb/unittest/mytap/tap.h
new file mode 100644
index 00000000..15b1842b
--- /dev/null
+++ b/libmariadb/unittest/mytap/tap.h
@@ -0,0 +1,305 @@
+/* Copyright (C) 2006 MySQL AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+   MA 02111-1301, USA
+
+   Library for providing TAP support for testing C and C++ was written
+   by Mats Kindahl <mats@mysql.com>.
+*/
+
+#ifndef TAP_H
+#define TAP_H
+
+#include "ma_global.h"
+
+/*
+  @defgroup MyTAP MySQL support for performing unit tests according to
+  the Test Anything Protocol (TAP).
+*/
+
+#define NO_PLAN  (0)
+
+/**
+   Data about test plan.
+
+   @ingroup MyTAP_Internal
+
+   @internal We are using the "typedef struct X { ... } X" idiom to
+   create class/struct X both in C and C++.
+ */
+
+typedef struct TEST_DATA {
+  /**
+     Number of tests that is planned to execute.
+
+     Can be zero (<code>NO_PLAN</code>) meaning that the plan string
+     will be printed at the end of test instead.
+  */
+  int plan;
+
+  /** Number of last test that was done or skipped. */
+  int last;
+
+  /** Number of tests that failed. */
+  int failed;
+
+  /** Todo reason. */
+  char todo[128];
+} TEST_DATA;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+   Defines whether "big" tests should be skipped.
+
+   This variable is set by plan() function unless MYTAP_CONFIG environment
+   variable is set to the string "big".  It is supposed to be used as
+
+   @code
+   if (skip_big_tests) {
+     skip(1, "Big test skipped");
+   } else {
+     ok(life_universe_and_everything() == 42, "The answer is CORRECT");
+   }
+   @endcode
+
+   @see SKIP_BIG_TESTS
+*/
+extern int skip_big_tests;
+
+/**
+  @defgroup MyTAP_API MyTAP API
+
+  MySQL support for performing unit tests according to TAP.
+
+  @{
+*/
+
+/**
+   Set number of tests that is planned to execute.
+
+   The function also accepts the predefined constant
+   <code>NO_PLAN</code>.  If the function is not called, it is as if
+   it was called with <code>NO_PLAN</code>, i.e., the test plan will
+   be printed after all the test lines.
+
+   The plan() function will install signal handlers for all signals
+   that generate a core, so if you want to override these signals, do
+   it <em>after</em> you have called the plan() function.
+
+   It will also set skip_big_tests variable if MYTAP_CONFIG environment
+   variable is defined.
+
+   @see skip_big_tests
+
+   @param count The planned number of tests to run.
+*/
+
+void plan(int const count);
+
+
+/**
+   Report test result as a TAP line.
+
+   Function used to write status of an individual test.  Call this
+   function in the following manner:
+
+   @code
+   ok(ducks == paddling,
+      "%d ducks did not paddle", ducks - paddling);
+   @endcode
+
+   @param pass Zero if the test failed, non-zero if it passed.
+   @param fmt  Format string in printf() format. NULL is allowed, in
+               which case nothing is printed.
+*/
+
+void ok(int const pass, char const *fmt, ...)
+  __attribute__((format(printf,2,3)));
+
+
+/**
+   Skip a determined number of tests.
+
+   Function to print that <em>how_many</em> tests have been skipped.
+   The reason is printed for each skipped test.  Observe that this
+   function does not do the actual skipping for you, it just prints
+   information that tests have been skipped. This function is not
+   usually used, but rather the macro @c SKIP_BLOCK_IF, which does the
+   skipping for you.
+
+   It shall be used in the following manner:
+
+   @code
+   if (ducks == 0) {
+     skip(2, "No ducks in the pond");
+   } else {
+      int i;
+      for (i = 0 ; i < 2 ; ++i)
+        ok(duck[i] == paddling, "is duck %d paddling?", i);
+   }
+   @endcode
+
+   @see SKIP_BLOCK_IF
+
+   @param how_many   Number of tests that are to be skipped.
+   @param reason     A reason for skipping the tests
+ */
+
+void skip(int how_many, char const *const reason, ...)
+    __attribute__((format(printf,2,3)));
+
+
+/**
+   Helper macro to skip a block of code.  The macro can be used to
+   simplify conditionally skipping a block of code.  It is used in the
+   following manner:
+
+   @code
+   SKIP_BLOCK_IF(ducks == 0, 2, "No ducks in the pond")
+   {
+     int i;
+     for (i = 0 ; i < 2 ; ++i)
+       ok(duck[i] == paddling, "is duck %d paddling?", i);
+   }
+   @endcode
+
+   @see skip
+ */
+
+#define SKIP_BLOCK_IF(SKIP_IF_TRUE, COUNT, REASON) \
+  if (SKIP_IF_TRUE) skip((COUNT),(REASON)); else
+
+
+/**
+   Helper macro to skip a group of "big" tests. It is used in the following
+   manner:
+
+   @code
+   SKIP_BIG_TESTS(1)
+   {
+     ok(life_universe_and_everything() == 42, "The answer is CORRECT");
+   }
+   @endcode
+
+   @see skip_big_tests
+ */
+
+#define SKIP_BIG_TESTS(COUNT) \
+  if (skip_big_tests) skip((COUNT), "big test"); else
+
+
+/**
+   Print a diagnostics message.
+
+   @param fmt  Diagnostics message in printf() format.
+ */
+
+void diag(char const *fmt, ...)
+  __attribute__((format(printf,1,2)));
+
+
+/**
+   Print a bail out message.
+
+   A bail out message can be issued when no further testing can be
+   done, e.g., when there are missing dependencies.
+
+   The test will exit with status 255.  This function does not return.
+
+   @code
+   BAIL_OUT("Lost connection to server %s", server_name);
+   @endcode
+
+   @note A bail out message is printed if a signal that generates a
+   core is raised.
+
+   @param fmt Bail out message in printf() format.
+*/
+
+void BAIL_OUT(char const *fmt, ...)
+  __attribute__((noreturn, format(printf,1,2)));
+
+
+/**
+   Print summary report and return exit status.
+
+   This function will print a summary report of how many tests passed,
+   how many were skipped, and how many remains to do.  The function
+   should be called after all tests are executed in the following
+   manner:
+
+   @code
+   return exit_status();
+   @endcode
+
+   @returns @c EXIT_SUCCESS if all tests passed, @c EXIT_FAILURE if
+   one or more tests failed.
+ */
+
+int exit_status(void);
+
+
+/**
+   Skip entire test suite.
+
+   To skip the entire test suite, use this function. It will
+   automatically call exit(), so there is no need to have checks
+   around it.
+ */
+
+void skip_all(char const *reason, ...)
+  __attribute__((noreturn, format(printf, 1, 2)));
+
+
+/**
+   Start section of tests that are not yet ready.
+
+   To start a section of tests that are not ready and are expected to
+   fail, use this function and todo_end() in the following manner:
+
+   @code
+   todo_start("Not ready yet");
+   ok(is_rocketeering(duck), "Rocket-propelled ducks");
+   ok(is_kamikaze(duck), "Kamikaze ducks");
+   todo_end();
+   @endcode
+
+   @see todo_end
+
+   @note
+   It is not possible to nest todo sections.
+
+   @param message Message that will be printed before the todo tests.
+*/
+
+void todo_start(char const *message, ...)
+  __attribute__((format(printf, 1, 2)));
+
+
+/**
+   End a section of tests that are not yet ready.
+*/
+
+void todo_end();
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TAP_H */