Annotation of embedaddon/sqlite3/test/misuse.test, revision 1.1.1.1

1.1       misho       1: # 2002 May 10
                      2: #
                      3: # The author disclaims copyright to this source code.  In place of
                      4: # a legal notice, here is a blessing:
                      5: #
                      6: #    May you do good and not evil.
                      7: #    May you find forgiveness for yourself and forgive others.
                      8: #    May you share freely, never taking more than you give.
                      9: #
                     10: #***********************************************************************
                     11: # This file implements regression tests for SQLite library.
                     12: #
                     13: # This file implements tests for the SQLITE_MISUSE detection logic.
                     14: # This test file leaks memory and file descriptors.
                     15: #
                     16: # $Id: misuse.test,v 1.11 2006/01/03 00:33:50 drh Exp $
                     17: 
                     18: set testdir [file dirname $argv0]
                     19: source $testdir/tester.tcl
                     20: 
                     21: proc catchsql2 {sql} {
                     22:   set r [
                     23:     catch {
                     24:       set res [list]
                     25:       db eval $sql data {
                     26:         if { $res==[list] } {
                     27:           foreach f $data(*) {lappend res $f}
                     28:         }
                     29:         foreach f $data(*) {lappend res $data($f)}
                     30:       }
                     31:       set res
                     32:     } msg
                     33:   ]
                     34:   lappend r $msg
                     35: }
                     36: 
                     37: 
                     38: # Make sure the test logic works
                     39: #
                     40: do_test misuse-1.1 {
                     41:   db close
                     42:   catch {forcedelete test2.db}
                     43:   catch {forcedelete test2.db-journal}
                     44:   sqlite3 db test2.db; set ::DB [sqlite3_connection_pointer db]
                     45:   execsql {
                     46:     CREATE TABLE t1(a,b);
                     47:     INSERT INTO t1 VALUES(1,2);
                     48:   }
                     49:   catchsql2 {
                     50:     SELECT * FROM t1
                     51:   }
                     52: } {0 {a b 1 2}}
                     53: do_test misuse-1.2 {
                     54:   catchsql2 {
                     55:     SELECT x_coalesce(NULL,a) AS 'xyz' FROM t1
                     56:   }
                     57: } {1 {no such function: x_coalesce}}
                     58: do_test misuse-1.3 {
                     59:   sqlite3_create_function $::DB
                     60:   catchsql2 {
                     61:     SELECT x_coalesce(NULL,a) AS 'xyz' FROM t1
                     62:   }
                     63: } {0 {xyz 1}}
                     64: 
                     65: # Use the x_sqlite_exec() SQL function to simulate the effect of two
                     66: # threads trying to use the same database at the same time.
                     67: #
                     68: # It used to be prohibited to invoke sqlite_exec() from within a function,
                     69: # but that has changed.  The following tests used to cause errors but now
                     70: # they do not.
                     71: #
                     72: ifcapable {utf16} {
                     73:   do_test misuse-1.4 {
                     74:     catchsql2 {
                     75:        SELECT x_sqlite_exec('SELECT * FROM t1') AS xyz;
                     76:     } 
                     77:   } {0 {xyz {1 2}}}
                     78: }
                     79: do_test misuse-1.5 {
                     80:   catchsql2 {SELECT * FROM t1}
                     81: } {0 {a b 1 2}}
                     82: do_test misuse-1.6 {
                     83:   catchsql {
                     84:     SELECT * FROM t1
                     85:   }
                     86: } {0 {1 2}}
                     87: 
                     88: # Attempt to register a new SQL function while an sqlite_exec() is active.
                     89: #
                     90: do_test misuse-2.1 {
                     91:   db close
                     92:   sqlite3 db test2.db; set ::DB [sqlite3_connection_pointer db]
                     93:   execsql {
                     94:     SELECT * FROM t1
                     95:   }
                     96: } {1 2}
                     97: do_test misuse-2.2 {
                     98:   catchsql2 {SELECT * FROM t1}
                     99: } {0 {a b 1 2}}
                    100: 
                    101: # We used to disallow creating new function from within an exec().
                    102: # But now this is acceptable.
                    103: do_test misuse-2.3 {
                    104:   set v [catch {
                    105:     db eval {SELECT * FROM t1} {} {
                    106:       sqlite3_create_function $::DB
                    107:     }
                    108:   } msg]
                    109:   lappend v $msg
                    110: } {0 {}}
                    111: do_test misuse-2.4 {
                    112:   catchsql2 {SELECT * FROM t1}
                    113: } {0 {a b 1 2}}
                    114: do_test misuse-2.5 {
                    115:   catchsql {
                    116:     SELECT * FROM t1
                    117:   }
                    118: } {0 {1 2}}
                    119: 
                    120: # Attempt to register a new SQL aggregate while an sqlite_exec() is active.
                    121: #
                    122: do_test misuse-3.1 {
                    123:   db close
                    124:   sqlite3 db test2.db; set ::DB [sqlite3_connection_pointer db]
                    125:   execsql {
                    126:     SELECT * FROM t1
                    127:   }
                    128: } {1 2}
                    129: do_test misuse-3.2 {
                    130:   catchsql2 {SELECT * FROM t1}
                    131: } {0 {a b 1 2}}
                    132: 
                    133: # We used to disallow creating new function from within an exec().
                    134: # But now this is acceptable.
                    135: do_test misuse-3.3 {
                    136:   set v [catch {
                    137:     db eval {SELECT * FROM t1} {} {
                    138:       sqlite3_create_aggregate $::DB
                    139:     }
                    140:   } msg]
                    141:   lappend v $msg
                    142: } {0 {}}
                    143: do_test misuse-3.4 {
                    144:   catchsql2 {SELECT * FROM t1}
                    145: } {0 {a b 1 2}}
                    146: do_test misuse-3.5 {
                    147:   catchsql {
                    148:     SELECT * FROM t1
                    149:   }
                    150: } {0 {1 2}}
                    151: 
                    152: # Attempt to close the database from an sqlite_exec callback.
                    153: #
                    154: # Update for v3: The db cannot be closed because there are active
                    155: # VMs. The sqlite3_close call would return SQLITE_BUSY.
                    156: do_test misuse-4.1 {
                    157:   db close
                    158:   sqlite3 db test2.db; set ::DB [sqlite3_connection_pointer db]
                    159:   execsql {
                    160:     SELECT * FROM t1
                    161:   }
                    162: } {1 2}
                    163: do_test misuse-4.2 {
                    164:   catchsql2 {SELECT * FROM t1}
                    165: } {0 {a b 1 2}}
                    166: do_test misuse-4.3 {
                    167:   set v [catch {
                    168:     db eval {SELECT * FROM t1} {} {
                    169:       set r [sqlite3_close $::DB]
                    170:     }
                    171:   } msg]
                    172:   lappend v $msg $r
                    173: } {0 {} SQLITE_BUSY}
                    174: do_test misuse-4.4 {
                    175:   # Flush the TCL statement cache here, otherwise the sqlite3_close() will
                    176:   # fail because there are still un-finalized() VDBEs.
                    177:   db cache flush
                    178:   sqlite3_close $::DB
                    179:   catchsql2 {SELECT * FROM t1}
                    180: } {1 {library routine called out of sequence}}
                    181: do_test misuse-4.5 {
                    182:   catchsql {
                    183:     SELECT * FROM t1
                    184:   }
                    185: } {1 {library routine called out of sequence}}
                    186: 
                    187: # Attempt to use a database after it has been closed.
                    188: #
                    189: do_test misuse-5.1 {
                    190:   db close
                    191:   sqlite3 db test2.db; set ::DB [sqlite3_connection_pointer db]
                    192:   execsql {
                    193:     SELECT * FROM t1
                    194:   }
                    195: } {1 2}
                    196: do_test misuse-5.2 {
                    197:   catchsql2 {SELECT * FROM t1}
                    198: } {0 {a b 1 2}}
                    199: do_test misuse-5.3 {
                    200:   db close
                    201:   set r [catch {
                    202:     sqlite3_prepare $::DB {SELECT * FROM t1} -1 TAIL
                    203:   } msg]
                    204:   lappend r $msg
                    205: } {1 {(21) library routine called out of sequence}}
                    206: 
                    207: finish_test

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>