Import SQLite 3.8.7.4.

third_party/sqlite/src/test/backup.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.
 #
 #***********************************************************************
@@ skipping 55 matching lines @@
   }
 } {}
 
 # Sanity check to verify that the [test_contents] proc works.
 #
 test_contents backup-1.2 db main db main
 
 # Check that it is possible to create and finish backup operations.
 #
 do_test backup-1.3.1 {
-  file delete test2.db
+  delete_file test2.db
   sqlite3 db2 test2.db
   sqlite3_backup B db2 main db main
 } {B}
 do_test backup-1.3.2 {
   B finish
 } {SQLITE_OK}
 do_test backup-1.3.3 {
   info commands B
 } {}
 
@@ skipping 74 matching lines @@
   sqlite3 db $zSrcFile
   sqlite3 db2 $zDestFile
   set db_dest db2
   set file_dest temp
 }] {
 foreach rows_dest {0 3 10} {
 foreach pgsz_dest {512 1024 2048} {
 foreach nPagePerStep {1 200} {
 
   # Open the databases.
-  catch { file delete test.db }
-  catch { file delete test2.db }
+  catch { delete_file test.db }
+  catch { delete_file test2.db }
   eval $zOpenScript
 
   # Set to true if copying to an in-memory destination. Copying to an 
   # in-memory destination is only possible if the initial destination
   # page size is the same as the source page size (in this case 1024 bytes).
   #
   set isMemDest [expr {
     $zDestFile eq ":memory:" || $file_dest eq "temp" && $TEMP_STORE>=2
   }]
 
@@ skipping 89 matching lines @@
 #
 #   * Target database page-size is the same as the source, OR
 #   * Target database page-size is larger than the source, OR
 #   * Target database page-size is smaller than the source.
 #
 set iTest 1
 foreach nSrcPg {10 64 65 66 100} {
 foreach nDestRow {10 100} {
 foreach nDestPgsz {512 1024 2048 4096} {
 
-  catch { file delete test.db }
-  catch { file delete test2.db }
+  catch { delete_file test.db }
+  catch { delete_file test2.db }
   sqlite3 db test.db
   sqlite3 db2 test2.db
 
   # Set up the content of the two databases.
   #
   execsql { PRAGMA page_size = 1024 }
   execsql "PRAGMA page_size = $nDestPgsz" db2
   foreach db {db db2} {
     execsql {
       BEGIN; 
@@ skipping 26 matching lines @@
 
   db close
   db2 close
   incr iTest
 }
 }
 }
 
 #--------------------------------------------------------------------
 do_test backup-3.$iTest.1 {
-  catch { file delete -force test.db }
-  catch { file delete -force test2.db }
+  catch { forcedelete test.db }
+  catch { forcedelete test2.db }
   sqlite3 db test.db
   set iTab 1
 
   db eval { PRAGMA page_size = 512 }
   while {[file size test.db] <= $::sqlite_pending_byte} {
     db eval "CREATE TABLE t${iTab}(a, b, c)"
     incr iTab
   }
 
   sqlite3 db2 test2.db
@@ skipping 43 matching lines @@
   sqlite3_errmsg db
 } {unknown database aux}
 do_test backup-4.1.3 {
   catch { sqlite3_backup B db main db2 aux }
 } {1}
 do_test backup-4.1.4 {
   sqlite3_errmsg db
 } {unknown database aux}
 
 do_test backup-4.2.1 {
-  catch { file delete -force test3.db }
-  catch { file delete -force test4.db }
+  catch { forcedelete test3.db }
+  catch { forcedelete test4.db }
   execsql { 
     ATTACH 'test3.db' AS aux1;
     CREATE TABLE aux1.t1(a, b);
   }
   execsql { 
     ATTACH 'test4.db' AS aux2;
     CREATE TABLE aux2.t2(a, b);
   } db2
   sqlite3_backup B db aux1 db2 aux2
 } {B}
 do_test backup-4.2.2 {
   catchsql { DETACH aux2 } db2
 } {1 {database aux2 is locked}}
 do_test backup-4.2.3 {
   B step 50
 } {SQLITE_DONE}
 do_test backup-4.2.4 {
   B finish
 } {SQLITE_OK}
 
 do_test backup-4.3.1 {
   sqlite3_backup B db aux1 db2 aux2
 } {B}
 do_test backup-4.3.2 {
   db2 cache flush
   sqlite3_close db2
 } {SQLITE_BUSY}
 do_test backup-4.3.3 {
   sqlite3_errmsg db2
-} {unable to close due to unfinished backup operation}
+} {unable to close due to unfinalized statements or unfinished backups}
 do_test backup-4.3.4 {
   B step 50
 } {SQLITE_DONE}
 do_test backup-4.3.5 {
   B finish
 } {SQLITE_OK}
 
 do_test backup-4.4.1 {
   set rc [catch {sqlite3_backup B db main db aux1}]
   list $rc [sqlite3_errcode db] [sqlite3_errmsg db]
 } {1 SQLITE_ERROR {source and destination must be distinct}}
 db close
 db2 close
 
 do_test backup-4.5.1 {
-  catch { file delete -force test.db }
+  catch { forcedelete test.db }
   sqlite3 db test.db
   sqlite3 db2 :memory:
   execsql {
     CREATE TABLE t1(a, b);
     INSERT INTO t1 VALUES(1, 2);
   }
   execsql {
     PRAGMA page_size = 4096;
     CREATE TABLE t2(a, b);
     INSERT INTO t2 VALUES(3, 4);
   } db2
   sqlite3_backup B db2 main db main
 } {B}
 do_test backup-4.5.2 {
   B step 5000
 } {SQLITE_READONLY}
 do_test backup-4.5.3 {
   B finish
 } {SQLITE_READONLY}
 
 db close
 db2 close
 #
-# End of backup-5.* tests.
+# End of backup-4.* tests.
 #---------------------------------------------------------------------
 
 #---------------------------------------------------------------------
 # The following tests, backup-5.*, test that the backup works properly
 # when the source database is modified during the backup. Test cases
 # are organized as follows:
 #
 # backup-5.x.1.*: Nothing special. Modify the database mid-backup.
 #
 # backup-5.x.2.*: Modify the database mid-backup so that one or more
 #                 pages are written out due to cache stress. Then 
 #                 rollback the transaction.
 #
 # backup-5.x.3.*: Database is vacuumed.
 #
 # backup-5.x.4.*: Database is vacuumed and the page-size modified.
 #
 # backup-5.x.5.*: Database is shrunk via incr-vacuum.
 #
 # Each test is run three times, in the following configurations:
 #
 #   1) Backing up file-to-file. The writer writes via an external pager.
 #   2) Backing up file-to-file. The writer writes via the same pager as
 #      is used by the backup operation.
 #   3) Backing up memory-to-file. 
 #
 set iTest 0
-file delete -force bak.db-wal
+forcedelete bak.db-wal
 foreach {writer file} {db test.db db3 test.db db :memory:} {
   incr iTest
-  catch { file delete bak.db }
+  catch { delete_file bak.db }
   sqlite3 db2 bak.db
-  catch { file delete $file }
+  catch { delete_file $file }
   sqlite3 db $file
   sqlite3 db3 $file
 
   do_test backup-5.$iTest.1.1 {
     execsql {
       BEGIN;
       CREATE TABLE t1(a, b);
       CREATE INDEX i1 ON t1(a, b);
       INSERT INTO t1 VALUES(1, randstr(1000,1000));
       INSERT INTO t1 VALUES(2, randstr(1000,1000));
@@ skipping 80 matching lines @@
   } {SQLITE_DONE}
   do_test backup-5.$iTest.4.4 {
     B finish
   } {SQLITE_OK} 
   integrity_check backup-5.$iTest.4.5 db2
   test_contents backup-5.$iTest.4.6 db main db2 main
 
   catch {db close}
   catch {db2 close}
   catch {db3 close}
-  catch { file delete bak.db }
+  catch { delete_file bak.db }
   sqlite3 db2 bak.db
-  catch { file delete $file }
+  catch { delete_file $file }
   sqlite3 db $file
   sqlite3 db3 $file
   do_test backup-5.$iTest.5.1 {
     execsql {
       PRAGMA auto_vacuum = incremental;
       BEGIN;
       CREATE TABLE t1(a, b);
       CREATE INDEX i1 ON t1(a, b);
       INSERT INTO t1 VALUES(1, randstr(1000,1000));
       INSERT INTO t1 VALUES(2, randstr(1000,1000));
@@ skipping 24 matching lines @@
   catch {db3 close}
 }
 #
 # End of backup-5.* tests.
 #---------------------------------------------------------------------
 
 #---------------------------------------------------------------------
 # Test the sqlite3_backup_remaining() and backup_pagecount() APIs.
 #
 do_test backup-6.1 {
-  catch { file delete -force test.db }
-  catch { file delete -force test2.db }
+  catch { forcedelete test.db }
+  catch { forcedelete test2.db }
   sqlite3 db test.db
   sqlite3 db2 test2.db
   execsql {
     BEGIN;
     CREATE TABLE t1(a, b);
     CREATE INDEX i1 ON t1(a, b);
     INSERT INTO t1 VALUES(1, randstr(1000,1000));
     INSERT INTO t1 VALUES(2, randstr(1000,1000));
     INSERT INTO t1 VALUES(3, randstr(1000,1000));
     INSERT INTO t1 VALUES(4, randstr(1000,1000));
@@ skipping 35 matching lines @@
 #
 # backup-7.1.*: Source database is externally locked (return SQLITE_BUSY).
 #
 # backup-7.2.*: Attempt to step the backup process while a 
 #               write-transaction is underway on the source pager (return
 #               SQLITE_LOCKED).
 #
 # backup-7.3.*: Destination database is externally locked (return SQLITE_BUSY).
 #
 do_test backup-7.0 {
-  catch { file delete -force test.db }
-  catch { file delete -force test2.db }
+  catch { forcedelete test.db }
+  catch { forcedelete test2.db }
   sqlite3 db2 test2.db
   sqlite3 db test.db
   execsql {
     CREATE TABLE t1(a, b);
     CREATE INDEX i1 ON 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;
@@ skipping 31 matching lines @@
 } {SQLITE_DONE}
 do_test backup-7.2.4 {
   B finish
 } {SQLITE_OK}
 test_contents backup-7.2.5 db main db2 main
 integrity_check backup-7.3.6 db2
 
 do_test backup-7.3.1 {
   db2 close
   db3 close
-  file delete -force test2.db
+  forcedelete test2.db
   sqlite3 db2 test2.db
   sqlite3 db3 test2.db
 
   sqlite3_backup B db2 main db main
   execsql { BEGIN ; CREATE TABLE t2(a, b); } db3
 
   B step 5
 } {SQLITE_BUSY}
 do_test backup-7.3.2 {
   execsql { COMMIT } db3
   B step 5000
 } {SQLITE_DONE}
 do_test backup-7.3.3 {
   B finish
 } {SQLITE_OK}
 test_contents backup-7.3.4 db main db2 main
 integrity_check backup-7.3.5 db2
 catch { db2 close }
 catch { db3 close }
 
 #-----------------------------------------------------------------------
 # The following tests, backup-8.*, test attaching multiple backup
 # processes to the same source database. Also, reading from the source
 # database while a read transaction is active.
 #
 # These tests reuse the database "test.db" left over from backup-7.*.
 #
 do_test backup-8.1 {
-  catch { file delete -force test2.db }
-  catch { file delete -force test3.db }
+  catch { forcedelete test2.db }
+  catch { forcedelete test3.db }
   sqlite3 db2 test2.db
   sqlite3 db3 test3.db
 
   sqlite3_backup B2 db2 main db main
   sqlite3_backup B3 db3 main db main
   list [B2 finish] [B3 finish]
 } {SQLITE_OK SQLITE_OK}
 do_test backup-8.2 {
   sqlite3_backup B3 db3 main db main
   sqlite3_backup B2 db2 main db main
@@ skipping 60 matching lines @@
 do_test backup-9.2.2 {
   B remaining
 } {0}
 do_test backup-9.2.3 {
   B finish
 } {SQLITE_OK}
 catch {db2 close}
 
 ifcapable memorymanage {
   db close
-  file delete -force test.db
-  file delete -force bak.db
+  forcedelete test.db
+  forcedelete bak.db
 
   sqlite3 db test.db
   sqlite3 db2 test.db
   sqlite3 db3 bak.db
 
   do_test backup-10.1.1 {
     execsql {
       BEGIN;
       CREATE TABLE t1(a, b);
       INSERT INTO t1 VALUES(1, randstr(1000,1000));
@@ skipping 31 matching lines @@
 
 
 #-----------------------------------------------------------------------
 # Test that if the database is written to via the same database handle being
 # used as the source by a backup operation:
 #
 #   10.1.*: If the db is in-memory, the backup is restarted.
 #   10.2.*: If the db is a file, the backup is not restarted.
 #
 db close
-file delete -force test.db test.db-journal
+forcedelete test.db test.db-journal
 foreach {tn file rc} {
   1 test.db  SQLITE_DONE
   2 :memory: SQLITE_OK
 } {
   do_test backup-10.$tn.1 {
     sqlite3 db $file
     execsql { 
       CREATE TABLE t1(a INTEGER PRIMARY KEY, b BLOB);
       BEGIN;
         INSERT INTO t1 VALUES(NULL, randomblob(200));
         INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
         INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
         INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
         INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
         INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
         INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
         INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
         INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
       COMMIT;
       SELECT count(*) FROM t1;
     }
   } {256}
 
   do_test backup-10.$tn.2 {
     set pgs [execsql {pragma page_count}]
     expr {$pgs > 50 && $pgs < 75}
   } {1}
 
   do_test backup-10.$tn.3 {
-    file delete -force bak.db bak.db-journal
+    forcedelete bak.db bak.db-journal
     sqlite3 db2 bak.db
     sqlite3_backup B db2 main db main
     B step 50
   } {SQLITE_OK}
 
   do_test backup-10.$tn.4 {
     execsql { UPDATE t1 SET b = randomblob(200) WHERE a IN (1, 250) }
   } {}
 
   do_test backup-10.$tn.5 {
     B step 50
   } $rc
 
   do_test backup-10.$tn.6 {
     B finish
   } {SQLITE_OK}
 
   db2 close
 }
 
 finish_test