Fix a typo in walfault.test.

FossilOrigin-Name: 232dbe8ecec16485be5c5995fdf7a0ed951c2097

manifest

@@ -1,5 +1,5 @@
-C Test\sthat\sthe\scorrect\snumber\sof\spadding\sframes\sare\sappended\sto\sthe\slog\sfile\safter\scommitting\sa\stransaction\sin\ssynchronous=FULL\smode.
+C Fix\sa\stypo\sin\swalfault.test.
-D 2010-05-04T10:36:21
+D 2010-05-04T11:06:03
 F Makefile.arm-wince-mingw32ce-gcc fcd5e9cd67fe88836360bb4f9ef4cb7f8e2fb5a0
 F Makefile.in d83a0ffef3dcbfb08b410a6c6dd6c009ec9167fb
 F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654
@@ -221,7 +221,7 @@ F src/vdbeblob.c 5327132a42a91e8b7acfb60b9d2c3b1c5c863e0e
 F src/vdbemem.c 2a82f455f6ca6f78b59fb312f96054c04ae0ead1
 F src/vdbetrace.c 864cef96919323482ebd9986f2132435115e9cc2
 F src/vtab.c a0f8a40274e4261696ef57aa806de2776ab72cda
-F src/wal.c fcd2c4ce4a7d44928763966c2199e0de800fae89
+F src/wal.c 1d0abe01ae9836f207ecfe2d3f1ece97b744fc3e
 F src/wal.h d6d4a6809151e30bed5b01dd05cf27858f5a7bc8
 F src/walker.c 3112bb3afe1d85dc52317cb1d752055e9a781f8f
 F src/where.c 75fee9e255b62f773fcadd1d1f25b6f63ac7a356
@@ -386,7 +386,7 @@ F test/fts2q.test b2fbbe038b7a31a52a6079b215e71226d8c6a682
 F test/fts2r.test b154c30b63061d8725e320fba1a39e2201cadd5e
 F test/fts2token.test d8070b241a15ff13592a9ae4a8b7c171af6f445a
 F test/fts3.test ae0433b09b12def08105640e57693726c4949338
-F test/fts3_common.tcl 1d887ded06dac9b993cfb175618df7f70c796de2
+F test/fts3_common.tcl 4d8eec9db565fed9098f45c378f28e1657802011
 F test/fts3aa.test 5327d4c1d9b6c61021696746cc9a6cdc5bf159c0
 F test/fts3ab.test 09aeaa162aee6513d9ff336b6932211008b9d1f9
 F test/fts3ac.test 636ed7486043055d4f126a0e385f2d5a82ebbf63
@@ -412,8 +412,8 @@ F test/fts3expr.test 5e745b2b6348499d9ef8d59015de3182072c564c
 F test/fts3expr2.test 18da930352e5693eaa163a3eacf96233b7290d1a
 F test/fts3malloc.test 059592c4f37ccd30138bbf8e3e5b7982cb5c8f2e
 F test/fts3near.test 2e318ee434d32babd27c167142e2b94ddbab4844
-F test/fts3query.test 1acb21b58d6aa7504e990f0f589be85e9a133969
+F test/fts3query.test 2468caf7938dbc3be2e049524320ce4faf2227b3
-F test/fts3rnd.test 2f5761db9dd92f6fe09d08976ac658ef521846ed
+F test/fts3rnd.test 707533ce943f490443ce5e696236bb1675a37635
 F test/fts3snippet.test 9f9a4a7e396c5d8ce2898be65ebabc429555430f
 F test/fts4aa.test eadf85621c0a113d4c7ad3ccbf8441130e007b8f
 F test/func.test 6c5ce11e3a0021ca3c0649234e2d4454c89110ca
@@ -503,7 +503,7 @@ F test/mallocH.test 79b65aed612c9b3ed2dcdaa727c85895fd1bfbdb
 F test/mallocI.test e3ea401904d010cb7c1e4b2ee8803f4a9f5b999d
 F test/mallocJ.test b5d1839da331d96223e5f458856f8ffe1366f62e
 F test/mallocK.test d79968641d1b70d88f6c01bdb9a7eb4a55582cc9
