Import SQLite 3.8.7.4.

third_party/sqlite/src/test/capi3.test

 # 2003 January 29
 #
 # The author disclaims copyright to this source code.  In place of
 # a legal notice, here is a blessing:
 #
 #    May you do good and not evil.
 #    May you find forgiveness for yourself and forgive others.
 #    May you share freely, never taking more than you give.
 #
 #***********************************************************************
 # This file implements regression tests for SQLite library.  The
 # focus of this script testing the callback-free C/C++ API.
 #
 # $Id: capi3.test,v 1.70 2009/01/09 02:49:32 drh Exp $
 #
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
+set ::testprefix capi3
 
 # Do not use a codec for tests in this file, as the database file is
 # manipulated directly using tcl scripts (using the [hexio_write] command).
 #
 do_not_use_codec
 
 # Return the UTF-16 representation of the supplied UTF-8 string $str.
 # If $nt is true, append two 0x00 bytes as a nul terminator.
 proc utf16 {str {nt 1}} {
   set r [encoding convertto unicode $str]
@@ skipping 143 matching lines @@
     set db2 [sqlite3_open /bogus/path/test.db {}]
   }
   sqlite3_extended_errcode $db2
 } {SQLITE_CANTOPEN}
 do_test capi3-3.4 {
   sqlite3_errmsg $db2
 } {unable to open database file}
 do_test capi3-3.5 {
   sqlite3_close $db2
 } {SQLITE_OK}
-do_test capi3-3.6.1-misuse {
-  sqlite3_close $db2
-} {SQLITE_MISUSE}
-do_test capi3-3.6.2-misuse {
-  sqlite3_errmsg $db2
-} {library routine called out of sequence}
-ifcapable {utf16} {
-  do_test capi3-3.6.3-misuse {
-    utf8 [sqlite3_errmsg16 $db2]
+if {[clang_sanitize_address]==0} {
+  do_test capi3-3.6.1-misuse {
+    sqlite3_close $db2
+  } {SQLITE_MISUSE}
+  do_test capi3-3.6.2-misuse {
+    sqlite3_errmsg $db2
   } {library routine called out of sequence}
+  ifcapable {utf16} {
+    do_test capi3-3.6.3-misuse {
+      utf8 [sqlite3_errmsg16 $db2]
+    } {library routine called out of sequence}
+  }
 }
 
 do_test capi3-3.7 {
   set db2 [sqlite3_open]
   sqlite3_errcode $db2
 } {SQLITE_OK}
 do_test capi3-3.8 {
   sqlite3_close $db2
 } {SQLITE_OK}
 
@@ skipping 440 matching lines @@
   set DB [sqlite3_connection_pointer db]
   if {[sqlite3 -has-codec]==0} { sqlite3_key $DB xyzzy }
   set sql {SELECT a FROM t1 order by rowid}
   set STMT [sqlite3_prepare $DB $sql -1 TAIL]
   expr 0
 } {0}
 do_test capi3-6.1 {
   db cache flush
   sqlite3_close $DB
 } {SQLITE_BUSY}
+
+# 6.2 and 6.3 used to return SQLITE_ERROR and SQLITE_SCHEMA, respectively.
+# But since attempting to close a connection no longer resets the internal
+# schema and expires all statements, this is no longer the case.
 do_test capi3-6.2 {
   sqlite3_step $STMT
-} {SQLITE_ERROR}
+} {SQLITE_ROW}
 #check_data $STMT capi3-6.3 {INTEGER} {1} {1.0} {1}
 do_test capi3-6.3 {
   sqlite3_finalize $STMT
-} {SQLITE_SCHEMA}
-do_test capi3-6.4-misuse {
-  db cache flush
-  sqlite3_close $DB
 } {SQLITE_OK}
