Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Rationalize a common pattern in tcl test cases into proc do_multiclient_test. |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
efe44564983f115017658dd8a1302263 |
User & Date: | dan 2010-06-15 19:07:42.000 |
Context
2010-06-16
| ||
10:55 | Fix a memory leak that can occur in os_unix.c if an IO error occurs within the xUnlock method. (check-in: 6c5c04eea1 user: dan tags: trunk) | |
2010-06-15
| ||
19:07 | Rationalize a common pattern in tcl test cases into proc do_multiclient_test. (check-in: efe4456498 user: dan tags: trunk) | |
18:00 | Fix a problem introduced into lock2.test by the previous commit. (check-in: c1c9f6fa9d user: dan tags: trunk) | |
Changes
Changes to test/crash8.test.
︙ | ︙ | |||
378 379 380 381 382 383 384 | INSERT INTO t1 SELECT randomblob(900) FROM t1; INSERT INTO t1 SELECT randomblob(900) FROM t1; INSERT INTO t1 SELECT randomblob(900) FROM t1; INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 64 rows */ BEGIN; UPDATE t1 SET x = randomblob(900); } | | | 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 | INSERT INTO t1 SELECT randomblob(900) FROM t1; INSERT INTO t1 SELECT randomblob(900) FROM t1; INSERT INTO t1 SELECT randomblob(900) FROM t1; INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 64 rows */ BEGIN; UPDATE t1 SET x = randomblob(900); } file delete -force testX.db testX.db-journal testX.db-wal copy_file test.db testX.db copy_file test.db-journal testX.db-journal db close crashsql -file test.db -delay [expr ($::i%2) + 1] { SELECT * FROM sqlite_master; INSERT INTO t1 VALUES(randomblob(900)); |
︙ | ︙ |
Changes to test/lock_common.tcl.
︙ | ︙ | |||
8 9 10 11 12 13 14 15 16 17 18 19 20 21 | # May you share freely, never taking more than you give. # #*********************************************************************** # This file contains code used by several different test scripts. The # code in this file allows testfixture to control another process (or # processes) to test locking. # # Launch another testfixture process to be controlled by this one. A # channel name is returned that may be passed as the first argument to proc # 'testfixture' to execute a command. The child testfixture process is shut # down by closing the channel. proc launch_testfixture {} { set prg [info nameofexec] | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 | # May you share freely, never taking more than you give. # #*********************************************************************** # This file contains code used by several different test scripts. The # code in this file allows testfixture to control another process (or # processes) to test locking. # proc do_multiclient_test {varname script} { foreach code [list { set ::code2_chan [launch_testfixture] set ::code3_chan [launch_testfixture] proc code2 {tcl} { testfixture $::code2_chan $tcl } proc code3 {tcl} { testfixture $::code3_chan $tcl } set tn 1 } { proc code2 {tcl} { uplevel #0 $tcl } proc code3 {tcl} { uplevel #0 $tcl } set tn 2 }] { faultsim_delete_and_reopen # Open connections [db2] and [db3]. Depending on which iteration this # is, the connections may be created in this interpreter, or in # interpreters running in other OS processes. As such, the [db2] and [db3] # commands should only be accessed within [code2] and [code3] blocks, # respectively. # eval $code code2 { sqlite3 db2 test.db } code3 { sqlite3 db3 test.db } # Shorthand commands. Execute SQL using database connection [db2] or # [db3]. Return the results. # proc sql1 {sql} { db eval $sql } proc sql2 {sql} { code2 [list db2 eval $sql] } proc sql3 {sql} { code3 [list db3 eval $sql] } proc csql1 {sql} { list [catch { sql1 $sql } msg] $msg } proc csql2 {sql} { list [catch { sql2 $sql } msg] $msg } proc csql3 {sql} { list [catch { sql3 $sql } msg] $msg } uplevel set $varname $tn uplevel $script code2 { db2 close } code3 { db3 close } catch { close $::code2_chan } catch { close $::code3_chan } } } # Launch another testfixture process to be controlled by this one. A # channel name is returned that may be passed as the first argument to proc # 'testfixture' to execute a command. The child testfixture process is shut # down by closing the channel. proc launch_testfixture {} { set prg [info nameofexec] |
︙ | ︙ |
Changes to test/pager1.test.
︙ | ︙ | |||
11 12 13 14 15 16 17 | # set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/lock_common.tcl source $testdir/malloc_common.tcl | < < < < < < < < < < < | < < < < < < < < < < < < < < < < < < < < < < | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | # set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/lock_common.tcl source $testdir/malloc_common.tcl do_multiclient_test tn { # Create and populate a database table using connection [db]. Check # that connections [db2] and [db3] can see the schema and content. # do_test pager1-$tn.1 { sql1 { CREATE TABLE t1(a PRIMARY KEY, b); |
︙ | ︙ | |||
72 73 74 75 76 77 78 | do_test pager1-$tn.4 { sql1 { BEGIN; INSERT INTO t1 VALUES(3, 'three'); } } {} do_test pager1-$tn.5 { sql2 { SELECT * FROM t1 } } {1 one 2 two} | < | 39 40 41 42 43 44 45 46 47 48 49 50 51 52 | do_test pager1-$tn.4 { sql1 { BEGIN; INSERT INTO t1 VALUES(3, 'three'); } } {} do_test pager1-$tn.5 { sql2 { SELECT * FROM t1 } } {1 one 2 two} do_test pager1-$tn.7 { sql1 { SELECT * FROM t1 } } {1 one 2 two 3 three} # [db] still has an open write transaction. Check that this prevents # other connections (specifically [db2]) from writing to the database. # # Even if [db2] opens a transaction first, it may not write to the # database. After the attempt to write the db within a transaction, |
︙ | ︙ | |||
179 180 181 182 183 184 185 | # committed, all three connections can read the new content. # do_test pager1-$tn.25 { sql1 { UPDATE t1 SET a = a+10 } } {} do_test pager1-$tn.26 { sql1 { COMMIT } } {} do_test pager1-$tn.27 { sql1 { SELECT * FROM t1 } } {21 one 22 two 23 three} do_test pager1-$tn.27 { sql2 { SELECT * FROM t1 } } {21 one 22 two 23 three} do_test pager1-$tn.28 { sql3 { SELECT * FROM t1 } } {21 one 22 two 23 three} | < < < < < | 145 146 147 148 149 150 151 152 153 154 155 | # committed, all three connections can read the new content. # do_test pager1-$tn.25 { sql1 { UPDATE t1 SET a = a+10 } } {} do_test pager1-$tn.26 { sql1 { COMMIT } } {} do_test pager1-$tn.27 { sql1 { SELECT * FROM t1 } } {21 one 22 two 23 three} do_test pager1-$tn.27 { sql2 { SELECT * FROM t1 } } {21 one 22 two 23 three} do_test pager1-$tn.28 { sql3 { SELECT * FROM t1 } } {21 one 22 two 23 three} } finish_test |
Changes to test/wal.test.
︙ | ︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | # focus of this file is testing the operation of the library in # "PRAGMA journal_mode=WAL" mode. # set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/lock_common.tcl ifcapable !wal {finish_test ; return } proc reopen_db {} { catch { db close } file delete -force test.db test.db-wal test.db-wal-summary sqlite3_wal db test.db | > | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | # focus of this file is testing the operation of the library in # "PRAGMA journal_mode=WAL" mode. # set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/lock_common.tcl source $testdir/malloc_common.tcl ifcapable !wal {finish_test ; return } proc reopen_db {} { catch { db close } file delete -force test.db test.db-wal test.db-wal-summary sqlite3_wal db test.db |
︙ | ︙ | |||
455 456 457 458 459 460 461 | #------------------------------------------------------------------------- # The following block of tests - wal-10.* - test that the WAL locking # scheme works in simple cases. This block of tests is run twice. Once # using multiple connections in the address space of the current process, # and once with all connections except one running in external processes. # | < < < < < < < < < < < | < < < < < < < < < < < < < < < < < > | | 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 | #------------------------------------------------------------------------- # The following block of tests - wal-10.* - test that the WAL locking # scheme works in simple cases. This block of tests is run twice. Once # using multiple connections in the address space of the current process, # and once with all connections except one running in external processes. # do_multiclient_test tn { # Initialize the database schema and contents. # do_test wal-10.$tn.1 { execsql { PRAGMA journal_mode = wal; CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(1, 2); SELECT * FROM t1; } } {wal 1 2} # Open a transaction and write to the database using [db]. Check that [db2] # is still able to read the snapshot before the transaction was opened. # do_test wal-10.$tn.2 { execsql { BEGIN; INSERT INTO t1 VALUES(3, 4); } sql2 {SELECT * FROM t1} |
︙ | ︙ | |||
688 689 690 691 692 693 694 | sql3 { INSERT INTO t1 VALUES('e', 'f') } sql2 { SELECT * FROM t1 } } {a b c d} do_test wal-10.$tn.37 { sql2 COMMIT execsql { PRAGMA wal_checkpoint } } {} | < < < < < < | 662 663 664 665 666 667 668 669 670 671 672 673 674 675 | sql3 { INSERT INTO t1 VALUES('e', 'f') } sql2 { SELECT * FROM t1 } } {a b c d} do_test wal-10.$tn.37 { sql2 COMMIT execsql { PRAGMA wal_checkpoint } } {} } #------------------------------------------------------------------------- # This block of tests, wal-11.*, test that nothing goes terribly wrong # if frames must be written to the log file before a transaction is # committed (in order to free up memory). # |
︙ | ︙ | |||
896 897 898 899 900 901 902 | } execsql { SELECT count(*) FROM t2 } } [expr int(pow(2, 16))] do_test wal-13.2.3 { expr [file size test.db-wal] > [log_file_size 33000 1024] } 1 | < | < < | < < < < < < < | | | | | | | < < < < | 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 | } execsql { SELECT count(*) FROM t2 } } [expr int(pow(2, 16))] do_test wal-13.2.3 { expr [file size test.db-wal] > [log_file_size 33000 1024] } 1 do_multiclient_test tn { incr tn 2 do_test wal-13.$tn.0 { sql1 { PRAGMA journal_mode = WAL; CREATE TABLE t1(x); INSERT INTO t1 SELECT randomblob(800); } sql1 { SELECT count(*) FROM t1 } } {1} for {set ii 1} {$ii<16} {incr ii} { do_test wal-13.$tn.$ii.a { sql2 { INSERT INTO t1 SELECT randomblob(800) FROM t1 } sql2 { SELECT count(*) FROM t1 } } [expr (1<<$ii)] do_test wal-13.$tn.$ii.b { sql1 { SELECT count(*) FROM t1 } } [expr (1<<$ii)] do_test wal-13.$tn.$ii.c { sql1 { SELECT count(*) FROM t1 } } [expr (1<<$ii)] do_test wal-13.$tn.$ii.d { sql1 { PRAGMA integrity_check } } {ok} } } #------------------------------------------------------------------------- # Check a fun corruption case has been fixed. # # The problem was that after performing a checkpoint using a connection # that had an out-of-date pager-cache, the next time the connection was |
︙ | ︙ |
Changes to test/wal3.test.
︙ | ︙ | |||
106 107 108 109 110 111 112 | } $str do_test wal3-1.$i.7 { execsql { PRAGMA integrity_check } db2 } {ok} db2 close } | < < < < < < < < < < < < < < < | < < < < < | | | | < < | < < < < | | | 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | } $str do_test wal3-1.$i.7 { execsql { PRAGMA integrity_check } db2 } {ok} db2 close } do_multiclient_test i { set testname(1) multiproc set testname(2) singleproc set tn $testname($i) do_test wal3-2.$tn.1 { sql1 { PRAGMA page_size = 1024; PRAGMA auto_vacuum = OFF; PRAGMA journal_mode = WAL; } sql1 { CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(1, 'one'); BEGIN; SELECT * FROM t1; } } {1 one} do_test wal3-2.$tn.2 { |
︙ | ︙ | |||
177 178 179 180 181 182 183 | # these frames would clobber the snapshot currently being used by [db2]). # # After [db2] has committed, a checkpoint can copy the entire log to the # database file. Checkpointing after [db3] has committed is therefore a # no-op, as the entire log has already been backfilled. # do_test wal3-2.$tn.4 { | | < < < < < < | 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 | # these frames would clobber the snapshot currently being used by [db2]). # # After [db2] has committed, a checkpoint can copy the entire log to the # database file. Checkpointing after [db3] has committed is therefore a # no-op, as the entire log has already been backfilled. # do_test wal3-2.$tn.4 { sql1 { COMMIT; PRAGMA wal_checkpoint; } file size test.db } [expr $AUTOVACUUM ? 4*1024 : 3*1024] do_test wal3-2.$tn.5 { sql2 { COMMIT; PRAGMA wal_checkpoint; } file size test.db } [expr $AUTOVACUUM ? 5*1024 : 4*1024] do_test wal3-2.$tn.6 { sql3 { COMMIT; PRAGMA wal_checkpoint; } file size test.db } [expr $AUTOVACUUM ? 5*1024 : 4*1024] } catch {db close} #------------------------------------------------------------------------- # Test that that for the simple test: # # CREATE TABLE x(y); |
︙ | ︙ |