-F test/malloc_common.tcl 206a1694c0d30cb8b8cbdda68ab8e1f232fd1ab9
+F test/malloc_common.tcl f95c4d3459877e64c2d856b8a9c39210f9968ddf
 F test/manydb.test b3d3bc4c25657e7f68d157f031eb4db7b3df0d3c
 F test/memdb.test 0825155b2290e900264daaaf0334b6dfe69ea498
 F test/memleak.test d2d2a1ff7105d32dc3fdf691458cf6cba58c7217
@@ -761,7 +761,7 @@ F test/vtab_shared.test 0eff9ce4f19facbe0a3e693f6c14b80711a4222d
 F test/wal.test 511c630993d5adc170f56e581909b6eb580b0f53
 F test/walbak.test a0e45187c7d8928df035dfea29b99b016b21ca3c
 F test/walcrash.test 63edc6a9e05f645b54d649186a5818fc82953e2e
-F test/walfault.test cdd1a27ed89bcb14596005ab2477b3724dd5f805
+F test/walfault.test 2504c5c50d8f9a9e48969de381eb98e2a8b89195
 F test/walhook.test 5f18e0fc8787f1f8889d7a9971af18f334f83786
 F test/walmode.test bac6f06544a8554588a1543def996bbe2fc41792
 F test/walslow.test d21625e2e99e11c032ce949e8a94661576548933
@@ -809,7 +809,7 @@ F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff
 F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
 F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
 F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f
-P 49bef00e5cda600ceb964148bf745de4aff1ab62
+P a60104aa7e38e7d9f2ff2eae02687dc9c5dd5d77
-R 44e8b17dd54df12e28ab0c945b738027
+R 9692cfa3edc87873be9342b2b7fc3777
 U dan
-Z dab97771a4b803a69cb81f43590ea234
+Z 6f47b056126e5089750d5cf38e878789

manifest.uuid

@@ -1 +1 @@
-a60104aa7e38e7d9f2ff2eae02687dc9c5dd5d77
+232dbe8ecec16485be5c5995fdf7a0ed951c2097

src/wal.c

@@ -573,16 +573,20 @@ finished:
 ** client from unlinking the log or wal-index file. If another process
 ** were to do this just after this client opened one of these files, the
 ** system would be badly broken.
+**
+** If the log file is successfully opened, SQLITE_OK is returned and 
+** *ppWal is set to point to a new WAL handle. If an error occurs,
+** an SQLite error code is returned and *ppWal is left unmodified.
 */
 int sqlite3WalOpen(
   sqlite3_vfs *pVfs,              /* vfs module to open wal and wal-index */
   const char *zDb,                /* Name of database file */
   Wal **ppWal                     /* OUT: Allocated Wal handle */
 ){
-  int rc = SQLITE_OK;             /* Return Code */
+  int rc;                         /* Return Code */
   Wal *pRet;                      /* Object to allocate and return */
   int flags;                      /* Flags passed to OsOpen() */
-  char *zWal = 0;                 /* Path to WAL file */
+  char *zWal;                     /* Path to WAL file */
   int nWal;                       /* Length of zWal in bytes */
 
   assert( zDb );
@@ -609,14 +613,12 @@ int sqlite3WalOpen(
   }
 
   if( rc!=SQLITE_OK ){
-    if( pRet ){
+    pVfs->xShmClose(pVfs, pRet->pWIndex, 0);
-      pVfs->xShmClose(pVfs, pRet->pWIndex, 0);
+    sqlite3OsClose(pRet->pFd);
-      sqlite3OsClose(pRet->pFd);
+    sqlite3_free(pRet);
-      sqlite3_free(pRet);
+  }else{
-    }
+    *ppWal = pRet;
-    pRet = 0;
   }
-  *ppWal = pRet;
   return rc;
 }
 

test/fts3_common.tcl

