# 2007 August 23

 #

 # 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 contains tests that verify that SQLite can correctly rollback

 # databases after crashes when using the special IO modes triggered 

 # by device IOCAP flags.

 #

 # $Id: crash3.test,v 1.4 2008/07/12 14:52:20 drh Exp $

 set testdir [file dirname $argv0]

 source $testdir/tester.tcl

 ifcapable !crashtest {

   finish_test

   return

 }

 proc do_test2 {name tcl res1 res2} {

   set script [subst -nocommands {

     do_test $name {

       set res1 {$res1}

       set res2 {$res2}

       set res [eval {$tcl}]

       if {[set res] eq [set res1] || [set res] eq [set res2]} {

         set res "{[set res1]} or {[set res2]}"

       }

       set res

     } {{$res1} or {$res2}}

   }]

   uplevel $script

 }

 # This block tests crash-recovery when the IOCAP_ATOMIC flags is set.

 #

 # Each iteration of the following loop sets up the database to contain

 # the following schema and data:

 #

 #    CREATE TABLE abc(a, b, c);

 #    INSERT INTO abc VALUES(1, 2, 3);

 #

 # Then execute the SQL statement, scheduling a crash for part-way through

 # the first sync() of either the database file or the journal file (often

 # the journal file is not required - meaning no crash occurs).

 #

 # After the crash (or absence of a crash), open the database and 

 # verify that:

 #

 #   * The integrity check passes, and

 #   * The contents of table abc is either {1 2 3} or the value specified

 #     to the right of the SQL statement below.

 #

 # The procedure is repeated 10 times for each SQL statement. Five times

 # with the crash scheduled for midway through the first journal sync (if 

 # any), and five times with the crash midway through the database sync.

 #

 set tn 1

 foreach {sql res2} [list \

   {INSERT INTO abc VALUES(4, 5, 6)}                    {1 2 3 4 5 6} \

   {DELETE FROM abc}                                    {}    \

   {INSERT INTO abc SELECT * FROM abc}                  {1 2 3 1 2 3} \

   {UPDATE abc SET a = 2}                               {2 2 3}       \

   {INSERT INTO abc VALUES(4, 5, randstr(1000,1000))}   {n/a} \

   {CREATE TABLE def(d, e, f)}                          {n/a} \

 ] {

   for {set ii 0} {$ii < 10} {incr ii} {

     db close

     file delete -force test.db test.db-journal

     sqlite3 db test.db

     do_test crash3-1.$tn.1 {

       execsql {

         PRAGMA page_size = 1024;

         BEGIN;

         CREATE TABLE abc(a, b, c);

         INSERT INTO abc VALUES(1, 2, 3);

         COMMIT;

       }

     } {}

     db close

     set crashfile test.db

     if {($ii%2)==0} { append crashfile -journal }

     set rand "SELECT randstr($tn,$tn);"

     do_test crash3-1.$tn.2 [subst {

       crashsql -file $crashfile -char atomic {$rand $sql}

       sqlite3 db test.db

       execsql { PRAGMA integrity_check; }

     }] {ok}

     do_test2 crash3-1.$tn.3 {

       execsql { SELECT * FROM abc }

     } {1 2 3} $res2

     incr tn

   }

 }

 # This block tests both the IOCAP_SEQUENTIAL and IOCAP_SAFE_APPEND flags.

 #

 db close

 file delete -force test.db test.db-journal

 sqlite3 db test.db

 do_test crash3-2.0 {

   execsql {

     BEGIN;

     CREATE TABLE abc(a PRIMARY KEY, b, c);

     CREATE TABLE def(d PRIMARY KEY, e, f);

     PRAGMA default_cache_size = 10;

     INSERT INTO abc VALUES(randstr(10,1000),randstr(10,1000),randstr(10,1000));

     INSERT INTO abc 

       SELECT randstr(10,1000),randstr(10,1000),randstr(10,1000) FROM abc;

     INSERT INTO abc 

       SELECT randstr(10,1000),randstr(10,1000),randstr(10,1000) FROM abc;

     INSERT INTO abc 

       SELECT randstr(10,1000),randstr(10,1000),randstr(10,1000) FROM abc;

     INSERT INTO abc 

       SELECT randstr(10,1000),randstr(10,1000),randstr(10,1000) FROM abc;

     INSERT INTO abc 

       SELECT randstr(10,1000),randstr(10,1000),randstr(10,1000) FROM abc;

     INSERT INTO abc 

       SELECT randstr(10,1000),randstr(10,1000),randstr(10,1000) FROM abc;

     COMMIT;

   }

 } {}

 set tn 1

 foreach {::crashfile ::delay ::char} {

   test.db         1 sequential

   test.db         1 safe_append

   test.db-journal 1 sequential

   test.db-journal 1 safe_append

   test.db-journal 2 safe_append

   test.db-journal 2 sequential

   test.db-journal 3 sequential

   test.db-journal 3 safe_append

 } {

   for {set ii 0} {$ii < 100} {incr ii} {

     set ::SQL [subst {

       SELECT randstr($ii,$ii+10);

       BEGIN;

       DELETE FROM abc WHERE random()%5;

       INSERT INTO abc 

         SELECT randstr(10,1000),randstr(10,1000),randstr(10,1000) 

         FROM abc

         WHERE (random()%5)==0;

       DELETE FROM def WHERE random()%5;

       INSERT INTO def 

         SELECT randstr(10,1000),randstr(10,1000),randstr(10,1000) 

         FROM def

         WHERE (random()%5)==0;

       COMMIT;

     }]

     do_test crash3-2.$tn.$ii {

       crashsql -file $::crashfile -delay $::delay -char $::char $::SQL

       db close

       sqlite3 db test.db

       execsql {PRAGMA integrity_check}

     } {ok}

   }

   incr tn

 }

 # The following block tests an interaction between IOCAP_ATOMIC and

 # IOCAP_SEQUENTIAL. At one point, if both flags were set, small

 # journal files that contained only a single page, but were required 

 # for some other reason (i.e. nTrunk) were not being written to

 # disk.

 #

 for {set ii 0} {$ii < 10} {incr ii} {

   db close

   file delete -force test.db test.db-journal

   crashsql -file test.db -char {sequential atomic} {

     CREATE TABLE abc(a, b, c);

   }

   sqlite3 db test.db

   do_test crash3-3.$ii {

     execsql {PRAGMA integrity_check}

   } {ok}

 }

 finish_test