+
+if {[clang_sanitize_address]==0} {
+  do_test capi3-6.4-misuse {
+    db cache flush
+    sqlite3_close $DB
+  } {SQLITE_OK}
+}
 db close
 
 # This procedure sets the value of the file-format in file 'test.db'
 # to $newval. Also, the schema cookie is incremented.
 # 
 proc set_file_format {newval} {
   hexio_write test.db 44 [hexio_render_int32 $newval]
   set schemacookie [hexio_get_int [hexio_read test.db 40 4]]
   incr schemacookie
   hexio_write test.db 40 [hexio_render_int32 $schemacookie]
@@ skipping 17 matching lines @@
       SELECT * FROM sqlite_master;
     }
   } {1 {unsupported file format}}
   db close
 }
 
 if {![sqlite3 -has-codec]} {
   # Now test that the library correctly handles bogus entries in the
   # sqlite_master table (schema corruption).
   do_test capi3-8.1 {
-    file delete -force test.db test.db-journal
+    forcedelete test.db test.db-journal
     sqlite3 db test.db
     execsql {
       CREATE TABLE t1(a);
     }
     db close
   } {}
   do_test capi3-8.2 {
     sqlite3 db test.db
     execsql {
       PRAGMA writable_schema=ON;
       INSERT INTO sqlite_master VALUES(NULL,NULL,NULL,NULL,NULL);
     }
     db close
   } {}
   do_test capi3-8.3 {
     catch { sqlite3 db test.db }
     catchsql {
       SELECT * FROM sqlite_master;
     }
   } {1 {malformed database schema (?)}}
   do_test capi3-8.4 {
     # Build a 5-field row record. The first field is a string 'table', and
     # subsequent fields are all NULL.
     db close
-    file delete -force test.db test.db-journal
+    forcedelete test.db test.db-journal
     sqlite3 db test.db
     execsql {
       CREATE TABLE t1(a);
       PRAGMA writable_schema=ON;
       INSERT INTO sqlite_master VALUES('table',NULL,NULL,NULL,NULL);
     }
     db close
   } {};
   do_test capi3-8.5 {
     catch { sqlite3 db test.db }
     catchsql {
       SELECT * FROM sqlite_master;
     }
   } {1 {malformed database schema (?)}}
   db close
 }
-file delete -force test.db
-file delete -force test.db-journal
+forcedelete test.db
+forcedelete test.db-journal
 
 
 # Test the english language string equivalents for sqlite error codes
 set code2english [list \
 SQLITE_OK         {not an error} \
 SQLITE_ERROR      {SQL logic error or missing database} \
 SQLITE_PERM       {access permission denied} \
 SQLITE_ABORT      {callback requested query abort} \
 SQLITE_BUSY       {database is locked} \
 SQLITE_LOCKED     {database table is locked} \
@@ skipping 17 matching lines @@
 unknownerror      {unknown error} \
 ]
 
 set test_number 1
 foreach {code english} $code2english {
   do_test capi3-9.$test_number "sqlite3_test_errstr $code" $english
   incr test_number
 }
 
 # Test the error message when a "real" out of memory occurs.
+if { [permutation] != "nofaultsim" } {
 ifcapable memdebug {
   do_test capi3-10-1 {
     sqlite3 db test.db
     set DB [sqlite3_connection_pointer db]
     sqlite3_memdebug_fail 1
     catchsql {
       select * from sqlite_master;
     }
   } {1 {out of memory}}
   do_test capi3-10-2 {
@@ skipping 18 matching lines @@
     sqlite3_errmsg $::DB
   } {out of memory}
   ifcapable {utf16} {
     do_test capi3-10-6 {
       utf8 [sqlite3_errmsg16 $::DB]
     } {out of memory}
   }
   db close
   sqlite3_memdebug_fail -1
 }
+}
 
 # The following tests - capi3-11.* - test that a COMMIT or ROLLBACK
 # statement issued while there are still outstanding VMs that are part of
 # the transaction fails.
 sqlite3 db test.db
 set DB [sqlite3_connection_pointer db]
 sqlite_register_test_function $DB func
 do_test capi3-11.1 {
   execsql {
     BEGIN;
@@ skipping 58 matching lines @@
   set STMT [sqlite3_prepare $DB "SELECT a FROM t2" -1 TAIL]
   sqlite3_step $STMT
 } {SQLITE_ROW}
 do_test capi3-11.9.1 {
   sqlite3_get_autocommit $DB
 } 0
 do_test capi3-11.9.2 {
   catchsql {
     ROLLBACK;
   }
-} {1 {cannot rollback transaction - SQL statements in progress}}
+} {0 {}}
 do_test capi3-11.9.3 {
   sqlite3_get_autocommit $DB
-} 0
+} 1
 do_test capi3-11.10 {
   sqlite3_step $STMT
 } {SQLITE_ROW}