@@ -288,155 +288,3 @@ proc fts3_read {tbl where varname} {
 
 ##########################################################################
 
-#-------------------------------------------------------------------------
-# This proc is used to test a single SELECT statement. Parameter $name is
-# passed a name for the test case (i.e. "fts3_malloc-1.4.1") and parameter
-# $sql is passed the text of the SELECT statement. Parameter $result is
-# set to the expected output if the SELECT statement is successfully
-# executed using [db eval].
-#
-# Example:
-#
-#   do_select_test testcase-1.1 "SELECT 1+1, 1+2" {1 2}
-#
-# If global variable DO_MALLOC_TEST is set to a non-zero value, or if
-# it is not defined at all, then OOM testing is performed on the SELECT
-# statement. Each OOM test case is said to pass if either (a) executing
-# the SELECT statement succeeds and the results match those specified
-# by parameter $result, or (b) TCL throws an "out of memory" error.
-#
-# If DO_MALLOC_TEST is defined and set to zero, then the SELECT statement
-# is executed just once. In this case the test case passes if the results
-# match the expected results passed via parameter $result.
-#
-proc do_select_test {name sql result} {
-  uplevel [list doPassiveTest 0 $name $sql [list 0 $result]]
-}
-
-proc do_restart_select_test {name sql result} {
-  uplevel [list doPassiveTest 1 $name $sql [list 0 $result]]
-}
-
-proc do_error_test {name sql error} {
-  uplevel [list doPassiveTest 0 $name $sql [list 1 $error]]
-}
-
-proc doPassiveTest {isRestart name sql catchres} {
-  if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }
-
-  switch $::DO_MALLOC_TEST {
-    0 { # No malloc failures.
-      do_test $name [list set {} [uplevel [list catchsql $sql]]] $catchres
-      return
-    }
-    1 { # Simulate transient failures.
-      set nRepeat 1
-      set zName "transient"
-      set nStartLimit 100000
-      set nBackup 1
-    }
-    2 { # Simulate persistent failures.
-      set nRepeat 1
-      set zName "persistent"
-      set nStartLimit 100000
-      set nBackup 1
-    }
-    3 { # Simulate transient failures with extra brute force.
-      set nRepeat 100000
-      set zName "ridiculous"
-      set nStartLimit 1
-      set nBackup 10
-    }
-  }
-
-  # The set of acceptable results from running [catchsql $sql].
-  #
-  set answers [list {1 {out of memory}} $catchres]
-  set str [join $answers " OR "]
-
-  set nFail 1
-  for {set iLimit $nStartLimit} {$nFail} {incr iLimit} {
-    for {set iFail 1} {$nFail && $iFail<=$iLimit} {incr iFail} {
-      for {set iTest 0} {$iTest<$nBackup && ($iFail-$iTest)>0} {incr iTest} {
-
-        if {$isRestart} { sqlite3 db test.db }
-
-        sqlite3_memdebug_fail [expr $iFail-$iTest] -repeat $nRepeat
-        set res [uplevel [list catchsql $sql]]
-        if {[lsearch -exact $answers $res]>=0} { set res $str }
-        set testname "$name.$zName.$iFail"
-        do_test "$name.$zName.$iLimit.$iFail" [list set {} $res] $str
-
-        set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
-      }
-    }
-  }
-}
-
-
-#-------------------------------------------------------------------------
-# Test a single write to the database. In this case a  "write" is a 
-# DELETE, UPDATE or INSERT statement.
-#
-# If OOM testing is performed, there are several acceptable outcomes:
-#
-#   1) The write succeeds. No error is returned.
-#
-#   2) An "out of memory" exception is thrown and:
-#
-#     a) The statement has no effect, OR
-#     b) The current transaction is rolled back, OR
-#     c) The statement succeeds. This can only happen if the connection
-#        is in auto-commit mode (after the statement is executed, so this
-#        includes COMMIT statements).
-#
-# If the write operation eventually succeeds, zero is returned. If a
-# transaction is rolled back, non-zero is returned.
-#
-# Parameter $name is the name to use for the test case (or test cases).
-# The second parameter, $tbl, should be the name of the database table
-# being modified. Parameter $sql contains the SQL statement to test.
-#
-proc do_write_test {name tbl sql} {
-  if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }
-
-  # Figure out an statement to get a checksum for table $tbl.
-  db eval "SELECT * FROM $tbl" V break
-  set cksumsql "SELECT md5sum([join [concat rowid $V(*)] ,]) FROM $tbl"
-
-  # Calculate the initial table checksum.
-  set cksum1 [db one $cksumsql]
-
-  if {$::DO_MALLOC_TEST } {
-    set answers [list {1 {out of memory}} {0 {}}]
-    if {$::DO_MALLOC_TEST==1} {
-      set modes {100000 transient}
-    } else {
-      set modes {1 persistent}
-    }
-  } else {
-    set answers [list {0 {}}]
-    set modes [list 0 nofail]
-  }
-  set str [join $answers " OR "]
-
-  foreach {nRepeat zName} $modes {
-    for {set iFail 1} 1 {incr iFail} {
-      if {$::DO_MALLOC_TEST} {sqlite3_memdebug_fail $iFail -repeat $nRepeat}
-
-      set res [uplevel [list catchsql $sql]]
-      set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
-      if {$nFail==0} {
-        do_test $name.$zName.$iFail [list set {} $res] {0 {}}
-        return
-      } else {
-        if {[lsearch $answers $res]>=0} {
-          set res $str
-        }
-        do_test $name.$zName.$iFail [list set {} $res] $str
-        set cksum2 [db one $cksumsql]
-        if {$cksum1 != $cksum2} return
-      }
-    }
-  }
-}

