Import SQLite 3.7.6.3.

third_party/sqlite/src/test/trans.test

 # 2001 September 15
 #
 # 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 script is database locks.
 #
 # $Id: trans.test,v 1.41 2009/04/28 16:37:59 danielk1977 Exp $
 
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 
 # Create several tables to work with.
 #
+wal_set_journal_mode
 do_test trans-1.0 {
   execsql {
     CREATE TABLE one(a int PRIMARY KEY, b text);
     INSERT INTO one VALUES(1,'one');
     INSERT INTO one VALUES(2,'two');
     INSERT INTO one VALUES(3,'three');
     SELECT b FROM one ORDER BY a;
   }
 } {one two three}
 integrity_check trans-1.0.1
 do_test trans-1.1 {
   execsql {
     CREATE TABLE two(a int PRIMARY KEY, b text);
     INSERT INTO two VALUES(1,'I');
     INSERT INTO two VALUES(5,'V');
     INSERT INTO two VALUES(10,'X');
     SELECT b FROM two ORDER BY a;
   }
 } {I V X}
 do_test trans-1.9 {
   sqlite3 altdb test.db
   execsql {SELECT b FROM one ORDER BY a} altdb
 } {one two three}
 do_test trans-1.10 {
   execsql {SELECT b FROM two ORDER BY a} altdb
 } {I V X}
 integrity_check trans-1.11
+wal_check_journal_mode trans-1.12
 
 # Basic transactions
 #
 do_test trans-2.1 {
   set v [catch {execsql {BEGIN}} msg]
   lappend v $msg
 } {0 {}}
 do_test trans-2.2 {
   set v [catch {execsql {END}} msg]
   lappend v $msg
@@ skipping 16 matching lines @@
 } {0 {}}
 do_test trans-2.10 {
   execsql {
     BEGIN;
     SELECT a FROM one ORDER BY a;
     SELECT a FROM two ORDER BY a;
     END;
   }
 } {1 2 3 1 5 10}
 integrity_check trans-2.11
+wal_check_journal_mode trans-2.12
 
 # Check the locking behavior
 #
 do_test trans-3.1 {
   execsql {
     BEGIN;
     UPDATE one SET a = 0 WHERE 0;
     SELECT a FROM one ORDER BY a;
   }
 } {1 2 3}
@@ skipping 60 matching lines @@
   } db} msg]
   lappend v $msg
 } {0 {1 4 5 10}}
 do_test trans-3.14 {
   set v [catch {execsql {
     SELECT a FROM one ORDER BY a;
   } db} msg]
   lappend v $msg
 } {0 {1 2 3 4}}
 integrity_check trans-3.15
+wal_check_journal_mode trans-3.16
 
 do_test trans-4.1 {
   set v [catch {execsql {
     COMMIT;
   } db} msg]
   lappend v $msg
 } {1 {cannot commit - no transaction is active}}
 do_test trans-4.2 {
   set v [catch {execsql {
     ROLLBACK;
@@ skipping 46 matching lines @@
   } altdb} msg]
   lappend v $msg
 } {0 {1 4 5 10}}
 do_test trans-4.11 {
   set v [catch {execsql {
     SELECT a FROM one ORDER BY a;
   } altdb} msg]
   lappend v $msg
 } {0 {1 2 3 4}}
 integrity_check trans-4.12
+wal_check_journal_mode trans-4.13
+wal_check_journal_mode trans-4.14 altdb
 do_test trans-4.98 {
   altdb close
   execsql {
     DROP TABLE one;
     DROP TABLE two;
   }
 } {}
 integrity_check trans-4.99
 
 # Check out the commit/rollback behavior of the database
@@ skipping 527 matching lines @@
       DROP TABLE t2;
       ROLLBACK;
       SELECT md5sum(x,y,z) FROM t2;
     }
   } $checksum
 }
 do_test trans-7.14 {
   execsql {SELECT md5sum(type,name,tbl_name,rootpage,sql) FROM sqlite_master}
 } $checksum2
 integrity_check trans-7.15
