Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(212)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/sqlite/sqlite-src-3080704/test/shared_err.test

Issue 2363173002: [sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
Patch Set: Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/sqlite/sqlite-src-3080704/test/sharedB.test ('k') | third_party/sqlite/sqlite-src-3080704/test/sharedlock.test » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/sqlite/sqlite-src-3080704/test/shared_err.test
diff --git a/third_party/sqlite/sqlite-src-3080704/test/shared_err.test b/third_party/sqlite/sqlite-src-3080704/test/shared_err.test
deleted file mode 100644
index 96e5ee454090a0ad372ebf104287c9e355d3829a..0000000000000000000000000000000000000000
--- a/third_party/sqlite/sqlite-src-3080704/test/shared_err.test
+++ /dev/null
@@ -1,528 +0,0 @@
-# 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
- execsql BEGIN
- execsql ROLLBACK
- 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
-}
-
-# When this test case was written, OOM errors in write statements would
-# cause transaction rollback, which would trip cursors in other statements,
-# aborting them. This no longer happens.
-#
-do_test shared_malloc-8.X {
- # Test that one or more queries were aborted due to the malloc() failure.
- # expr $::aborted>=1
- expr $::aborted==0
-} {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
« no previous file with comments | « third_party/sqlite/sqlite-src-3080704/test/sharedB.test ('k') | third_party/sqlite/sqlite-src-3080704/test/sharedlock.test » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698