+ifcapable !autoreset {
+  # If SQLITE_OMIT_AUTORESET is defined, then the statement must be
+  # reset() before it can be passed to step() again.
+  do_test capi3-11.11a { sqlite3_step $STMT } {SQLITE_MISUSE}
+  do_test capi3-11.11b { sqlite3_reset $STMT } {SQLITE_ABORT}
+}
 do_test capi3-11.11 {
   sqlite3_step $STMT
-} {SQLITE_ROW}
+} {SQLITE_DONE}
 do_test capi3-11.12 {
   sqlite3_step $STMT
-} {SQLITE_DONE}
+  sqlite3_step $STMT
+} {SQLITE_ROW}
 do_test capi3-11.13 {
   sqlite3_finalize $STMT
 } {SQLITE_OK}
 do_test capi3-11.14 {
   execsql {
     SELECT a FROM t2;
   }
-} {1 2 3}
+} {1 2}
 do_test capi3-11.14.1 {
   sqlite3_get_autocommit $DB
-} 0
+} 1
 do_test capi3-11.15 {
   catchsql {
     ROLLBACK;
   }
-} {0 {}}
+} {1 {cannot rollback - no transaction is active}}
 do_test capi3-11.15.1 {
   sqlite3_get_autocommit $DB
 } 1
 do_test capi3-11.16 {
   execsql {
     SELECT a FROM t2;
   }
 } {1 2}
 
 # Sanity check on the definition of 'outstanding VM'. This means any VM
@@ skipping 103 matching lines @@
   } {{} {} hello world {} {}}
 }
 if {[llength [info commands sqlite3_sleep]]>0} {
   do_test capi3-13-5 {
     set ms [sqlite3_sleep 80]
     expr {$ms==80 || $ms==1000}
   } {1}
 }
 
 # Ticket #1219:  Make sure binding APIs can handle a NULL pointer.
-#
-do_test capi3-14.1-misuse {
-  set rc [catch {sqlite3_bind_text 0 1 hello 5} msg]
-  lappend rc $msg
-} {1 SQLITE_MISUSE}
+# 
+if {[clang_sanitize_address]==0} {
+  do_test capi3-14.1-misuse {
+    set rc [catch {sqlite3_bind_text 0 1 hello 5} msg]
+      lappend rc $msg
+  } {1 SQLITE_MISUSE}
+}
 
 # Ticket #1650:  Honor the nBytes parameter to sqlite3_prepare.
 #
 do_test capi3-15.1 {
   set sql {SELECT * FROM t2}
   set nbytes [string length $sql]
   append sql { WHERE a==1}
   set STMT [sqlite3_prepare $DB $sql $nbytes TAIL]
   sqlite3_step $STMT
   sqlite3_column_int $STMT 0
@@ skipping 130 matching lines @@
 sqlite3_finalize $STMT
 
 # Ticket #3134.  Prepare a statement with an nBytes parameter of 0.
 # Make sure this works correctly and does not reference memory out of
 # range.
 #
 do_test capi3-19.1 {
   sqlite3_prepare_tkt3134 db
 } {}
 
+# Test that calling sqlite3_column_blob() on a TEXT value does not change
+# the return type of subsequent calls to sqlite3_column_type().
+#
+do_execsql_test 20.1 {
+  CREATE TABLE t4(x);
+  INSERT INTO t4 VALUES('abcdefghij');
+}
+do_test 20.2 {
+  set stmt [sqlite3_prepare db "SELECT * FROM t4" -1 dummy]
+  sqlite3_step $stmt
+} {SQLITE_ROW}
+do_test 20.3 { sqlite3_column_type $stmt 0 } {TEXT}
+do_test 20.4 { sqlite3_column_blob $stmt 0 } {abcdefghij}
+do_test 20.5 { sqlite3_column_type $stmt 0 } {TEXT}
+do_test 20.6 { sqlite3_finalize $stmt } SQLITE_OK
+
+
 # Tests of the interface when no VFS is registered.
 #
 if {![info exists tester_do_binarylog]} {
   db close
   vfs_unregister_all
   do_test capi3-20.1 {
     sqlite3_sleep 100
   } {0}
   vfs_reregister_all
 }
 
 finish_test