Move bundled copy of sqlite one level deeper to better separate it...

third_party/sqlite/test/backup_ioerr.test

-# 2009 January 30
-#
-# 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 the handling of IO errors by the
-# sqlite3_backup_XXX APIs.
-#
-# $Id: backup_ioerr.test,v 1.3 2009/04/10 18:41:01 danielk1977 Exp $
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-
-proc data_checksum {db file} { 
-  $db one "SELECT md5sum(a, b) FROM ${file}.t1" 
-}
-proc test_contents {name db1 file1 db2 file2} {
-  $db2 eval {select * from sqlite_master}
-  $db1 eval {select * from sqlite_master}
-  set checksum [data_checksum $db2 $file2]
-  uplevel [list do_test $name [list data_checksum $db1 $file1] $checksum]
-}
-
-#--------------------------------------------------------------------
-# This proc creates a database of approximately 290 pages. Depending
-# on whether or not auto-vacuum is configured. Test cases backup_ioerr-1.*
-# verify nothing more than this assumption.
-#
-proc populate_database {db {xtra_large 0}} {
-  execsql {
-    BEGIN;
-    CREATE TABLE t1(a, b);
-    INSERT INTO t1 VALUES(1, randstr(1000,1000));
-    INSERT INTO t1 SELECT a+ 1, randstr(1000,1000) FROM t1;
-    INSERT INTO t1 SELECT a+ 2, randstr(1000,1000) FROM t1;
-    INSERT INTO t1 SELECT a+ 4, randstr(1000,1000) FROM t1;
-    INSERT INTO t1 SELECT a+ 8, randstr(1000,1000) FROM t1;
-    INSERT INTO t1 SELECT a+16, randstr(1000,1000) FROM t1;
-    INSERT INTO t1 SELECT a+32, randstr(1000,1000) FROM t1;
-    CREATE INDEX i1 ON t1(b);
-    COMMIT;
-  } $db
-  if {$xtra_large} {
-    execsql { INSERT INTO t1 SELECT a+64, randstr(1000,1000) FROM t1 } $db
-  }
-}
-do_test backup_ioerr-1.1 {
-  populate_database db
-  set nPage [expr {[file size test.db] / 1024}]
-  expr {$nPage>130 && $nPage<160}
-} {1}
-do_test backup_ioerr-1.2 {
-  expr {[file size test.db] > $sqlite_pending_byte}
-} {1}
-do_test backup_ioerr-1.3 {
-  db close
-  file delete -force test.db
-} {}
-
-# Turn off IO error simulation.
-#
-proc clear_ioerr_simulation {} {
-  set ::sqlite_io_error_hit 0
-  set ::sqlite_io_error_hardhit 0
-  set ::sqlite_io_error_pending 0
-  set ::sqlite_io_error_persist 0
-}
-
-#--------------------------------------------------------------------
-# The following procedure runs with SQLite's IO error simulation 
-# enabled.
-#
-#   1) Start with a reasonably sized database. One that includes the
-#      pending-byte (locking) page.
-#
-#   2) Open a backup process. Set the cache-size for the destination
-#      database to 10 pages only.
-#
-#   3) Step the backup process N times to partially backup the database
-#      file. If an IO error is reported, then the backup process is
-#      concluded with a call to backup_finish().
-#
-#      If an IO error occurs, verify that:
-#
-#      * the call to backup_step() returns an SQLITE_IOERR_XXX error code.
-#
-#      * after the failed call to backup_step() but before the call to
-#        backup_finish() the destination database handle error code and 
-#        error message remain unchanged.
-#
-#      * the call to backup_finish() returns an SQLITE_IOERR_XXX error code.
-#
-#      * following the call to backup_finish(), the destination database
-#        handle has been populated with an error code and error message.
-#
-#   4) Write to the database via the source database connection. Check 
-#      that:
-#
-#      * If an IO error occurs while writing the source database, the
-#        write operation should report an IO error. The backup should 
-#        proceed as normal.
-#
-#      * If an IO error occurs while updating the backup, the write 
-#        operation should proceed normally. The error should be reported
-#        from the next call to backup_step() (in step 5 of this test
-#        procedure).
-#
-#   5) Step the backup process to finish the backup. If an IO error is 
-#      reported, then the backup process is concluded with a call to 
-#      backup_finish().
-#
-#      Test that if an IO error occurs, or if one occured while updating
-#      the backup database during step 4, then the conditions listed
-#      under step 3 are all true.
-#
-#   6) Finish the backup process.
-#
-#   * If the backup succeeds (backup_finish() returns SQLITE_OK), then
-#     the contents of the backup database should match that of the
-#     source database.
-#
-#   * If the backup fails (backup_finish() returns other than SQLITE_OK), 
-#     then the contents of the backup database should be as they were 
-#     before the operation was started.
-#
-# The following factors are varied:
-#
-#   * Destination database is initially larger than the source database, OR
-#   * Destination database is initially smaller than the source database.
-#
-#   * IO errors are transient, OR
-#   * IO errors are persistent.
-#
-#   * Destination page-size is smaller than the source.
-#   * Destination page-size is the same as the source.
-#   * Destination page-size is larger than the source.
-#
-
-set iTest 1
-foreach bPersist {0 1} {
-foreach iDestPagesize {512 1024 4096} {
-foreach zSetupBak [list "" {populate_database ddb 1}] {
-
-  incr iTest
-  set bStop 0
-for {set iError 1} {$bStop == 0} {incr iError} {
-  # Disable IO error simulation.
-  clear_ioerr_simulation
-
-  catch { ddb close }
-  catch { sdb close }
-  catch { file delete -force test.db }
-  catch { file delete -force bak.db }
-
-  # Open the source and destination databases.
-  sqlite3 sdb test.db
-  sqlite3 ddb bak.db
-
-  # Step 1: Populate the source and destination databases.
-  populate_database sdb
-  ddb eval "PRAGMA page_size = $iDestPagesize"
-  ddb eval "PRAGMA cache_size = 10"
-  eval $zSetupBak
-
-  # Step 2: Open the backup process.
-  sqlite3_backup B ddb main sdb main
-
-  # Enable IO error simulation.
-  set ::sqlite_io_error_pending $iError
-  set ::sqlite_io_error_persist $bPersist
-
-  # Step 3: Partially backup the database. If an IO error occurs, check
-  # a few things then skip to the next iteration of the loop.
-  #
-  set rc [B step 100]
-  if {$::sqlite_io_error_hardhit} {
-
-    do_test backup_ioerr-$iTest.$iError.1 {
-      string match SQLITE_IOERR* $rc
-    } {1}
-    do_test backup_ioerr-$iTest.$iError.2 {
-      list [sqlite3_errcode ddb] [sqlite3_errmsg ddb]
-    } {SQLITE_OK {not an error}}
-
-    set rc [B finish]
-    do_test backup_ioerr-$iTest.$iError.3 {
-      string match SQLITE_IOERR* $rc
-    } {1}
-
-    do_test backup_ioerr-$iTest.$iError.4 {
-      sqlite3_errmsg ddb
-    } {disk I/O error}
-
-    clear_ioerr_simulation
-    sqlite3 ddb bak.db
-    integrity_check backup_ioerr-$iTest.$iError.5 ddb
-
-    continue
-  }
-
-  # No IO error was encountered during step 3. Check that backup_step()
-  # returned SQLITE_OK before proceding.
-  do_test backup_ioerr-$iTest.$iError.6 {
-    expr {$rc eq "SQLITE_OK"}
-  } {1}
-
-  # Step 4: Write to the source database.
-  set rc [catchsql { UPDATE t1 SET b = randstr(1000,1000) WHERE a < 50 } sdb]
-
-  if {[lindex $rc 0] && $::sqlite_io_error_persist==0} {
-    # The IO error occured while updating the source database. In this
-    # case the backup should be able to continue.
-    set rc [B step 5000]
-    if { $rc != "SQLITE_IOERR_UNLOCK" } {
-      do_test backup_ioerr-$iTest.$iError.7 {
-        list [B step 5000] [B finish]
-      } {SQLITE_DONE SQLITE_OK}
-
-      clear_ioerr_simulation
-      test_contents backup_ioerr-$iTest.$iError.8 ddb main sdb main
-      integrity_check backup_ioerr-$iTest.$iError.9 ddb
-    } else {
-      do_test backup_ioerr-$iTest.$iError.10 {
-        B finish
-      } {SQLITE_IOERR_UNLOCK}
-    }
-
-    clear_ioerr_simulation
-    sqlite3 ddb bak.db
-    integrity_check backup_ioerr-$iTest.$iError.11 ddb
-
-    continue
-  }
-
-  # Step 5: Finish the backup operation. If an IO error occurs, check that
-  # it is reported correctly and skip to the next iteration of the loop.
-  #
-  set rc [B step 5000]
-  if {$rc != "SQLITE_DONE"} {
-    do_test backup_ioerr-$iTest.$iError.12 {
-      string match SQLITE_IOERR* $rc
-    } {1}
-    do_test backup_ioerr-$iTest.$iError.13 {
-      list [sqlite3_errcode ddb] [sqlite3_errmsg ddb]
-    } {SQLITE_OK {not an error}}
-
-    set rc [B finish]
-    do_test backup_ioerr-$iTest.$iError.14 {
-      string match SQLITE_IOERR* $rc
-    } {1}
-    do_test backup_ioerr-$iTest.$iError.15 {
-      sqlite3_errmsg ddb
-    } {disk I/O error}
-
-    clear_ioerr_simulation
-    sqlite3 ddb bak.db
-    integrity_check backup_ioerr-$iTest.$iError.16 ddb
-
-    continue
-  }
-
-  # The backup was successfully completed.
-  #
-  do_test backup_ioerr-$iTest.$iError.17 {
-    list [set rc] [B finish]
-  } {SQLITE_DONE SQLITE_OK}
-
-  clear_ioerr_simulation
-  sqlite3 sdb test.db
-  sqlite3 ddb bak.db
-
-  test_contents backup_ioerr-$iTest.$iError.18 ddb main sdb main
-  integrity_check backup_ioerr-$iTest.$iError.19 ddb
-
-  set bStop [expr $::sqlite_io_error_pending<=0]
-}}}}
-
-catch { sdb close }
-catch { ddb close }
-finish_test