test/fts3query.test

@@ -20,6 +20,7 @@ source $testdir/tester.tcl
 # If this build does not include FTS3, skip the tests in this file.
 #
 ifcapable !fts3 { finish_test ; return }
+source $testdir/malloc_common.tcl
 source $testdir/fts3_common.tcl
 set DO_MALLOC_TEST 0
 

test/fts3rnd.test

@@ -82,6 +82,7 @@ source $testdir/tester.tcl
 #
 ifcapable !fts3 { finish_test ; return }
 source $testdir/fts3_common.tcl
+source $testdir/malloc_common.tcl
 
 set G(nVocab) 100
 

test/malloc_common.tcl

@@ -167,3 +167,157 @@ proc do_malloc_test {tn args} {
   unset ::mallocopts
   sqlite3_memdebug_fail -1
 }
+
+
+#-------------------------------------------------------------------------
+# This proc is used to test a single SELECT statement. Parameter $name is
+# passed a name for the test case (i.e. "fts3_malloc-1.4.1") and parameter
+# $sql is passed the text of the SELECT statement. Parameter $result is
+# set to the expected output if the SELECT statement is successfully
+# executed using [db eval].
+#
+# Example:
+#
+#   do_select_test testcase-1.1 "SELECT 1+1, 1+2" {1 2}
+#
+# If global variable DO_MALLOC_TEST is set to a non-zero value, or if
+# it is not defined at all, then OOM testing is performed on the SELECT
+# statement. Each OOM test case is said to pass if either (a) executing
+# the SELECT statement succeeds and the results match those specified
+# by parameter $result, or (b) TCL throws an "out of memory" error.
+#
+# If DO_MALLOC_TEST is defined and set to zero, then the SELECT statement
+# is executed just once. In this case the test case passes if the results
+# match the expected results passed via parameter $result.
+#
+proc do_select_test {name sql result} {
+  uplevel [list doPassiveTest 0 $name $sql [list 0 $result]]
+}
+
+proc do_restart_select_test {name sql result} {
+  uplevel [list doPassiveTest 1 $name $sql [list 0 $result]]
+}
+
+proc do_error_test {name sql error} {
+  uplevel [list doPassiveTest 0 $name $sql [list 1 $error]]
+}
+
+proc doPassiveTest {isRestart name sql catchres} {
+  if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }
+
+  switch $::DO_MALLOC_TEST {
+    0 { # No malloc failures.
+      do_test $name [list set {} [uplevel [list catchsql $sql]]] $catchres
+      return
+    }
+    1 { # Simulate transient failures.
+      set nRepeat 1
+      set zName "transient"
+      set nStartLimit 100000
+      set nBackup 1
+    }
+    2 { # Simulate persistent failures.
+      set nRepeat 1
+      set zName "persistent"
+      set nStartLimit 100000
+      set nBackup 1
+    }
+    3 { # Simulate transient failures with extra brute force.
+      set nRepeat 100000
+      set zName "ridiculous"
+      set nStartLimit 1
+      set nBackup 10
+    }
+  }
+
+  # The set of acceptable results from running [catchsql $sql].
+  #
+  set answers [list {1 {out of memory}} $catchres]
+  set str [join $answers " OR "]
+
+  set nFail 1
+  for {set iLimit $nStartLimit} {$nFail} {incr iLimit} {
+    for {set iFail 1} {$nFail && $iFail<=$iLimit} {incr iFail} {
+      for {set iTest 0} {$iTest<$nBackup && ($iFail-$iTest)>0} {incr iTest} {
+
+        if {$isRestart} { sqlite3 db test.db }
+
+        sqlite3_memdebug_fail [expr $iFail-$iTest] -repeat $nRepeat
+        set res [uplevel [list catchsql $sql]]
+        if {[lsearch -exact $answers $res]>=0} { set res $str }
+        set testname "$name.$zName.$iFail"
+        do_test "$name.$zName.$iLimit.$iFail" [list set {} $res] $str
+
+        set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
+      }
+    }
+  }
+}
+
+
+#-------------------------------------------------------------------------
+# Test a single write to the database. In this case a  "write" is a 
+# DELETE, UPDATE or INSERT statement.
+#
+# If OOM testing is performed, there are several acceptable outcomes:
+#
+#   1) The write succeeds. No error is returned.
+#
+#   2) An "out of memory" exception is thrown and:
+#
+#     a) The statement has no effect, OR
+#     b) The current transaction is rolled back, OR
+#     c) The statement succeeds. This can only happen if the connection
+#        is in auto-commit mode (after the statement is executed, so this
+#        includes COMMIT statements).
+#
+# If the write operation eventually succeeds, zero is returned. If a
+# transaction is rolled back, non-zero is returned.
+#
+# Parameter $name is the name to use for the test case (or test cases).
+# The second parameter, $tbl, should be the name of the database table
+# being modified. Parameter $sql contains the SQL statement to test.
+#
+proc do_write_test {name tbl sql} {
+  if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }
+
+  # Figure out an statement to get a checksum for table $tbl.
+  db eval "SELECT * FROM $tbl" V break
+  set cksumsql "SELECT md5sum([join [concat rowid $V(*)] ,]) FROM $tbl"
+
+  # Calculate the initial table checksum.
+  set cksum1 [db one $cksumsql]
+
+  if {$::DO_MALLOC_TEST } {
+    set answers [list {1 {out of memory}} {0 {}}]
+    if {$::DO_MALLOC_TEST==1} {
+      set modes {100000 transient}
+    } else {
+      set modes {1 persistent}
+    }
+  } else {
+    set answers [list {0 {}}]
+    set modes [list 0 nofail]
+  }
+  set str [join $answers " OR "]
+
+  foreach {nRepeat zName} $modes {
+    for {set iFail 1} 1 {incr iFail} {
+      if {$::DO_MALLOC_TEST} {sqlite3_memdebug_fail $iFail -repeat $nRepeat}
+
+      set res [uplevel [list catchsql $sql]]
+      set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
+      if {$nFail==0} {
+        do_test $name.$zName.$iFail [list set {} $res] {0 {}}
+        return
+      } else {
+        if {[lsearch $answers $res]>=0} {
+          set res $str
+        }
+        do_test $name.$zName.$iFail [list set {} $res] $str
+        set cksum2 [db one $cksumsql]
+        if {$cksum1 != $cksum2} return
+      }
+    }
+  }
+}

test/walfault.test

@@ -23,7 +23,7 @@ do_malloc_test walfault-oom-1 -sqlbody {
   PRAGMA journal_mode = WAL;
   CREATE TABLE t1(a, b);
   INSERT INTO t1 VALUES(1, 2);
-  PRAGMA checkpoint;
+  PRAGMA wal_checkpoint;
 }
 
 do_malloc_test walfault-oom-2 -tclprep {