Move bundled copy of sqlite one level deeper to better separate it...

third_party/sqlite/test/corrupt.test

-# 2004 August 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.
-#
-#***********************************************************************
-# This file implements regression tests for SQLite library.
-#
-# This file implements tests to make sure SQLite does not crash or
-# segfault if it sees a corrupt database file.
-#
-# $Id: corrupt.test,v 1.12 2009/07/13 09:41:45 danielk1977 Exp $
-
-catch {file delete -force test.db test.db-journal test.bu}
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-
-# Construct a large database for testing.
-#
-do_test corrupt-1.1 {
-  execsql {
-    BEGIN;
-    CREATE TABLE t1(x);
-    INSERT INTO t1 VALUES(randstr(100,100));
-    INSERT INTO t1 VALUES(randstr(90,90));
-    INSERT INTO t1 VALUES(randstr(80,80));
-    INSERT INTO t1 SELECT x || randstr(5,5) FROM t1;
-    INSERT INTO t1 SELECT x || randstr(6,6) FROM t1;
-    INSERT INTO t1 SELECT x || randstr(7,7) FROM t1;
-    INSERT INTO t1 SELECT x || randstr(8,8) FROM t1;
-    INSERT INTO t1 VALUES(randstr(3000,3000));
-    INSERT INTO t1 SELECT x || randstr(9,9) FROM t1;
-    INSERT INTO t1 SELECT x || randstr(10,10) FROM t1;
-    INSERT INTO t1 SELECT x || randstr(11,11) FROM t1;
-    INSERT INTO t1 SELECT x || randstr(12,12) FROM t1;
-    CREATE INDEX t1i1 ON t1(x);
-    CREATE TABLE t2 AS SELECT * FROM t1;
-    DELETE FROM t2 WHERE rowid%5!=0;
-    COMMIT;
-  }
-} {}
-integrity_check corrupt-1.2
-
-# Copy file $from into $to
-#
-proc copy_file {from to} {
-  set f [open $from]
-  fconfigure $f -translation binary
-  set t [open $to w]
-  fconfigure $t -translation binary
-  puts -nonewline $t [read $f [file size $from]]
-  close $t
-  close $f
-}
-
-# Setup for the tests.  Make a backup copy of the good database in test.bu.
-# Create a string of garbage data that is 256 bytes long.
-#
-copy_file test.db test.bu
-set fsize [file size test.db]
-set junk "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-while {[string length $junk]<256} {append junk $junk}
-set junk [string range $junk 0 255]
-
-# Go through the database and write garbage data into each 256 segment
-# of the file.  Then do various operations on the file to make sure that
-# the database engine can recover gracefully from the corruption.
-#
-for {set i [expr {1*256}]} {$i<$fsize-256} {incr i 256} {
-  set tn [expr {$i/256}]
-  db close
-  copy_file test.bu test.db
-  set fd [open test.db r+]
-  fconfigure $fd -translation binary
-  seek $fd $i
-  puts -nonewline $fd $junk
-  close $fd
-  do_test corrupt-2.$tn.1 {
-    sqlite3 db test.db
-    catchsql {SELECT count(*) FROM sqlite_master}
-    set x {}
-  } {}
-  do_test corrupt-2.$tn.2 {
-    catchsql {SELECT count(*) FROM t1}
-    set x {}
-  } {}
-  do_test corrupt-2.$tn.3 {
-    catchsql {SELECT count(*) FROM t1 WHERE x>'abcdef'}
-    set x {}
-  } {}
-  do_test corrupt-2.$tn.4 {
-    catchsql {SELECT count(*) FROM t2}
-    set x {}
-  } {}
-  do_test corrupt-2.$tn.5 {
-    catchsql {CREATE TABLE t3 AS SELECT * FROM t1}
-    set x {}
-  } {}
-  do_test corrupt-2.$tn.6 {
-    catchsql {DROP TABLE t1}
-    set x {}
-  } {}
-  do_test corrupt-2.$tn.7 {
-    catchsql {PRAGMA integrity_check}
-    set x {}
-  } {}
-
-  # Check that no page references were leaked.
-  do_test corrupt-2.$tn.8 {
-    set bt [btree_from_db db]
-    db_enter db
-    array set stats [btree_pager_stats $bt]
-    db_leave db
-    set stats(ref)
-  } {0}
-}  
-
-#------------------------------------------------------------------------
-# For these tests, swap the rootpage entries of t1 (a table) and t1i1 (an
-# index on t1) in sqlite_master. Then perform a few different queries
-# and make sure this is detected as corruption.
-#
-do_test corrupt-3.1 {
-  db close
-  copy_file test.bu test.db
-  sqlite3 db test.db
-  list
-} {}
-do_test corrupt-3.2 {
-  set t1_r [execsql {SELECT rootpage FROM sqlite_master WHERE name = 't1i1'}]
-  set t1i1_r [execsql {SELECT rootpage FROM sqlite_master WHERE name = 't1'}]
-  set cookie [expr [execsql {PRAGMA schema_version}] + 1]
-  execsql "
-    PRAGMA writable_schema = 1;
-    UPDATE sqlite_master SET rootpage = $t1_r WHERE name = 't1';
-    UPDATE sqlite_master SET rootpage = $t1i1_r WHERE name = 't1i1';
-    PRAGMA writable_schema = 0;
-    PRAGMA schema_version = $cookie;
-  "
-} {}
-
-# This one tests the case caught by code in checkin [2313].
-do_test corrupt-3.3 {
-  db close
-  sqlite3 db test.db
-  catchsql {
-    INSERT INTO t1 VALUES('abc');
-  }
-} {1 {database disk image is malformed}}
-do_test corrupt-3.4 {
-  db close
-  sqlite3 db test.db
-  catchsql {
-    SELECT * FROM t1;
-  }
-} {1 {database disk image is malformed}}
-do_test corrupt-3.5 {
-  db close
-  sqlite3 db test.db
-  catchsql {
-    SELECT * FROM t1 WHERE oid = 10;
-  }
-} {1 {database disk image is malformed}}
-do_test corrupt-3.6 {
-  db close
-  sqlite3 db test.db
-  catchsql {
-    SELECT * FROM t1 WHERE x = 'abcde';
-  }
-} {1 {database disk image is malformed}}
-
-do_test corrupt-4.1 {
-  db close
-  file delete -force test.db test.db-journal
-  sqlite3 db test.db
-  execsql {
-    PRAGMA page_size = 1024;
-    CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT);
-  }
-  for {set i 0} {$i < 10} {incr i} {
-    set text [string repeat $i 220]
-    execsql { INSERT INTO t1 VALUES($i, $text) }
-  }
-  execsql { CREATE INDEX i1 ON t1(b) }
-} {}
-do_test corrupt-4.2 {
-  set iRoot [db one {SELECT rootpage FROM sqlite_master WHERE name = 'i1'}]
-  set iOffset [hexio_get_int [hexio_read test.db [expr 12+($iRoot-1)*1024] 2]]
-  set data [hexio_render_int32 [expr $iRoot - 1]]
-  hexio_write test.db [expr ($iRoot-1)*1024 + $iOffset] $data
-  db close
-  sqlite3 db test.db
-
-  # The following DELETE statement attempts to delete a cell stored on the
-  # root page of index i1. After this cell is deleted it must be replaced
-  # by a cell retrieved from the child page (a leaf) of the deleted cell.
-  # This will fail, as the block modified the database image so that the
-  # child page of the deleted cell is from a table (intkey) b-tree, not an
-  # index b-tree as expected. At one point this was causing an assert()
-  # to fail.
-  catchsql { DELETE FROM t1 WHERE rowid = 3 }
-} {1 {database disk image is malformed}}
-
-do_test corrupt-5.1 {
-  db close
-  file delete -force test.db test.db-journal
-  sqlite3 db test.db
-
-  execsql { PRAGMA page_size = 1024 }
-  set ct "CREATE TABLE t1(c0 "
-  set i 0
-  while {[string length $ct] < 950} { append ct ", c[incr i]" }
-  append ct ")"
-  execsql $ct
-} {}
-
-do_test corrupt-5.2 {
-  db close
-  hexio_write test.db 108 00000000 
-  sqlite3 db test.db
-  catchsql { SELECT * FROM sqlite_master }
-} {1 {database disk image is malformed}}
-
-# At one point, the specific corruption caused by this test case was
-# causing a buffer overwrite. Although a crash was never demonstrated,
-# running this testcase under valgrind revealed the problem.
-do_test corrupt-6.1 {
-  db close
-  file delete -force test.db test.db-journal
-  sqlite3 db test.db
-  execsql { 
-    PRAGMA page_size = 1024; CREATE TABLE t1(x);
-  }
-
-  # The root page of t1 is 1024 bytes in size. The header is 8 bytes, and
-  # each of the cells inserted by the following INSERT statements consume
-  # 16 bytes (including the 2 byte cell-offset array entry). So the page
-  # can contain up to 63 cells.
-  for {set i 0} {$i < 63} {incr i} {
-    execsql { INSERT INTO t1 VALUES( randomblob(10) ) }
-  }
-
-  # Free the cell stored right at the end of the page (at offset pgsz-14).
-  execsql { DELETE FROM t1 WHERE rowid=1 }
-  set rootpage [db one {SELECT rootpage FROM sqlite_master WHERE name = 't1'}]
-  db close
-
-  set offset [expr ($rootpage * 1024)-14+2]
-  hexio_write test.db $offset 00FF
-  sqlite3 db test.db 
-
-  catchsql { INSERT INTO t1 VALUES( randomblob(10) ) }
-} {1 {database disk image is malformed}}
-
-finish_test