github.com/jdgcs/sqlite3@v1.12.1-0.20210908114423-bc5f96e4dd51/testdata/tcl/sortfault.test (about)

     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