1 # 2009 January 30 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. The 12 # focus of this file is testing the handling of IO errors by the 13 # sqlite3_backup_XXX APIs. 14 # 15 # $Id: backup_ioerr.test,v 1.3 2009/04/10 18:41:01 danielk1977 Exp $ 16 17 set testdir [file dirname $argv0] 18 source $testdir/tester.tcl 19 20 proc data_checksum {db file} { 21 $db one "SELECT md5sum(a, b) FROM ${file}.t1" 22 } 23 proc test_contents {name db1 file1 db2 file2} { 24 $db2 eval {select * from sqlite_master} 25 $db1 eval {select * from sqlite_master} 26 set checksum [data_checksum $db2 $file2] 27 uplevel [list do_test $name [list data_checksum $db1 $file1] $checksum] 28 } 29 30 #-------------------------------------------------------------------- 31 # This proc creates a database of approximately 290 pages. Depending 32 # on whether or not auto-vacuum is configured. Test cases backup_ioerr-1.* 33 # verify nothing more than this assumption. 34 # 35 proc populate_database {db {xtra_large 0}} { 36 execsql { 37 BEGIN; 38 CREATE TABLE t1(a, b); 39 INSERT INTO t1 VALUES(1, randstr(1000,1000)); 40 INSERT INTO t1 SELECT a+ 1, randstr(1000,1000) FROM t1; 41 INSERT INTO t1 SELECT a+ 2, randstr(1000,1000) FROM t1; 42 INSERT INTO t1 SELECT a+ 4, randstr(1000,1000) FROM t1; 43 INSERT INTO t1 SELECT a+ 8, randstr(1000,1000) FROM t1; 44 INSERT INTO t1 SELECT a+16, randstr(1000,1000) FROM t1; 45 INSERT INTO t1 SELECT a+32, randstr(1000,1000) FROM t1; 46 CREATE INDEX i1 ON t1(b); 47 COMMIT; 48 } $db 49 if {$xtra_large} { 50 execsql { INSERT INTO t1 SELECT a+64, randstr(1000,1000) FROM t1 } $db 51 } 52 } 53 do_test backup_ioerr-1.1 { 54 populate_database db 55 set nPage [expr {[file size test.db] / 1024}] 56 expr {$nPage>130 && $nPage<160} 57 } {1} 58 do_test backup_ioerr-1.2 { 59 expr {[file size test.db] > $sqlite_pending_byte} 60 } {1} 61 do_test backup_ioerr-1.3 { 62 db close 63 file delete -force test.db 64 } {} 65 66 # Turn off IO error simulation. 67 # 68 proc clear_ioerr_simulation {} { 69 set ::sqlite_io_error_hit 0 70 set ::sqlite_io_error_hardhit 0 71 set ::sqlite_io_error_pending 0 72 set ::sqlite_io_error_persist 0 73 } 74 75 #-------------------------------------------------------------------- 76 # The following procedure runs with SQLite's IO error simulation 77 # enabled. 78 # 79 # 1) Start with a reasonably sized database. One that includes the 80 # pending-byte (locking) page. 81 # 82 # 2) Open a backup process. Set the cache-size for the destination 83 # database to 10 pages only. 84 # 85 # 3) Step the backup process N times to partially backup the database 86 # file. If an IO error is reported, then the backup process is 87 # concluded with a call to backup_finish(). 88 # 89 # If an IO error occurs, verify that: 90 # 91 # * the call to backup_step() returns an SQLITE_IOERR_XXX error code. 92 # 93 # * after the failed call to backup_step() but before the call to 94 # backup_finish() the destination database handle error code and 95 # error message remain unchanged. 96 # 97 # * the call to backup_finish() returns an SQLITE_IOERR_XXX error code. 98 # 99 # * following the call to backup_finish(), the destination database 100 # handle has been populated with an error code and error message. 101 # 102 # 4) Write to the database via the source database connection. Check 103 # that: 104 # 105 # * If an IO error occurs while writing the source database, the 106 # write operation should report an IO error. The backup should 107 # proceed as normal. 108 # 109 # * If an IO error occurs while updating the backup, the write 110 # operation should proceed normally. The error should be reported 111 # from the next call to backup_step() (in step 5 of this test 112 # procedure). 113 # 114 # 5) Step the backup process to finish the backup. If an IO error is 115 # reported, then the backup process is concluded with a call to 116 # backup_finish(). 117 # 118 # Test that if an IO error occurs, or if one occured while updating 119 # the backup database during step 4, then the conditions listed 120 # under step 3 are all true. 121 # 122 # 6) Finish the backup process. 123 # 124 # * If the backup succeeds (backup_finish() returns SQLITE_OK), then 125 # the contents of the backup database should match that of the 126 # source database. 127 # 128 # * If the backup fails (backup_finish() returns other than SQLITE_OK), 129 # then the contents of the backup database should be as they were 130 # before the operation was started. 131 # 132 # The following factors are varied: 133 # 134 # * Destination database is initially larger than the source database, OR 135 # * Destination database is initially smaller than the source database. 136 # 137 # * IO errors are transient, OR 138 # * IO errors are persistent. 139 # 140 # * Destination page-size is smaller than the source. 141 # * Destination page-size is the same as the source. 142 # * Destination page-size is larger than the source. 143 # 144 145 set iTest 1 146 foreach bPersist {0 1} { 147 foreach iDestPagesize {512 1024 4096} { 148 foreach zSetupBak [list "" {populate_database ddb 1}] { 149 150 incr iTest 151 set bStop 0 152 for {set iError 1} {$bStop == 0} {incr iError} { 153 # Disable IO error simulation. 154 clear_ioerr_simulation 155 156 catch { ddb close } 157 catch { sdb close } 158 catch { file delete -force test.db } 159 catch { file delete -force bak.db } 160 161 # Open the source and destination databases. 162 sqlite3 sdb test.db 163 sqlite3 ddb bak.db 164 165 # Step 1: Populate the source and destination databases. 166 populate_database sdb 167 ddb eval "PRAGMA page_size = $iDestPagesize" 168 ddb eval "PRAGMA cache_size = 10" 169 eval $zSetupBak 170 171 # Step 2: Open the backup process. 172 sqlite3_backup B ddb main sdb main 173 174 # Enable IO error simulation. 175 set ::sqlite_io_error_pending $iError 176 set ::sqlite_io_error_persist $bPersist 177 178 # Step 3: Partially backup the database. If an IO error occurs, check 179 # a few things then skip to the next iteration of the loop. 180 # 181 set rc [B step 100] 182 if {$::sqlite_io_error_hardhit} { 183 184 do_test backup_ioerr-$iTest.$iError.1 { 185 string match SQLITE_IOERR* $rc 186 } {1} 187 do_test backup_ioerr-$iTest.$iError.2 { 188 list [sqlite3_errcode ddb] [sqlite3_errmsg ddb] 189 } {SQLITE_OK {not an error}} 190 191 set rc [B finish] 192 do_test backup_ioerr-$iTest.$iError.3 { 193 string match SQLITE_IOERR* $rc 194 } {1} 195 196 do_test backup_ioerr-$iTest.$iError.4 { 197 sqlite3_errmsg ddb 198 } {disk I/O error} 199 200 clear_ioerr_simulation 201 sqlite3 ddb bak.db 202 integrity_check backup_ioerr-$iTest.$iError.5 ddb 203 204 continue 205 } 206 207 # No IO error was encountered during step 3. Check that backup_step() 208 # returned SQLITE_OK before proceding. 209 do_test backup_ioerr-$iTest.$iError.6 { 210 expr {$rc eq "SQLITE_OK"} 211 } {1} 212 213 # Step 4: Write to the source database. 214 set rc [catchsql { UPDATE t1 SET b = randstr(1000,1000) WHERE a < 50 } sdb] 215 216 if {[lindex $rc 0] && $::sqlite_io_error_persist==0} { 217 # The IO error occured while updating the source database. In this 218 # case the backup should be able to continue. 219 set rc [B step 5000] 220 if { $rc != "SQLITE_IOERR_UNLOCK" } { 221 do_test backup_ioerr-$iTest.$iError.7 { 222 list [B step 5000] [B finish] 223 } {SQLITE_DONE SQLITE_OK} 224 225 clear_ioerr_simulation 226 test_contents backup_ioerr-$iTest.$iError.8 ddb main sdb main 227 integrity_check backup_ioerr-$iTest.$iError.9 ddb 228 } else { 229 do_test backup_ioerr-$iTest.$iError.10 { 230 B finish 231 } {SQLITE_IOERR_UNLOCK} 232 } 233 234 clear_ioerr_simulation 235 sqlite3 ddb bak.db 236 integrity_check backup_ioerr-$iTest.$iError.11 ddb 237 238 continue 239 } 240 241 # Step 5: Finish the backup operation. If an IO error occurs, check that 242 # it is reported correctly and skip to the next iteration of the loop. 243 # 244 set rc [B step 5000] 245 if {$rc != "SQLITE_DONE"} { 246 do_test backup_ioerr-$iTest.$iError.12 { 247 string match SQLITE_IOERR* $rc 248 } {1} 249 do_test backup_ioerr-$iTest.$iError.13 { 250 list [sqlite3_errcode ddb] [sqlite3_errmsg ddb] 251 } {SQLITE_OK {not an error}} 252 253 set rc [B finish] 254 do_test backup_ioerr-$iTest.$iError.14 { 255 string match SQLITE_IOERR* $rc 256 } {1} 257 do_test backup_ioerr-$iTest.$iError.15 { 258 sqlite3_errmsg ddb 259 } {disk I/O error} 260 261 clear_ioerr_simulation 262 sqlite3 ddb bak.db 263 integrity_check backup_ioerr-$iTest.$iError.16 ddb 264 265 continue 266 } 267 268 # The backup was successfully completed. 269 # 270 do_test backup_ioerr-$iTest.$iError.17 { 271 list [set rc] [B finish] 272 } {SQLITE_DONE SQLITE_OK} 273 274 clear_ioerr_simulation 275 sqlite3 sdb test.db 276 sqlite3 ddb bak.db 277 278 test_contents backup_ioerr-$iTest.$iError.18 ddb main sdb main 279 integrity_check backup_ioerr-$iTest.$iError.19 ddb 280 281 set bStop [expr $::sqlite_io_error_pending<=0] 282 }}}} 283 284 catch { sdb close } 285 catch { ddb close } 286 finish_test 287
