src/third_party/sqlite/src/test/shared_err.test - cobalt - Git at Google

 # 2005 December 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.
 #
 #***********************************************************************
 #
 # The focus of the tests in this file are IO errors that occur in a shared
 # cache context. What happens to connection B if one connection A encounters
 # an IO-error whilst reading or writing the file-system?
 #
 # $Id: shared_err.test,v 1.24 2008/10/12 00:27:54 shane Exp $

 proc skip {args} {}


 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 source $testdir/malloc_common.tcl
 db close

 ifcapable !shared_cache||!subquery {
   finish_test
   return
 }

 set ::enable_shared_cache [sqlite3_enable_shared_cache 1]

 do_ioerr_test shared_ioerr-1 -tclprep {
   sqlite3 db2 test.db
   execsql {
     PRAGMA read_uncommitted = 1;
     CREATE TABLE t1(a,b,c);
     BEGIN;
     SELECT * FROM sqlite_master;
   } db2
 } -sqlbody {
   SELECT * FROM sqlite_master;
   INSERT INTO t1 VALUES(1,2,3);
   BEGIN TRANSACTION;
   INSERT INTO t1 VALUES(1,2,3);
   INSERT INTO t1 VALUES(4,5,6);
   ROLLBACK;
   SELECT * FROM t1;
   BEGIN TRANSACTION;
   INSERT INTO t1 VALUES(1,2,3);
   INSERT INTO t1 VALUES(4,5,6);
   COMMIT;
   SELECT * FROM t1;
   DELETE FROM t1 WHERE a<100;
 } -cleanup {
   do_test shared_ioerr-1.$n.cleanup.1 {
     set res [catchsql {
       SELECT * FROM t1;
     } db2]
     set possible_results [list               \
       "1 {disk I/O error}"                   \
       "0 {1 2 3}"                            \
       "0 {1 2 3 1 2 3 4 5 6}"                \
       "0 {1 2 3 1 2 3 4 5 6 1 2 3 4 5 6}"    \
       "0 {}"                                 \
       "1 {database disk image is malformed}" \
     ]
     set rc [expr [lsearch -exact $possible_results $res] >= 0]
     if {$rc != 1} {
       puts ""
       puts "Result: $res"
     }
     set rc
   } {1}

   # The "database disk image is malformed" is a special case that can
   # occur if an IO error occurs during a rollback in the {SELECT * FROM t1}
   # statement above. This test is to make sure there is no real database
   # corruption.
   db2 close
   do_test shared_ioerr-1.$n.cleanup.2 {
     execsql {pragma integrity_check} db
   } {ok}
 }

 do_ioerr_test shared_ioerr-2 -tclprep {
   sqlite3 db2 test.db
   execsql {
     PRAGMA read_uncommitted = 1;
     BEGIN;
     CREATE TABLE t1(a, b);
     INSERT INTO t1(oid) VALUES(NULL);
     INSERT INTO t1(oid) SELECT NULL FROM t1;
     INSERT INTO t1(oid) SELECT NULL FROM t1;
     INSERT INTO t1(oid) SELECT NULL FROM t1;
     INSERT INTO t1(oid) SELECT NULL FROM t1;
     INSERT INTO t1(oid) SELECT NULL FROM t1;
     INSERT INTO t1(oid) SELECT NULL FROM t1;
     INSERT INTO t1(oid) SELECT NULL FROM t1;
     INSERT INTO t1(oid) SELECT NULL FROM t1;
     INSERT INTO t1(oid) SELECT NULL FROM t1;
     INSERT INTO t1(oid) SELECT NULL FROM t1;
     UPDATE t1 set a = oid, b = 'abcdefghijklmnopqrstuvwxyz0123456789';
     CREATE INDEX i1 ON t1(a);
     COMMIT;
     BEGIN;
     SELECT * FROM sqlite_master;
   } db2
 } -tclbody {
   set ::residx 0
   execsql {DELETE FROM t1 WHERE 0 = (a % 2);}
   incr ::residx

   # When this transaction begins the table contains 512 entries. The
   # two statements together add 512+146 more if it succeeds.
   # (1024/7==146)
   execsql {BEGIN;}
   execsql {INSERT INTO t1 SELECT a+1, b FROM t1;}
   execsql {INSERT INTO t1 SELECT 'string' || a, b FROM t1 WHERE 0 = (a%7);}
   execsql {COMMIT;}

   incr ::residx
 } -cleanup {
   catchsql ROLLBACK
   do_test shared_ioerr-2.$n.cleanup.1 {
     set res [catchsql {
       SELECT max(a), min(a), count(*) FROM (SELECT a FROM t1 order by a);
     } db2]
     set possible_results [list \
       {0 {1024 1 1024}}        \
       {0 {1023 1 512}}         \
       {0 {string994 1 1170}}   \
     ]
     set idx [lsearch -exact $possible_results $res]
     set success [expr {$idx==$::residx || $res=="1 {disk I/O error}"}]
     if {!$success} {
       puts ""
       puts "Result: \"$res\" ($::residx)"
     }
     set success
   } {1}
   db2 close
 }

 # This test is designed to provoke an IO error when a cursor position is
 # "saved" (because another cursor is going to modify the underlying table).
 #
 do_ioerr_test shared_ioerr-3 -tclprep {
   sqlite3 db2 test.db
   execsql {
     PRAGMA read_uncommitted = 1;
     PRAGMA cache_size = 10;
     BEGIN;
     CREATE TABLE t1(a, b, UNIQUE(a, b));
   } db2
   for {set i 0} {$i < 200} {incr i} {
     set a [string range [string repeat "[format %03d $i]." 5] 0 end-1]

     set b [string repeat $i 2000]
     execsql {INSERT INTO t1 VALUES($a, $b)} db2
   }
   execsql {COMMIT} db2
   set ::DB2 [sqlite3_connection_pointer db2]
   set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
   sqlite3_step $::STMT       ;# Cursor points at 000.000.000.000
   sqlite3_step $::STMT       ;# Cursor points at 001.001.001.001

 } -tclbody {
   execsql {
     BEGIN;
     INSERT INTO t1 VALUES('201.201.201.201.201', NULL);
     UPDATE t1 SET a = '202.202.202.202.202' WHERE a LIKE '201%';
     COMMIT;
   }
 } -cleanup {
   set ::steprc  [sqlite3_step $::STMT]
   set ::column  [sqlite3_column_text $::STMT 0]
   set ::finalrc [sqlite3_finalize $::STMT]

   # There are three possible outcomes here (assuming persistent IO errors):
   #
   # 1. If the [sqlite3_step] did not require any IO (required pages in
   #    the cache), then the next row ("002...") may be retrieved
   #    successfully.
   #
   # 2. If the [sqlite3_step] does require IO, then [sqlite3_step] returns
   #    SQLITE_ERROR and [sqlite3_finalize] returns IOERR.
   #
   # 3. If, after the initial IO error, SQLite tried to rollback the
   #    active transaction and a second IO error was encountered, then
   #    statement $::STMT will have been aborted. This means [sqlite3_stmt]
   #    returns SQLITE_ABORT, and the statement cursor does not move. i.e.
   #    [sqlite3_column] still returns the current row ("001...") and
   #    [sqlite3_finalize] returns SQLITE_OK.
   #

   do_test shared_ioerr-3.$n.cleanup.1 {
     expr {
       $::steprc eq "SQLITE_ROW" ||
       $::steprc eq "SQLITE_ERROR" ||
       $::steprc eq "SQLITE_ABORT"
     }
   } {1}
   do_test shared_ioerr-3.$n.cleanup.2 {
     expr {
       ($::steprc eq "SQLITE_ROW" && $::column eq "002.002.002.002.002") ||
       ($::steprc eq "SQLITE_ERROR" && $::column eq "") ||
       ($::steprc eq "SQLITE_ABORT" && $::column eq "001.001.001.001.001")
     }
   } {1}
   do_test shared_ioerr-3.$n.cleanup.3 {
     expr {
       ($::steprc eq "SQLITE_ROW" && $::finalrc eq "SQLITE_OK") ||
       ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_IOERR") ||
       ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_ABORT")
     }
   } {1}

 # db2 eval {select * from sqlite_master}
   db2 close
 }

 # This is a repeat of the previous test except that this time we
 # are doing a reverse-order scan of the table when the cursor is
 # "saved".
 #
 do_ioerr_test shared_ioerr-3rev -tclprep {
   sqlite3 db2 test.db
   execsql {
     PRAGMA read_uncommitted = 1;
     PRAGMA cache_size = 10;
     BEGIN;
     CREATE TABLE t1(a, b, UNIQUE(a, b));
   } db2
   for {set i 0} {$i < 200} {incr i} {
     set a [string range [string repeat "[format %03d $i]." 5] 0 end-1]

     set b [string repeat $i 2000]
     execsql {INSERT INTO t1 VALUES($a, $b)} db2
   }
   execsql {COMMIT} db2
   set ::DB2 [sqlite3_connection_pointer db2]
   set ::STMT [sqlite3_prepare $::DB2 \
            "SELECT a FROM t1 ORDER BY a DESC" -1 DUMMY]
   sqlite3_step $::STMT       ;# Cursor points at 199.199.199.199.199
   sqlite3_step $::STMT       ;# Cursor points at 198.198.198.198.198

 } -tclbody {
   execsql {
     BEGIN;
     INSERT INTO t1 VALUES('201.201.201.201.201', NULL);
     UPDATE t1 SET a = '202.202.202.202.202' WHERE a LIKE '201%';
     COMMIT;
   }
 } -cleanup {
   set ::steprc  [sqlite3_step $::STMT]
   set ::column  [sqlite3_column_text $::STMT 0]
   set ::finalrc [sqlite3_finalize $::STMT]

   # There are three possible outcomes here (assuming persistent IO errors):
   #
   # 1. If the [sqlite3_step] did not require any IO (required pages in
   #    the cache), then the next row ("002...") may be retrieved
   #    successfully.
   #
   # 2. If the [sqlite3_step] does require IO, then [sqlite3_step] returns
   #    SQLITE_ERROR and [sqlite3_finalize] returns IOERR.
   #
   # 3. If, after the initial IO error, SQLite tried to rollback the
   #    active transaction and a second IO error was encountered, then
   #    statement $::STMT will have been aborted. This means [sqlite3_stmt]
   #    returns SQLITE_ABORT, and the statement cursor does not move. i.e.
   #    [sqlite3_column] still returns the current row ("001...") and
   #    [sqlite3_finalize] returns SQLITE_OK.
   #

   do_test shared_ioerr-3rev.$n.cleanup.1 {
     expr {
       $::steprc eq "SQLITE_ROW" ||
       $::steprc eq "SQLITE_ERROR" ||
       $::steprc eq "SQLITE_ABORT"
     }
   } {1}
   do_test shared_ioerr-3rev.$n.cleanup.2 {
     expr {
       ($::steprc eq "SQLITE_ROW" && $::column eq "197.197.197.197.197") ||
       ($::steprc eq "SQLITE_ERROR" && $::column eq "") ||
       ($::steprc eq "SQLITE_ABORT" && $::column eq "198.198.198.198.198")
     }
   } {1}
   do_test shared_ioerr-3rev.$n.cleanup.3 {
     expr {
       ($::steprc eq "SQLITE_ROW" && $::finalrc eq "SQLITE_OK") ||
       ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_IOERR") ||
       ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_ABORT")
     }
   } {1}

 # db2 eval {select * from sqlite_master}
   db2 close
 }

 # Provoke a malloc() failure when a cursor position is being saved. This
 # only happens with index cursors (because they malloc() space to save the
 # current key value). It does not happen with tables, because an integer
 # key does not require a malloc() to store.
 #
 # The library should return an SQLITE_NOMEM to the caller. The query that
 # owns the cursor (the one for which the position is not saved) should
 # continue unaffected.
 #
 do_malloc_test shared_err-4 -tclprep {
   sqlite3 db2 test.db
   execsql {
     PRAGMA read_uncommitted = 1;
     BEGIN;
     CREATE TABLE t1(a, b, UNIQUE(a, b));
   } db2
   for {set i 0} {$i < 5} {incr i} {
     set a [string repeat $i 10]
     set b [string repeat $i 2000]
     execsql {INSERT INTO t1 VALUES($a, $b)} db2
   }
   execsql {COMMIT} db2
   set ::DB2 [sqlite3_connection_pointer db2]
   set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
   sqlite3_step $::STMT       ;# Cursor points at 0000000000
   sqlite3_step $::STMT       ;# Cursor points at 1111111111
 } -tclbody {
   execsql {
     INSERT INTO t1 VALUES(6, NULL);
   }
 } -cleanup {
   do_test shared_malloc-4.$::n.cleanup.1 {
     set ::rc [sqlite3_step $::STMT]
     expr {$::rc=="SQLITE_ROW" || $::rc=="SQLITE_ERROR"}
   } {1}
   if {$::rc=="SQLITE_ROW"} {
     do_test shared_malloc-4.$::n.cleanup.2 {
       sqlite3_column_text $::STMT 0
     } {2222222222}
   }
   do_test shared_malloc-4.$::n.cleanup.3 {
    set rc [sqlite3_finalize $::STMT]
    expr {$rc=="SQLITE_OK" || $rc=="SQLITE_ABORT" ||
          $rc=="SQLITE_NOMEM" || $rc=="SQLITE_IOERR"}
   } {1}
 # db2 eval {select * from sqlite_master}
   db2 close
 }

 do_malloc_test shared_err-5 -tclbody {
   db close
   sqlite3 dbX test.db
   sqlite3 dbY test.db
   dbX close
   dbY close
 } -cleanup {
   catch {dbX close}
   catch {dbY close}
 }

 do_malloc_test shared_err-6 -tclbody {
   catch {db close}
   ifcapable deprecated {
     sqlite3_thread_cleanup
   }
   sqlite3_enable_shared_cache 0
 } -cleanup {
   sqlite3_enable_shared_cache 1
 }

 # As of 3.5.0, sqlite3_enable_shared_cache can be called at
 # any time and from any thread
 #do_test shared_err-misuse-7.1 {
 #  sqlite3 db test.db
 #  catch {
 #    sqlite3_enable_shared_cache 0
 #  } msg
 #  set msg
 #} {library routine called out of sequence}

 # Again provoke a malloc() failure when a cursor position is being saved,
 # this time during a ROLLBACK operation by some other handle.
 #
 # The library should return an SQLITE_NOMEM to the caller. The query that
 # owns the cursor (the one for which the position is not saved) should
 # be aborted.
 #
 set ::aborted 0
 do_malloc_test shared_err-8 -tclprep {
   sqlite3 db2 test.db
   execsql {
     PRAGMA read_uncommitted = 1;
     BEGIN;
     CREATE TABLE t1(a, b, UNIQUE(a, b));
   } db2
   for {set i 0} {$i < 2} {incr i} {
     set a [string repeat $i 10]
     set b [string repeat $i 2000]
     execsql {INSERT INTO t1 VALUES($a, $b)} db2
   }
   execsql {COMMIT} db2
   set ::DB2 [sqlite3_connection_pointer db2]
   set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
   sqlite3_step $::STMT       ;# Cursor points at 0000000000
   sqlite3_step $::STMT       ;# Cursor points at 1111111111
 } -tclbody {
   execsql {
     BEGIN;
     INSERT INTO t1 VALUES(6, NULL);
     ROLLBACK;
   }
 } -cleanup {
   # UPDATE: As of [5668], if the rollback fails SQLITE_CORRUPT is returned.
   # So these tests have been updated to expect SQLITE_CORRUPT and its
   # associated English language error message.
   #
   do_test shared_malloc-8.$::n.cleanup.1 {
     set res [catchsql {SELECT a FROM t1} db2]
     set ans [lindex $res 1]
     if {[lindex $res 0]} {
        set r [expr {
          $ans=="disk I/O error" ||
          $ans=="out of memory" ||
          $ans=="database disk image is malformed"
        }]
     } else {
        set r [expr {[lrange $ans 0 1]=="0000000000 1111111111"}]
     }
   } {1}
   do_test shared_malloc-8.$::n.cleanup.2 {
     set rc1 [sqlite3_step $::STMT]
     set rc2 [sqlite3_finalize $::STMT]
     if {$rc2=="SQLITE_ABORT"} {
       incr ::aborted
     }
     expr {
       ($rc1=="SQLITE_DONE" && $rc2=="SQLITE_OK") ||
       ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_ABORT") ||
       ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_NOMEM") ||
       ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_IOERR") ||
       ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_CORRUPT")
     }
   } {1}
   db2 close
 }
 do_test shared_malloc-8.X {
   # Test that one or more queries were aborted due to the malloc() failure.
   expr $::aborted>=1
 } {1}

 # This test is designed to catch a specific bug that was present during
 # development of 3.5.0. If a malloc() failed while setting the page-size,
 # a buffer (Pager.pTmpSpace) was being freed. This could cause a seg-fault
 # later if another connection tried to use the pager.
 #
 # This test will crash 3.4.2.
 #
 do_malloc_test shared_err-9 -tclprep {
   sqlite3 db2 test.db
 } -sqlbody {
   PRAGMA page_size = 4096;
   PRAGMA page_size = 1024;
 } -cleanup {
   db2 eval {
     CREATE TABLE abc(a, b, c);
     BEGIN;
     INSERT INTO abc VALUES(1, 2, 3);
     ROLLBACK;
   }
   db2 close
 }

 catch {db close}
 catch {db2 close}
 do_malloc_test shared_err-10 -tclprep {
   sqlite3 db test.db
   sqlite3 db2 test.db

   db eval { SELECT * FROM sqlite_master }
   db2 eval {
     BEGIN;
     CREATE TABLE abc(a, b, c);
   }
 } -tclbody {
   catch {db eval {SELECT * FROM sqlite_master}}
   error 1
 } -cleanup {
   execsql { SELECT * FROM sqlite_master }
 }

 do_malloc_test shared_err-11 -tclprep {
   sqlite3 db test.db
   sqlite3 db2 test.db

   db eval { SELECT * FROM sqlite_master }
   db2 eval {
     BEGIN;
     CREATE TABLE abc(a, b, c);
   }
 } -tclbody {
   catch {db eval {SELECT * FROM sqlite_master}}
   catch {sqlite3_errmsg16 db}
   error 1
 } -cleanup {
   execsql { SELECT * FROM sqlite_master }
 }

 catch {db close}
 catch {db2 close}

 do_malloc_test shared_err-12 -sqlbody {
   CREATE TABLE abc(a, b, c);
   INSERT INTO abc VALUES(1, 2, 3);
 }

 catch {db close}
 catch {db2 close}
 sqlite3_enable_shared_cache $::enable_shared_cache
 finish_test
	# 2005 December 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.
	#
	#***********************************************************************
	#
	# The focus of the tests in this file are IO errors that occur in a shared
	# cache context. What happens to connection B if one connection A encounters
	# an IO-error whilst reading or writing the file-system?
	#
	# $Id: shared_err.test,v 1.24 2008/10/12 00:27:54 shane Exp $

	proc skip {args} {}


	set testdir [file dirname $argv0]
	source $testdir/tester.tcl
	source $testdir/malloc_common.tcl
	db close

	ifcapable !shared_cache\|\|!subquery {
	finish_test
	return
	}

	set ::enable_shared_cache [sqlite3_enable_shared_cache 1]

	do_ioerr_test shared_ioerr-1 -tclprep {
	sqlite3 db2 test.db
	execsql {
	PRAGMA read_uncommitted = 1;
	CREATE TABLE t1(a,b,c);
	BEGIN;
	SELECT * FROM sqlite_master;
	} db2
	} -sqlbody {
	SELECT * FROM sqlite_master;
	INSERT INTO t1 VALUES(1,2,3);
	BEGIN TRANSACTION;
	INSERT INTO t1 VALUES(1,2,3);
	INSERT INTO t1 VALUES(4,5,6);
	ROLLBACK;
	SELECT * FROM t1;
	BEGIN TRANSACTION;
	INSERT INTO t1 VALUES(1,2,3);
	INSERT INTO t1 VALUES(4,5,6);
	COMMIT;
	SELECT * FROM t1;
	DELETE FROM t1 WHERE a<100;
	} -cleanup {
	do_test shared_ioerr-1.$n.cleanup.1 {
	set res [catchsql {
	SELECT * FROM t1;
	} db2]
	set possible_results [list \
	"1 {disk I/O error}" \
	"0 {1 2 3}" \
	"0 {1 2 3 1 2 3 4 5 6}" \
	"0 {1 2 3 1 2 3 4 5 6 1 2 3 4 5 6}" \
	"0 {}" \
	"1 {database disk image is malformed}" \
	]
	set rc [expr [lsearch -exact $possible_results $res] >= 0]
	if {$rc != 1} {
	puts ""
	puts "Result: $res"
	}
	set rc
	} {1}

	# The "database disk image is malformed" is a special case that can
	# occur if an IO error occurs during a rollback in the {SELECT * FROM t1}
	# statement above. This test is to make sure there is no real database
	# corruption.
	db2 close
	do_test shared_ioerr-1.$n.cleanup.2 {
	execsql {pragma integrity_check} db
	} {ok}
	}

	do_ioerr_test shared_ioerr-2 -tclprep {
	sqlite3 db2 test.db
	execsql {
	PRAGMA read_uncommitted = 1;
	BEGIN;
	CREATE TABLE t1(a, b);
	INSERT INTO t1(oid) VALUES(NULL);
	INSERT INTO t1(oid) SELECT NULL FROM t1;
	INSERT INTO t1(oid) SELECT NULL FROM t1;
	INSERT INTO t1(oid) SELECT NULL FROM t1;
	INSERT INTO t1(oid) SELECT NULL FROM t1;
	INSERT INTO t1(oid) SELECT NULL FROM t1;
	INSERT INTO t1(oid) SELECT NULL FROM t1;
	INSERT INTO t1(oid) SELECT NULL FROM t1;
	INSERT INTO t1(oid) SELECT NULL FROM t1;
	INSERT INTO t1(oid) SELECT NULL FROM t1;
	INSERT INTO t1(oid) SELECT NULL FROM t1;
	UPDATE t1 set a = oid, b = 'abcdefghijklmnopqrstuvwxyz0123456789';
	CREATE INDEX i1 ON t1(a);
	COMMIT;
	BEGIN;
	SELECT * FROM sqlite_master;
	} db2
	} -tclbody {
	set ::residx 0
	execsql {DELETE FROM t1 WHERE 0 = (a % 2);}
	incr ::residx

	# When this transaction begins the table contains 512 entries. The
	# two statements together add 512+146 more if it succeeds.
	# (1024/7==146)
	execsql {BEGIN;}
	execsql {INSERT INTO t1 SELECT a+1, b FROM t1;}
	execsql {INSERT INTO t1 SELECT 'string' \|\| a, b FROM t1 WHERE 0 = (a%7);}
	execsql {COMMIT;}

	incr ::residx
	} -cleanup {
	catchsql ROLLBACK
	do_test shared_ioerr-2.$n.cleanup.1 {
	set res [catchsql {
	SELECT max(a), min(a), count(*) FROM (SELECT a FROM t1 order by a);
	} db2]
	set possible_results [list \
	{0 {1024 1 1024}} \
	{0 {1023 1 512}} \
	{0 {string994 1 1170}} \
	]
	set idx [lsearch -exact $possible_results $res]
	set success [expr {$idx==$::residx \|\| $res=="1 {disk I/O error}"}]
	if {!$success} {
	puts ""
	puts "Result: \"$res\" ($::residx)"
	}
	set success
	} {1}
	db2 close
	}

	# This test is designed to provoke an IO error when a cursor position is
	# "saved" (because another cursor is going to modify the underlying table).
	#
	do_ioerr_test shared_ioerr-3 -tclprep {
	sqlite3 db2 test.db
	execsql {
	PRAGMA read_uncommitted = 1;
	PRAGMA cache_size = 10;
	BEGIN;
	CREATE TABLE t1(a, b, UNIQUE(a, b));
	} db2
	for {set i 0} {$i < 200} {incr i} {
	set a [string range [string repeat "[format %03d $i]." 5] 0 end-1]

	set b [string repeat $i 2000]
	execsql {INSERT INTO t1 VALUES($a, $b)} db2
	}
	execsql {COMMIT} db2
	set ::DB2 [sqlite3_connection_pointer db2]
	set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
	sqlite3_step $::STMT ;# Cursor points at 000.000.000.000
	sqlite3_step $::STMT ;# Cursor points at 001.001.001.001

	} -tclbody {
	execsql {
	BEGIN;
	INSERT INTO t1 VALUES('201.201.201.201.201', NULL);
	UPDATE t1 SET a = '202.202.202.202.202' WHERE a LIKE '201%';
	COMMIT;
	}
	} -cleanup {
	set ::steprc [sqlite3_step $::STMT]
	set ::column [sqlite3_column_text $::STMT 0]
	set ::finalrc [sqlite3_finalize $::STMT]

	# There are three possible outcomes here (assuming persistent IO errors):
	#
	# 1. If the [sqlite3_step] did not require any IO (required pages in
	# the cache), then the next row ("002...") may be retrieved
	# successfully.
	#
	# 2. If the [sqlite3_step] does require IO, then [sqlite3_step] returns
	# SQLITE_ERROR and [sqlite3_finalize] returns IOERR.
	#
	# 3. If, after the initial IO error, SQLite tried to rollback the
	# active transaction and a second IO error was encountered, then
	# statement $::STMT will have been aborted. This means [sqlite3_stmt]
	# returns SQLITE_ABORT, and the statement cursor does not move. i.e.
	# [sqlite3_column] still returns the current row ("001...") and
	# [sqlite3_finalize] returns SQLITE_OK.
	#

	do_test shared_ioerr-3.$n.cleanup.1 {
	expr {
	$::steprc eq "SQLITE_ROW" \|\|
	$::steprc eq "SQLITE_ERROR" \|\|
	$::steprc eq "SQLITE_ABORT"
	}
	} {1}
	do_test shared_ioerr-3.$n.cleanup.2 {
	expr {
	($::steprc eq "SQLITE_ROW" && $::column eq "002.002.002.002.002") \|\|
	($::steprc eq "SQLITE_ERROR" && $::column eq "") \|\|
	($::steprc eq "SQLITE_ABORT" && $::column eq "001.001.001.001.001")
	}
	} {1}
	do_test shared_ioerr-3.$n.cleanup.3 {
	expr {
	($::steprc eq "SQLITE_ROW" && $::finalrc eq "SQLITE_OK") \|\|
	($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_IOERR") \|\|
	($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_ABORT")
	}
	} {1}

	# db2 eval {select * from sqlite_master}
	db2 close
	}

	# This is a repeat of the previous test except that this time we
	# are doing a reverse-order scan of the table when the cursor is
	# "saved".
	#
	do_ioerr_test shared_ioerr-3rev -tclprep {
	sqlite3 db2 test.db
	execsql {
	PRAGMA read_uncommitted = 1;
	PRAGMA cache_size = 10;
	BEGIN;
	CREATE TABLE t1(a, b, UNIQUE(a, b));
	} db2
	for {set i 0} {$i < 200} {incr i} {
	set a [string range [string repeat "[format %03d $i]." 5] 0 end-1]

	set b [string repeat $i 2000]
	execsql {INSERT INTO t1 VALUES($a, $b)} db2
	}
	execsql {COMMIT} db2
	set ::DB2 [sqlite3_connection_pointer db2]
	set ::STMT [sqlite3_prepare $::DB2 \
	"SELECT a FROM t1 ORDER BY a DESC" -1 DUMMY]
	sqlite3_step $::STMT ;# Cursor points at 199.199.199.199.199
	sqlite3_step $::STMT ;# Cursor points at 198.198.198.198.198

	} -tclbody {
	execsql {
	BEGIN;
	INSERT INTO t1 VALUES('201.201.201.201.201', NULL);
	UPDATE t1 SET a = '202.202.202.202.202' WHERE a LIKE '201%';
	COMMIT;
	}
	} -cleanup {
	set ::steprc [sqlite3_step $::STMT]
	set ::column [sqlite3_column_text $::STMT 0]
	set ::finalrc [sqlite3_finalize $::STMT]

	# There are three possible outcomes here (assuming persistent IO errors):
	#
	# 1. If the [sqlite3_step] did not require any IO (required pages in
	# the cache), then the next row ("002...") may be retrieved
	# successfully.
	#
	# 2. If the [sqlite3_step] does require IO, then [sqlite3_step] returns
	# SQLITE_ERROR and [sqlite3_finalize] returns IOERR.
	#
	# 3. If, after the initial IO error, SQLite tried to rollback the
	# active transaction and a second IO error was encountered, then
	# statement $::STMT will have been aborted. This means [sqlite3_stmt]
	# returns SQLITE_ABORT, and the statement cursor does not move. i.e.
	# [sqlite3_column] still returns the current row ("001...") and
	# [sqlite3_finalize] returns SQLITE_OK.
	#

	do_test shared_ioerr-3rev.$n.cleanup.1 {
	expr {
	$::steprc eq "SQLITE_ROW" \|\|
	$::steprc eq "SQLITE_ERROR" \|\|
	$::steprc eq "SQLITE_ABORT"
	}
	} {1}
	do_test shared_ioerr-3rev.$n.cleanup.2 {
	expr {
	($::steprc eq "SQLITE_ROW" && $::column eq "197.197.197.197.197") \|\|
	($::steprc eq "SQLITE_ERROR" && $::column eq "") \|\|
	($::steprc eq "SQLITE_ABORT" && $::column eq "198.198.198.198.198")
	}
	} {1}
	do_test shared_ioerr-3rev.$n.cleanup.3 {
	expr {
	($::steprc eq "SQLITE_ROW" && $::finalrc eq "SQLITE_OK") \|\|
	($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_IOERR") \|\|
	($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_ABORT")
	}
	} {1}

	# db2 eval {select * from sqlite_master}
	db2 close
	}

	# Provoke a malloc() failure when a cursor position is being saved. This
	# only happens with index cursors (because they malloc() space to save the
	# current key value). It does not happen with tables, because an integer
	# key does not require a malloc() to store.
	#
	# The library should return an SQLITE_NOMEM to the caller. The query that
	# owns the cursor (the one for which the position is not saved) should
	# continue unaffected.
	#
	do_malloc_test shared_err-4 -tclprep {
	sqlite3 db2 test.db
	execsql {
	PRAGMA read_uncommitted = 1;
	BEGIN;
	CREATE TABLE t1(a, b, UNIQUE(a, b));
	} db2
	for {set i 0} {$i < 5} {incr i} {
	set a [string repeat $i 10]
	set b [string repeat $i 2000]
	execsql {INSERT INTO t1 VALUES($a, $b)} db2
	}
	execsql {COMMIT} db2
	set ::DB2 [sqlite3_connection_pointer db2]
	set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
	sqlite3_step $::STMT ;# Cursor points at 0000000000
	sqlite3_step $::STMT ;# Cursor points at 1111111111
	} -tclbody {
	execsql {
	INSERT INTO t1 VALUES(6, NULL);
	}
	} -cleanup {
	do_test shared_malloc-4.$::n.cleanup.1 {
	set ::rc [sqlite3_step $::STMT]
	expr {$::rc=="SQLITE_ROW" \|\| $::rc=="SQLITE_ERROR"}
	} {1}
	if {$::rc=="SQLITE_ROW"} {
	do_test shared_malloc-4.$::n.cleanup.2 {
	sqlite3_column_text $::STMT 0
	} {2222222222}
	}
	do_test shared_malloc-4.$::n.cleanup.3 {
	set rc [sqlite3_finalize $::STMT]
	expr {$rc=="SQLITE_OK" \|\| $rc=="SQLITE_ABORT" \|\|
	$rc=="SQLITE_NOMEM" \|\| $rc=="SQLITE_IOERR"}
	} {1}
	# db2 eval {select * from sqlite_master}
	db2 close
	}

	do_malloc_test shared_err-5 -tclbody {
	db close
	sqlite3 dbX test.db
	sqlite3 dbY test.db
	dbX close
	dbY close
	} -cleanup {
	catch {dbX close}
	catch {dbY close}
	}

	do_malloc_test shared_err-6 -tclbody {
	catch {db close}
	ifcapable deprecated {
	sqlite3_thread_cleanup
	}
	sqlite3_enable_shared_cache 0
	} -cleanup {
	sqlite3_enable_shared_cache 1
	}

	# As of 3.5.0, sqlite3_enable_shared_cache can be called at
	# any time and from any thread
	#do_test shared_err-misuse-7.1 {
	# sqlite3 db test.db
	# catch {
	# sqlite3_enable_shared_cache 0
	# } msg
	# set msg
	#} {library routine called out of sequence}

	# Again provoke a malloc() failure when a cursor position is being saved,
	# this time during a ROLLBACK operation by some other handle.
	#
	# The library should return an SQLITE_NOMEM to the caller. The query that
	# owns the cursor (the one for which the position is not saved) should
	# be aborted.
	#
	set ::aborted 0
	do_malloc_test shared_err-8 -tclprep {
	sqlite3 db2 test.db
	execsql {
	PRAGMA read_uncommitted = 1;
	BEGIN;
	CREATE TABLE t1(a, b, UNIQUE(a, b));
	} db2
	for {set i 0} {$i < 2} {incr i} {
	set a [string repeat $i 10]
	set b [string repeat $i 2000]
	execsql {INSERT INTO t1 VALUES($a, $b)} db2
	}
	execsql {COMMIT} db2
	set ::DB2 [sqlite3_connection_pointer db2]
	set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
	sqlite3_step $::STMT ;# Cursor points at 0000000000
	sqlite3_step $::STMT ;# Cursor points at 1111111111
	} -tclbody {
	execsql {
	BEGIN;
	INSERT INTO t1 VALUES(6, NULL);
	ROLLBACK;
	}
	} -cleanup {
	# UPDATE: As of [5668], if the rollback fails SQLITE_CORRUPT is returned.
	# So these tests have been updated to expect SQLITE_CORRUPT and its
	# associated English language error message.
	#
	do_test shared_malloc-8.$::n.cleanup.1 {
	set res [catchsql {SELECT a FROM t1} db2]
	set ans [lindex $res 1]
	if {[lindex $res 0]} {
	set r [expr {
	$ans=="disk I/O error" \|\|
	$ans=="out of memory" \|\|
	$ans=="database disk image is malformed"
	}]
	} else {
	set r [expr {[lrange $ans 0 1]=="0000000000 1111111111"}]
	}
	} {1}
	do_test shared_malloc-8.$::n.cleanup.2 {
	set rc1 [sqlite3_step $::STMT]
	set rc2 [sqlite3_finalize $::STMT]
	if {$rc2=="SQLITE_ABORT"} {
	incr ::aborted
	}
	expr {
	($rc1=="SQLITE_DONE" && $rc2=="SQLITE_OK") \|\|
	($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_ABORT") \|\|
	($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_NOMEM") \|\|
	($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_IOERR") \|\|
	($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_CORRUPT")
	}
	} {1}
	db2 close
	}
	do_test shared_malloc-8.X {
	# Test that one or more queries were aborted due to the malloc() failure.
	expr $::aborted>=1
	} {1}

	# This test is designed to catch a specific bug that was present during
	# development of 3.5.0. If a malloc() failed while setting the page-size,
	# a buffer (Pager.pTmpSpace) was being freed. This could cause a seg-fault
	# later if another connection tried to use the pager.
	#
	# This test will crash 3.4.2.
	#
	do_malloc_test shared_err-9 -tclprep {
	sqlite3 db2 test.db
	} -sqlbody {
	PRAGMA page_size = 4096;
	PRAGMA page_size = 1024;
	} -cleanup {
	db2 eval {
	CREATE TABLE abc(a, b, c);
	BEGIN;
	INSERT INTO abc VALUES(1, 2, 3);
	ROLLBACK;
	}
	db2 close
	}

	catch {db close}
	catch {db2 close}
	do_malloc_test shared_err-10 -tclprep {
	sqlite3 db test.db
	sqlite3 db2 test.db

	db eval { SELECT * FROM sqlite_master }
	db2 eval {
	BEGIN;
	CREATE TABLE abc(a, b, c);
	}
	} -tclbody {
	catch {db eval {SELECT * FROM sqlite_master}}
	error 1
	} -cleanup {
	execsql { SELECT * FROM sqlite_master }
	}

	do_malloc_test shared_err-11 -tclprep {
	sqlite3 db test.db
	sqlite3 db2 test.db

	db eval { SELECT * FROM sqlite_master }
	db2 eval {
	BEGIN;
	CREATE TABLE abc(a, b, c);
	}
	} -tclbody {
	catch {db eval {SELECT * FROM sqlite_master}}
	catch {sqlite3_errmsg16 db}
	error 1
	} -cleanup {
	execsql { SELECT * FROM sqlite_master }
	}

	catch {db close}
	catch {db2 close}

	do_malloc_test shared_err-12 -sqlbody {
	CREATE TABLE abc(a, b, c);
	INSERT INTO abc VALUES(1, 2, 3);
	}

	catch {db close}
	catch {db2 close}
	sqlite3_enable_shared_cache $::enable_shared_cache
	finish_test