+wal_check_journal_mode trans-7.16
 
 # Arrange for another process to begin modifying the database but abort
 # and die in the middle of the modification.  Then have this process read
 # the database.  This process should detect the journal file and roll it
 # back.  Verify that this happens correctly.
 #
 set fd [open test.tcl w]
 puts $fd {
   sqlite3_test_control_pending_byte 0x0010000
   sqlite3 db test.db
@@ skipping 29 matching lines @@
 }
 close $fd
 do_test trans-8.4 {
   catch {exec [info nameofexec] test.tcl}
   execsql {SELECT md5sum(x,y,z) FROM t2}
 } $checksum
 do_test trans-8.5 {
   execsql {SELECT md5sum(type,name,tbl_name,rootpage,sql) FROM sqlite_master}
 } $checksum2
 integrity_check trans-8.6
-
+wal_check_journal_mode trans-8.7
 
 # In the following sequence of tests, compute the MD5 sum of the content
 # of a table, make lots of modifications to that table, then do a rollback.
 # Verify that after the rollback, the MD5 checksum is unchanged.
 #
 do_test trans-9.1 {
   execsql {
     PRAGMA default_cache_size=10;
   }
   db close
   sqlite3 db test.db
   execsql {
     BEGIN;
     CREATE TABLE t3(x TEXT);
     INSERT INTO t3 VALUES(randstr(10,400));
     INSERT INTO t3 VALUES(randstr(10,400));
     INSERT INTO t3 SELECT randstr(10,400) FROM t3;
     INSERT INTO t3 SELECT randstr(10,400) FROM t3;
     INSERT INTO t3 SELECT randstr(10,400) FROM t3;
     INSERT INTO t3 SELECT randstr(10,400) FROM t3;
     INSERT INTO t3 SELECT randstr(10,400) FROM t3;
     INSERT INTO t3 SELECT randstr(10,400) FROM t3;
     INSERT INTO t3 SELECT randstr(10,400) FROM t3;
     INSERT INTO t3 SELECT randstr(10,400) FROM t3;
     INSERT INTO t3 SELECT randstr(10,400) FROM t3;
     COMMIT;
     SELECT count(*) FROM t3;
   }
 } {1024}
+wal_check_journal_mode trans-9.1.1
 
 # The following procedure computes a "signature" for table "t3".  If
 # T3 changes in any way, the signature should change.  
 #
 # This is used to test ROLLBACK.  We gather a signature for t3, then
 # make lots of changes to t3, then rollback and take another signature.
 # The two signatures should be the same.
 #
 proc signature {} {
   return [db eval {SELECT count(*), md5sum(x) FROM t3}]
 }
 
 # Repeat the following group of tests 20 times for quick testing and
 # 40 times for full testing.  Each iteration of the test makes table
 # t3 a little larger, and thus takes a little longer, so doing 40 tests
 # is more than 2.0 times slower than doing 20 tests.  Considerably more.
 #
 # Also, if temporary tables are stored in memory and the test pcache
 # is in use, only 20 iterations. Otherwise the test pcache runs out
 # of page slots and SQLite reports "out of memory".
 #
-if {[info exists ISQUICK] || (
-  $TEMP_STORE==3 && [catch {set ::permutations_test_prefix} val]==0 && 
-  [regexp {^pcache[[:digit:]]*$} $val]
+if {[info exists G(isquick)] || (
+  $TEMP_STORE==3 && [regexp {^pcache[[:digit:]]*$} [permutation]]
 ) } {
   set limit 20
-} elseif {[info exists SOAKTEST]} {
+} elseif {[info exists G(issoak)]} {
   set limit 100
 } else {
   set limit 40
 }
 
 # Do rollbacks.  Make sure the signature does not change.
 #
 for {set i 2} {$i<=$limit} {incr i} {
   set ::sig [signature]
   set cnt [lindex $::sig 0]
@@ skipping 24 matching lines @@
        ROLLBACK;
      }
      signature
   } $sig
   if {$i<$limit} {
     do_test trans-9.$i.3-$cnt {
        execsql {
          INSERT INTO t3 SELECT randstr(10,400) FROM t3 WHERE random()%10==0;
        }
     } {}
+    catch flush_async_queue
     if {$tcl_platform(platform)=="unix"} {
       do_test trans-9.$i.4-$cnt {
          expr {$sqlite_sync_count>0}
       } 1
       ifcapable pager_pragmas {
         do_test trans-9.$i.5-$cnt {
            expr {$sqlite_fullsync_count>0}
         } [expr {$i%2==0}]
       } else {
         do_test trans-9.$i.5-$cnt {
           expr {$sqlite_fullsync_count==0}
         } {1}
       }
     }
   }
+
+  wal_check_journal_mode trans-9.$i.6-$cnt
   set ::pager_old_format 0
 }
    
 finish_test