test/sortfault.test

   1 # 2014 March 25.
   2 #
   3 # The author disclaims copyright to this source code.  In place of
   4 # a legal notice, here is a blessing:
   5 #
   6 #    May you do good and not evil.
   7 #    May you find forgiveness for yourself and forgive others.
   8 #    May you share freely, never taking more than you give.
   9 #
  10 #***********************************************************************
  11 # This file implements regression tests for SQLite library.
  12 #
  13 # Specifically, it tests the effects of fault injection on the sorter
  14 # module (code in vdbesort.c).
  15 #
  16
  17 set testdir [file dirname $argv0]
  18 source $testdir/tester.tcl
  19 set testprefix sortfault
  20 db close
  21 sqlite3_shutdown
  22 sqlite3_config_pmasz 10
  23 sqlite3_initialize
  24 sqlite3 db test.db
  25
  26
  27 do_execsql_test 1.0 {
  28   PRAGMA cache_size = 5;
  29 }
  30
  31 foreach {tn mmap_limit nWorker tmpstore threadsmode fakeheap lookaside} {
  32           1          0       0     file multithread    false     false
  33           2     100000       0     file multithread    false     false
  34           3     100000       1     file multithread    false     false
  35           4    2000000       0     file singlethread   false      true
  36 } {
  37   if {$sqlite_options(threadsafe)} { set threadsmode singlethread }
  38
  39   db eval "PRAGMA threads=$nWorker"
  40   sqlite3_config $threadsmode
  41   if { $lookaside } {
  42     sqlite3_config_lookaside 100 500
  43   } else {
  44     sqlite3_config_lookaside 0 0
  45   }
  46   sqlite3_initialize
  47   sorter_test_fakeheap $fakeheap
  48
  49   set str [string repeat a 1000]
  50   puts $threadsmode
  51
  52   do_faultsim_test 1.$tn -prep {
  53     sqlite3 db test.db
  54     sqlite3_test_control SQLITE_TESTCTRL_SORTER_MMAP db $::mmap_limit
  55     execsql { PRAGMA cache_size = 5 }
  56   } -body {
  57     execsql {
  58       WITH r(x,y) AS (
  59           SELECT 1, $::str
  60           UNION ALL
  61           SELECT x+1, $::str FROM r
  62           LIMIT 200
  63       )
  64       SELECT count(x), length(y) FROM r GROUP BY (x%5)
  65     }
  66   } -test {
  67     faultsim_test_result {0 {40 1000 40 1000 40 1000 40 1000 40 1000}}
  68   }
  69
  70   do_faultsim_test 2.$tn -faults oom* -prep {
  71     sqlite3 db test.db
  72     sqlite3_test_control SQLITE_TESTCTRL_SORTER_MMAP db $::mmap_limit
  73     add_test_utf16bin_collate db
  74     execsql { PRAGMA cache_size = 5 }
  75   } -body {
  76     execsql {
  77       WITH r(x,y) AS (
  78           SELECT 100, $::str
  79           UNION ALL
  80           SELECT x-1, $::str FROM r
  81           LIMIT 100
  82       )
  83       SELECT count(x), length(y) FROM r GROUP BY y COLLATE utf16bin, (x%5)
  84     }
  85   } -test {
  86     faultsim_test_result {0 {20 1000 20 1000 20 1000 20 1000 20 1000}}
  87   }
  88
  89   if {$mmap_limit > 1000000} {
  90     set str2 [string repeat $str 10]
  91
  92     sqlite3_memdebug_vfs_oom_test 0
  93     sqlite3 db test.db
  94     sqlite3_test_control SQLITE_TESTCTRL_SORTER_MMAP db $::mmap_limit
  95     execsql { PRAGMA cache_size = 5 }
  96
  97     do_faultsim_test 3.$tn -faults oom-trans* -body {
  98       execsql {
  99         WITH r(x,y) AS (
 100             SELECT 300, $::str2
 101             UNION ALL
 102             SELECT x-1, $::str2 FROM r
 103             LIMIT 300
 104         )
 105         SELECT count(x), length(y) FROM r GROUP BY y, (x%5)
 106       }
 107     } -test {
 108       faultsim_test_result {0 {60 10000 60 10000 60 10000 60 10000 60 10000}}
 109     }
 110
 111     sqlite3_memdebug_vfs_oom_test 1
 112   }
 113 }
 114
 115 catch { db close }
 116 sqlite3_shutdown
 117 set t(0) singlethread
 118 set t(1) multithread
 119 set t(2) serialized
 120 sqlite3_config $t($sqlite_options(threadsafe))
 121 sqlite3_config_lookaside 100 500
 122 sqlite3_initialize
 123
 124 #-------------------------------------------------------------------------
 125 #
 126 reset_db
 127 do_execsql_test 4.0 {
 128   CREATE TABLE t1(a, b, c);
 129   INSERT INTO t1 VALUES(1, 2, 3);
 130 }
 131 do_test 4.1 {
 132   for {set i 0} {$i < 256} {incr i} {
 133     execsql {
 134       INSERT INTO t1 SELECT
 135         ((a<<3) + b) & 2147483647,
 136         ((b<<3) + c) & 2147483647,
 137         ((c<<3) + a) & 2147483647
 138       FROM t1 ORDER BY rowid DESC LIMIT 1;
 139     }
 140   }
 141 } {}
 142
 143 faultsim_save_and_close
 144
 145 do_faultsim_test 4.2 -faults oom* -prep {
 146   faultsim_restore_and_reopen
 147 } -body {
 148   execsql { CREATE UNIQUE INDEX i1 ON t1(a,b,c) }
 149 } -test {
 150   faultsim_test_result {0 {}}
 151 }
 152
 153 #-------------------------------------------------------------------------
 154 #
 155 reset_db
 156 set a [string repeat a 500]
 157 set b [string repeat b 500]
 158 set c [string repeat c 500]
 159 do_execsql_test 5.0 {
 160   CREATE TABLE t1(a, b, c);
 161   INSERT INTO t1 VALUES($a, $b, $c);
 162   INSERT INTO t1 VALUES($c, $b, $a);
 163 }
 164
 165 do_faultsim_test 5.1 -faults oom* -body {
 166   execsql { SELECT * FROM t1 ORDER BY a }
 167 } -test {
 168   faultsim_test_result [list 0 [list $::a $::b $::c $::c $::b $::a]]
 169 }
 170
 171 finish_test