Annotation of embedaddon/sqlite3/test/backup_ioerr.test, revision 1.1
1.1 ! misho 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: forcedelete 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 { forcedelete test.db }
! 159: catch { forcedelete 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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to backup_ioerr.test CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test