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     ! 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