Return to win32lock.test CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test

Annotation of embedaddon/sqlite3/test/win32lock.test, revision 1.1.1.1

1.1       misho       1: # 2011 July 11
                      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.  The
                     12: # focus of this script is recovery from transient manditory locks
                     13: # that sometimes appear on database files due to anti-virus software.
                     14: #
                     15: 
                     16: if {$tcl_platform(platform)!="windows"} return
                     17: 
                     18: set testdir [file dirname $argv0]
                     19: source $testdir/tester.tcl
                     20: 
                     21: set testprefix win32lock
                     22: 
                     23: db close
                     24: sqlite3_shutdown
                     25: test_sqlite3_log xLog
                     26: proc xLog {error_code msg} {
                     27:   lappend ::log $msg 
                     28: }
                     29: sqlite3 db test.db
                     30: 
                     31: do_test win32lock-1.1 {
                     32:   db eval {
                     33:     PRAGMA cache_size=10;
                     34:     CREATE TABLE t1(x,y);
                     35:     INSERT INTO t1 VALUES(1,randomblob(100000));
                     36:     INSERT INTO t1 VALUES(2,randomblob(50000));
                     37:     INSERT INTO t1 VALUES(3,randomblob(25000));
                     38:     INSERT INTO t1 VALUES(4,randomblob(12500));
                     39:     SELECT x, length(y) FROM t1 ORDER BY rowid;
                     40:   }
                     41: } {1 100000 2 50000 3 25000 4 12500}
                     42: 
                     43: unset -nocomplain delay1 rc msg
                     44: set old_pending_byte [sqlite3_test_control_pending_byte 0x40000000]
                     45: 
                     46: set win32_lock_ok [list]
                     47: set win32_lock_error [list]
                     48: set delay1 25
                     49: while {1} {
                     50:   lock_win32_file test.db 0 $::delay1
                     51:   set ::log {}
                     52:   set rc [catch {db eval {SELECT x, length(y) FROM t1 ORDER BY rowid}} msg]
                     53:   if {$rc} {
                     54:     lappend win32_lock_error $::delay1
                     55:     do_test win32lock-1.2-$delay1-error {
                     56:        set ::msg
                     57:     } {disk I/O error}
                     58:   } else {
                     59:     lappend win32_lock_ok $::delay1
                     60:     do_test win32lock-1.2-$delay1-ok {
                     61:        set ::msg
                     62:     } {1 100000 2 50000 3 25000 4 12500}
                     63:     if {[info exists ::log] && $::log!=""} {
                     64:       do_test win32lock-1.2-$delay1-log1 {
                     65:         regsub {\d+} $::log # x
                     66:         set x
                     67:       } {{delayed #ms for lock/sharing conflict}}
                     68:     }
                     69:   }
                     70:   if {[llength $win32_lock_ok] && [llength $win32_lock_error]} break
                     71:   incr delay1 25
                     72:   if {$delay1 > 12500} {
                     73:     puts "Timed out waiting for \"ok\" and \"error\" results."
                     74:     break
                     75:   }
                     76:   sqlite3_sleep 10
                     77: }
                     78: 
                     79: do_test win32lock-2.0 {
                     80:   file_control_win32_av_retry db -1 -1
                     81: } {0 10 25}
                     82: do_test win32lock-2.1 {
                     83:   file_control_win32_av_retry db 1 1
                     84: } {0 1 1}
                     85: 
                     86: #
                     87: # NOTE: It is known that the win32lock-2.2-* tests may fail if the system is
                     88: #       experiencing heavy load (i.e. they are very timing sensitive).  This is
                     89: #       primarily due to the AV retry delay being set to 1 millisecond in the
                     90: #       win32lock-2.1 test (above).  While it is important to test this corner
                     91: #       case for the AV retry logic, a failure of this test should probably not
                     92: #       be interpreted as a bug in SQLite or these test cases.
                     93: #
                     94: set win32_lock_ok [list]
                     95: set win32_lock_error [list]
                     96: set delay1 1
                     97: while {1} {
                     98:   lock_win32_file test.db 0 $::delay1
                     99:   set ::log {}
                    100:   set rc [catch {db eval {SELECT x, length(y) FROM t1 ORDER BY rowid}} msg]
                    101:   if {$rc} {
                    102:     lappend win32_lock_error $::delay1
                    103:     do_test win32lock-2.2-$delay1-error {
                    104:        set ::msg
                    105:     } {disk I/O error}
                    106:   } else {
                    107:     lappend win32_lock_ok $::delay1
                    108:     do_test win32lock-2.2-$delay1-ok {
                    109:        set ::msg
                    110:     } {1 100000 2 50000 3 25000 4 12500}
                    111:     if {[info exists ::log] && $::log!=""} {
                    112:       do_test win32lock-2.2-$delay1-log1 {
                    113:         regsub {\d+} $::log # x
                    114:         set x
                    115:       } {{delayed #ms for lock/sharing conflict}}
                    116:     }
                    117:   }
                    118:   if {[llength $win32_lock_ok] && [llength $win32_lock_error]} break
                    119:   incr delay1 1
                    120:   if {$delay1 > 500} {
                    121:     puts "Timed out waiting for \"ok\" and \"error\" results."
                    122:     break
                    123:   }
                    124:   sqlite3_sleep 10
                    125: }
                    126: 
                    127: file_control_win32_av_retry db 10 25
                    128: sqlite3_test_control_pending_byte $old_pending_byte
                    129: db close
                    130: sqlite3_shutdown
                    131: test_sqlite3_log 
                    132: sqlite3_initialize
                    133: finish_test