# 2010 August 19 # # 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 file is testing that the current version of SQLite # is capable of reading and writing databases created by previous # versions, and vice-versa. # # To use this test, old versions of the testfixture process should be # copied into the working directory alongside the new version. The old # versions should be named "testfixtureXXX" (or testfixtureXXX.exe on # windows), where XXX can be any string. # # This test file uses the tcl code for controlling a second testfixture # process located in lock_common.tcl. See the commments in lock_common.tcl # for documentation of the available commands. # set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/lock_common.tcl source $testdir/malloc_common.tcl db close # Search for binaries to test against. Any executable files that match # our naming convention are assumed to be testfixture binaries to test # against. # set binaries [list] set pattern "[file tail [info nameofexec]]?*" if {$tcl_platform(platform)=="windows"} { set pattern [string map {\.exe {}} $pattern] } foreach file [glob -nocomplain $pattern] { if {[file executable $file]} {lappend binaries $file} } if {[llength $binaries]==0} { puts "WARNING: No historical binaries to test against." puts "WARNING: No backwards-compatibility tests have been run." finish_test return } proc get_version {binary} { set chan [launch_testfixture $binary] set v [testfixture $chan { sqlite3 -version }] close $chan set v } foreach bin $binaries { puts -nonewline "Testing against $bin - " flush stdout puts "version [get_version $bin]" } proc do_backcompat_test {rv bin1 bin2 script} { file delete -force test.db if {$bin1 != ""} { set ::bc_chan1 [launch_testfixture $bin1] } set ::bc_chan2 [launch_testfixture $bin2] if { $rv } { proc code2 {tcl} { uplevel #0 $tcl } if {$bin1 != ""} { proc code2 {tcl} { testfixture $::bc_chan1 $tcl } } proc code1 {tcl} { testfixture $::bc_chan2 $tcl } } else { proc code1 {tcl} { uplevel #0 $tcl } if {$bin1 != ""} { proc code1 {tcl} { testfixture $::bc_chan1 $tcl } } proc code2 {tcl} { testfixture $::bc_chan2 $tcl } } proc sql1 sql { code1 [list db eval $sql] } proc sql2 sql { code2 [list db eval $sql] } code1 { sqlite3 db test.db } code2 { sqlite3 db test.db } uplevel $script catch { code1 { db close } } catch { code2 { db close } } catch { close $::bc_chan2 } catch { close $::bc_chan1 } } array set ::incompatible [list] proc do_allbackcompat_test {script} { foreach bin $::binaries { set nErr [set_test_counter errors] foreach dir {0 1} { set bintag [string map {testfixture {}} $bin] set bintag [string map {\.exe {}} $bintag] if {$bintag == ""} {set bintag self} set ::bcname ".$bintag.$dir." rename do_test _do_test proc do_test {nm sql res} { set nm [regsub {\.} $nm $::bcname] uplevel [list _do_test $nm $sql $res] } do_backcompat_test $dir {} $bin $script rename do_test {} rename _do_test do_test } if { $nErr < [set_test_counter errors] } { set ::incompatible([get_version $bin]) 1 } } } proc read_file {zFile} { set zData {} if {[file exists $zFile]} { set fd [open $zFile] fconfigure $fd -translation binary -encoding binary if {[file size $zFile]<=$::sqlite_pending_byte || $zFile != "test.db"} { set zData [read $fd] } else { set zData [read $fd $::sqlite_pending_byte] append zData [string repeat x 512] seek $fd [expr $::sqlite_pending_byte+512] start append zData [read $fd] } close $fd } return $zData } proc write_file {zFile zData} { set fd [open $zFile w] fconfigure $fd -translation binary -encoding binary puts -nonewline $fd $zData close $fd } proc read_file_system {} { set ret [list] foreach f {test.db test.db-journal test.db-wal} { lappend ret [read_file $f] } set ret } proc write_file_system {data} { foreach f {test.db test.db-journal test.db-wal} d $data { if {[string length $d] == 0} { file delete -force $f } else { write_file $f $d } } } #------------------------------------------------------------------------- # Actual tests begin here. # # This first block of tests checks to see that the same database and # journal files can be used by old and new versions. WAL and wal-index # files are tested separately below. # do_allbackcompat_test { # Test that database files are backwards compatible. # do_test backcompat-1.1.1 { sql1 { CREATE TABLE t1(a PRIMARY KEY, b UNIQUE); INSERT INTO t1 VALUES('abc', 'def'); } } {} do_test backcompat-1.1.2 { sql2 { SELECT * FROM t1; } } {abc def} do_test backcompat-1.1.3 { sql2 { INSERT INTO t1 VALUES('ghi', 'jkl'); } } {} do_test backcompat-1.1.4 { sql1 { SELECT * FROM t1; } } {abc def ghi jkl} do_test backcompat-1.1.5 { sql1 { PRAGMA integrity_check } } {ok} do_test backcompat-1.1.6 { sql2 { PRAGMA integrity_check } } {ok} # Test that one version can roll back a hot-journal file left in the # file-system by the other version. # # Each test case is named "backcompat-1.X...", where X is either 0 or # 1. If it is 0, then the current version creates a journal file that # the old versions try to read. Otherwise, if X is 1, then the old version # creates the journal file and we try to read it with the current version. # do_test backcompat-1.2.1 { sql1 { PRAGMA cache_size = 10; BEGIN; INSERT INTO t1 VALUES(randomblob(400), randomblob(400)); INSERT INTO t1 SELECT randomblob(400), randomblob(400) FROM t1; INSERT INTO t1 SELECT randomblob(400), randomblob(400) FROM t1; INSERT INTO t1 SELECT randomblob(400), randomblob(400) FROM t1; INSERT INTO t1 SELECT randomblob(400), randomblob(400) FROM t1; COMMIT; } } {} set cksum1 [sql1 {SELECT md5sum(a), md5sum(b) FROM t1}] set cksum2 [sql2 {SELECT md5sum(a), md5sum(b) FROM t1}] do_test backcompat-1.2.2 [list string compare $cksum1 $cksum2] 0 do_test backcompat-1.2.3 { sql1 { BEGIN; UPDATE t1 SET a = randomblob(500); } } {} set data [read_file_system] do_test backcompat-1.2.4 { sql1 { COMMIT } } {} set same [expr {[sql2 {SELECT md5sum(a), md5sum(b) FROM t1}] == $cksum2}] do_test backcompat-1.2.5 [list set {} $same] 0 code1 { db close } code2 { db close } write_file_system $data code1 { sqlite3 db test.db } code2 { sqlite3 db test.db } set same [expr {[sql2 {SELECT md5sum(a), md5sum(b) FROM t1}] == $cksum2}] do_test backcompat-1.2.6 [list set {} $same] 1 do_test backcompat-1.2.7 { sql1 { PRAGMA integrity_check } } {ok} do_test backcompat-1.2.8 { sql2 { PRAGMA integrity_check } } {ok} } foreach k [lsort [array names ::incompatible]] { puts "ERROR: Detected journal incompatibility with version $k" } unset ::incompatible #------------------------------------------------------------------------- # Test that WAL and wal-index files may be shared between different # SQLite versions. # do_allbackcompat_test { if {[code1 {sqlite3 -version}] >= "3.7.0" && [code2 {sqlite3 -version}] >= "3.7.0" } { do_test backcompat-2.1.1 { sql1 { PRAGMA journal_mode = WAL; CREATE TABLE t1(a PRIMARY KEY, b UNIQUE); INSERT INTO t1 VALUES('I', 1); INSERT INTO t1 VALUES('II', 2); INSERT INTO t1 VALUES('III', 3); SELECT * FROM t1; } } {wal I 1 II 2 III 3} do_test backcompat-2.1.2 { sql2 { SELECT * FROM t1; } } {I 1 II 2 III 3} set data [read_file_system] code1 {db close} code2 {db close} write_file_system $data code1 {sqlite3 db test.db} code2 {sqlite3 db test.db} # The WAL file now in the file-system was created by the [code1] # process. Check that the [code2] process can recover the log. # do_test backcompat-2.1.3 { sql2 { SELECT * FROM t1; } } {I 1 II 2 III 3} do_test backcompat-2.1.4 { sql1 { SELECT * FROM t1; } } {I 1 II 2 III 3} } } finish_test