Add files using upload-large-folder tool

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts3/unicode/parseunicode.tcl

@@ -0,0 +1,205 @@
+
+#--------------------------------------------------------------------------
+# Parameter $zName must be a path to the file UnicodeData.txt. This command
+# reads the file and returns a list of mappings required to remove all
+# diacritical marks from a unicode string. Each mapping is itself a list
+# consisting of two elements - the unicode codepoint and the single ASCII
+# character that it should be replaced with, or an empty string if the 
+# codepoint should simply be removed from the input. Examples:
+#
+#   { 224 a  0 }     (replace codepoint 224 to "a")
+#   { 769 "" 0 }     (remove codepoint 769 from input)
+#
+# Mappings are only returned for non-upper case codepoints. It is assumed
+# that the input has already been folded to lower case.
+#
+# The third value in the list is always either 0 or 1. 0 if the 
+# UnicodeData.txt file maps the codepoint to a single ASCII character and
+# a diacritic, or 1 if the mapping is indirect. For example, consider the 
+# two entries:
+#
+# 1ECD;LATIN SMALL LETTER O WITH DOT BELOW;Ll;0;L;006F 0323;;;;N;;;1ECC;;1ECC
+# 1ED9;LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW;Ll;0;L;1ECD 0302;;;;N;;;1ED8;;1ED8
+#
+# The first codepoint is a direct mapping (as 006F is ASCII and 0323 is a 
+# diacritic). The second is an indirect mapping, as it maps to the
+# first codepoint plus 0302 (a diacritic).
+#
+proc rd_load_unicodedata_text {zName} {
+  global tl_lookup_table
+
+  set fd [open $zName]
+  set lField {
+    code
+    character_name
+    general_category
+    canonical_combining_classes
+    bidirectional_category
+    character_decomposition_mapping
+    decimal_digit_value
+    digit_value
+    numeric_value
+    mirrored
+    unicode_1_name
+    iso10646_comment_field
+    uppercase_mapping
+    lowercase_mapping
+    titlecase_mapping
+  }
+  set lRet [list]
+
+  while { ![eof $fd] } {
+    set line [gets $fd]
+    if {$line == ""} continue
+
+    set fields [split $line ";"]
+    if {[llength $fields] != [llength $lField]} { error "parse error: $line" }
+    foreach $lField $fields {}
+    if { [llength $character_decomposition_mapping]!=2
+      || [string is xdigit [lindex $character_decomposition_mapping 0]]==0
+    } {
+      continue
+    }
+
+    set iCode  [expr "0x$code"]
+    set iAscii [expr "0x[lindex $character_decomposition_mapping 0]"]
+    set iDia   [expr "0x[lindex $character_decomposition_mapping 1]"]
+
+    # Filter out upper-case characters, as they will be mapped to their
+    # lower-case equivalents before this data is used.
+    if {[info exists tl_lookup_table($iCode)]} continue
+
+    # Check if this is an indirect mapping. If so, set bIndirect to true
+    # and change $iAscii to the indirectly mappped ASCII character.
+    set bIndirect 0
+    if {[info exists dia($iDia)] && [info exists mapping($iAscii)]} {
+      set iAscii $mapping($iAscii)
+      set bIndirect 1
+    }
+
+    if { ($iAscii >= 97 && $iAscii <= 122)
+      || ($iAscii >= 65 && $iAscii <= 90)
+    } {
+      lappend lRet [list $iCode [string tolower [format %c $iAscii]] $bIndirect]
+      set mapping($iCode) $iAscii
+      set dia($iDia) 1
+    }
+  }
+
+  foreach d [array names dia] {
+    lappend lRet [list $d "" 0]
+  }
+  set lRet [lsort -integer -index 0 $lRet]
+
+  close $fd
+  set lRet
+}
+
+#-------------------------------------------------------------------------
+# Parameter $zName must be a path to the file UnicodeData.txt. This command
+# reads the file and returns a list of codepoints (integers). The list
+# contains all codepoints in the UnicodeData.txt assigned to any "General
+# Category" that is not a "Letter" or "Number".
+#
+proc an_load_unicodedata_text {zName} {
+  set fd [open $zName]
+  set lField {
+    code
+    character_name
+    general_category
+    canonical_combining_classes
+    bidirectional_category
+    character_decomposition_mapping
+    decimal_digit_value
+    digit_value
+    numeric_value
+    mirrored
+    unicode_1_name
+    iso10646_comment_field
+    uppercase_mapping
+    lowercase_mapping
+    titlecase_mapping
+  }
+  set lRet [list]
+
+  while { ![eof $fd] } {
+    set line [gets $fd]
+    if {$line == ""} continue
+
+    set fields [split $line ";"]
+    if {[llength $fields] != [llength $lField]} { error "parse error: $line" }
+    foreach $lField $fields {}
+
+    set iCode [expr "0x$code"]
+    set bAlnum [expr {
+         [lsearch {L N} [string range $general_category 0 0]] >= 0
+      || $general_category=="Co"
+    }]
+
+    if { !$bAlnum } { lappend lRet $iCode }
+  }
+
+  close $fd
+  set lRet
+}
+
+proc tl_load_casefolding_txt {zName} {
+  global tl_lookup_table
+
+  set fd [open $zName]
+  while { ![eof $fd] } {
+    set line [gets $fd]
+    if {[string range $line 0 0] == "#"} continue
+    if {$line == ""} continue
+
+    foreach x {a b c d} {unset -nocomplain $x}
+    foreach {a b c d} [split $line ";"] {}
+
+    set a2 [list]
+    set c2 [list]
+    foreach elem $a { lappend a2 [expr "0x[string trim $elem]"] }
+    foreach elem $c { lappend c2 [expr "0x[string trim $elem]"] }
+    set b [string trim $b]
+    set d [string trim $d]
+
+    if {$b=="C" || $b=="S"} { set tl_lookup_table($a2) $c2 }
+  }
+}
+
+proc cc_load_unicodedata_text {zName} {
+  set fd [open $zName]
+  set lField {
+    code
+    character_name
+    general_category
+    canonical_combining_classes
+    bidirectional_category
+    character_decomposition_mapping
+    decimal_digit_value
+    digit_value
+    numeric_value
+    mirrored
+    unicode_1_name
+    iso10646_comment_field
+    uppercase_mapping
+    lowercase_mapping
+    titlecase_mapping
+  }
+  set lRet [list]
+
+  while { ![eof $fd] } {
+    set line [gets $fd]
+    if {$line == ""} continue
+
+    set fields [split $line ";"]
+    if {[llength $fields] != [llength $lField]} { error "parse error: $line" }
+    foreach $lField $fields {}
+
+    lappend lRet [list $code $general_category]
+  }
+
+  close $fd
+  set lRet
+}
+
+

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5bigid.test

@@ -0,0 +1,62 @@
+# 2023 May 28
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5bigid
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+set nRow 20000
+
+proc do_ascdesc_test {tn query} {
+  set ::lAsc  [db eval { SELECT rowid FROM x1($query) }] 
+  set ::lDesc [db eval { SELECT rowid FROM x1($query) ORDER BY rowid DESC }] 
+  do_test $tn.1 { lsort -integer $::lAsc } $::lAsc
+  do_test $tn.2 { lsort -integer -decr $::lDesc } $::lDesc
+  do_test $tn.3 { lsort -integer $::lDesc } $::lAsc
+}
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE x1 USING fts5(a);
+}
+
+do_test 1.1 {
+  for {set ii 0} {$ii < $nRow} {incr ii} {
+    db eval {
+      REPLACE INTO x1(rowid, a) VALUES(random(), 'movement at the station');
+    }
+  }
+} {}
+
+do_ascdesc_test 1.2 "the"
+
+do_execsql_test 1.3 {
+  DELETE FROM x1
+}
+
+do_test 1.4 {
+  for {set ii 0} {$ii < $nRow} {incr ii} {
+    db eval {
+      INSERT INTO x1(rowid, a) VALUES(
+          $ii + 0x6FFFFFFFFFFFFFFF, 'movement at the station'
+      );
+    }
+  }
+} {}
+
+do_ascdesc_test 1.5 "movement"
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5corrupt4.test

@@ -0,0 +1,63 @@
+# 2019 May 16
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5corrupt4
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+sqlite3_fts5_may_be_corrupt 1
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE ttt USING fts5(a, b); 
+  INSERT INTO ttt 
+     VALUES('e ee eee e ee eee e ee eee', 'eee ee e e e ee eee ee ee');
+  INSERT INTO ttt SELECT a||a, b||b FROM ttt;   
+  INSERT INTO ttt SELECT a||a, b||b FROM ttt;   
+}
+
+expr srand(1)
+
+proc mutate {blob i} {
+  set o [expr {$i % [string length $blob]}]
+  set a [string range $blob 0 $o-1]
+  set b [string range $blob $o+1 end]
+  set v [expr int(rand()*255) - 127]
+  return "$a[binary format c $v]$b"
+}
+db func mutate mutate
+
+for {set j 1000} {$j <= 5000} {incr j 1000} {
+  do_test 1.$j {
+    for {set i 0} {$i < 1000} {incr i} {
+      execsql {
+        BEGIN;
+          UPDATE ttt_data SET block = mutate(block, $i) WHERE id>10;
+      }
+      foreach sql {
+        {SELECT snippet(ttt, -1, '.', '..', '[', ']'), * FROM ttt('e*')}
+        {SELECT snippet(ttt, -1, '.', '..', '[', ']'), * FROM ttt('e* NOT ee*')}
+      } {
+        catch { execsql $sql }
+      }
+      execsql ROLLBACK
+    }
+  } {}
+}
+
+sqlite3_fts5_may_be_corrupt 0
+finish_test
+

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5faultA.test

@@ -0,0 +1,63 @@
+# 2016 February 2
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+#
+# This file is focused on OOM errors.
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+source $testdir/malloc_common.tcl
+set testprefix fts5faultA
+
+# If SQLITE_ENABLE_FTS3 is defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+foreach_detail_mode $testprefix {
+  do_execsql_test 1.0 {
+    CREATE VIRTUAL TABLE o1 USING fts5(a, detail=%DETAIL%);
+    INSERT INTO o1(o1, rank) VALUES('pgsz', 32);
+  
+    WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<300 )
+    INSERT INTO o1 SELECT 'A B C' FROM s;
+  
+    INSERT INTO o1 VALUES('A X C');
+  
+    WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<300 )
+    INSERT INTO o1 SELECT 'A B C' FROM s;
+  }
+  
+  do_faultsim_test 1 -faults oom* -prep {
+    sqlite3 db test.db
+  } -body {
+    execsql { SELECT rowid FROM o1('a NOT b') }
+  } -test {
+    faultsim_test_result {0 301}
+  }
+}
+
+do_execsql_test 2.0 {
+  CREATE VIRTUAL TABLE o2 USING fts5(a);
+  
+  INSERT INTO o2 VALUES('A B C');
+  WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<300 )
+  INSERT INTO o2 SELECT group_concat('A B C ') FROM s;
+}
+
+do_faultsim_test 2 -faults oom* -prep {
+  sqlite3 db test.db
+} -body {
+  execsql { SELECT rowid FROM o2('a+b+c NOT xyz') }
+} -test {
+  faultsim_test_result {0 {1 2}}
+}
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5faultH.test

@@ -0,0 +1,150 @@
+# 2010 June 15
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+source $testdir/malloc_common.tcl
+set testprefix fts5faultG
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+set ::testprefix fts5faultH
+
+sqlite3_fts5_register_origintext db
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(
+      x, tokenize="origintext unicode61", tokendata=1
+  );
+
+  BEGIN;
+    INSERT INTO t1 VALUES('oNe tWo thRee');
+    INSERT INTO t1 VALUES('One Two Three');
+    INSERT INTO t1 VALUES('onE twO threE');
+  COMMIT;
+  BEGIN;
+    INSERT INTO t1 VALUES('one two three');
+    INSERT INTO t1 VALUES('one two three');
+    INSERT INTO t1 VALUES('one two three');
+  COMMIT;
+}
+
+do_faultsim_test 1 -faults oom* -prep { 
+} -body {
+  execsql {
+    SELECT rowid FROM t1('three');
+  }
+} -test {
+  faultsim_integrity_check
+  faultsim_test_result {0 {1 2 3 4 5 6}}
+}
+
+
+reset_db
+sqlite3_fts5_register_origintext db
+do_execsql_test 2.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(
+      x, tokenize="origintext unicode61", tokendata=1
+  );
+  INSERT INTO t1(t1, rank) VALUES('pgsz', 64);
+
+  BEGIN;
+    INSERT INTO t1(rowid, x) VALUES(10, 'aaa bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(12, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(13, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(14, 'bbb BBB bbb');
+    INSERT INTO t1(rowid, x) VALUES(15, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(16, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(17, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(18, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(19, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(20, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(21, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(22, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(23, 'bbb bbb bbb');
+    INSERT INTO t1(rowid, x) VALUES(24, 'aaa bbb BBB');
+  COMMIT;
+}
+
+do_faultsim_test 2 -faults oom* -prep { 
+} -body {
+  execsql {
+    SELECT rowid FROM t1('BBB AND AAA');
+  }
+} -test {
+  faultsim_integrity_check
+  faultsim_test_result {0 {10 24}}
+}
+
+reset_db
+sqlite3_fts5_register_origintext db
+do_execsql_test 3.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(
+      x, tokenize="origintext unicode61", tokendata=1
+  );
+  INSERT INTO t1(t1, rank) VALUES('pgsz', 64);
+
+  INSERT INTO t1(rowid, x) VALUES(9, 'bbb Bbb BBB');
+  BEGIN;
+    INSERT INTO t1(rowid, x) VALUES(10, 'aaa bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(11, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(12, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(13, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(14, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(15, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(16, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(17, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(18, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(19, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(20, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(21, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(22, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(23, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(24, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(25, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(26, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(27, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(28, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(29, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(30, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(31, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(32, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(33, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(34, 'bbb Bbb BBB');
+    INSERT INTO t1(rowid, x) VALUES(35, 'aaa bbb BBB');
+  COMMIT;
+}
+
+do_faultsim_test 3.1 -faults oom* -prep { 
+} -body {
+  execsql {
+    SELECT rowid FROM t1('BBB AND AAA');
+  }
+} -test {
+  faultsim_integrity_check
+  faultsim_test_result {0 {10 35}}
+}
+do_faultsim_test 3.2 -faults oom* -prep { 
+} -body {
+  execsql {
+    SELECT count(*) FROM t1('BBB');
+  }
+} -test {
+  faultsim_integrity_check
+  faultsim_test_result {0 27}
+}
+
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5merge2.test

@@ -0,0 +1,57 @@
+# 2014 Dec 20
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Test that focus on incremental merges of segments.
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5merge2
+return_if_no_fts5
+
+proc dump_structure {} {
+  db eval {SELECT fts5_decode(id, block) AS t FROM t1_data WHERE id=10} {
+    foreach lvl [lrange $t 1 end] {
+      set seg [string repeat . [expr [llength $lvl]-2]]
+      puts "[lrange $lvl 0 1] $seg"
+    }
+  }
+}
+
+foreach_detail_mode $testprefix {
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(x, detail=%DETAIL%);
+  INSERT INTO t1(t1, rank) VALUES('pgsz', 32);
+  INSERT INTO t1(t1, rank) VALUES('crisismerge', 2);
+  INSERT INTO t1 VALUES('1 2 3 4');
+}
+
+expr srand(0)
+db func rnddoc fts5_rnddoc
+do_test 1.1 {
+  for {set i 0} {$i < 100} {incr i} {
+    execsql {
+      BEGIN;
+        DELETE FROM t1 WHERE rowid = 1;
+        INSERT INTO t1(rowid, x) VALUES(1, '1 2 3 4');
+        INSERT INTO t1 VALUES(rnddoc(10));
+      COMMIT;
+    }
+  }
+} {}
+
+do_execsql_test 1.2 {
+  INSERT INTO t1(t1) VALUES('integrity-check');
+}
+
+}
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5near.test

@@ -0,0 +1,70 @@
+# 2014 Jan 08
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Tests focused on the NEAR operator.
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5near
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+proc do_near_test {tn doc near res} {
+  uplevel [list do_execsql_test $tn "
+    DELETE FROM t1;
+    INSERT INTO t1 VALUES('$doc');
+    SELECT count(*) FROM t1 WHERE t1 MATCH '$near';
+  " $res]
+}
+
+execsql { 
+  CREATE VIRTUAL TABLE t1 USING fts5(x, tokenize = "ascii tokenchars '.'") 
+}
+
+do_near_test 1.1 ". . a . . . b . ." { NEAR(a b, 5) } 1
+do_near_test 1.2 ". . a . . . b . ." { NEAR(a b, 4) } 1
+do_near_test 1.3 ". . a . . . b . ." { NEAR(a b, 3) } 1
+do_near_test 1.4 ". . a . . . b . ." { NEAR(a b, 2) } 0
+
+do_near_test 1.5 ". . a . . . b . ." { NEAR(b a, 5) } 1
+do_near_test 1.6 ". . a . . . b . ." { NEAR(b a, 4) } 1
+do_near_test 1.7 ". . a . . . b . ." { NEAR(b a, 3) } 1
+do_near_test 1.8 ". . a . . . b . ." { NEAR(b a, 2) } 0
+
+do_near_test 1.9  ". a b . . . c . ." { NEAR("a b" c, 3) } 1
+do_near_test 1.10 ". a b . . . c . ." { NEAR("a b" c, 2) } 0
+do_near_test 1.11 ". a b . . . c . ." { NEAR(c "a b", 3) } 1
+do_near_test 1.12 ". a b . . . c . ." { NEAR(c "a b", 2) } 0
+
+do_near_test 1.13 ". a b . . . c d ." { NEAR(a+b c+d, 3) } 1
+do_near_test 1.14 ". a b . . . c d ." { NEAR(a+b c+d, 2) } 0
+do_near_test 1.15 ". a b . . . c d ." { NEAR(c+d a+b, 3) } 1
+do_near_test 1.16 ". a b . . . c d ." { NEAR(c+d a+b, 2) } 0
+
+do_near_test 1.17 ". a b . . . c d ." { NEAR(a b c d, 5) } 1
+do_near_test 1.18 ". a b . . . c d ." { NEAR(a b c d, 4) } 0
+do_near_test 1.19 ". a b . . . c d ." { NEAR(a+b c d, 4) } 1
+
+do_near_test 1.20 "a b c d e f g h i" { NEAR(b+c a+b+c+d i, 5) } 1
+do_near_test 1.21 "a b c d e f g h i" { NEAR(b+c a+b+c+d i, 4) } 0
+
+do_near_test 1.22 "a b c d e f g h i" { NEAR(a+b+c+d i b+c, 5) } 1
+do_near_test 1.23 "a b c d e f g h i" { NEAR(a+b+c+d i b+c, 4) } 0
+
+do_near_test 1.24 "a b c d e f g h i" { NEAR(i a+b+c+d b+c, 5) } 1
+do_near_test 1.25 "a b c d e f g h i" { NEAR(i a+b+c+d b+c, 4) } 0
+
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5vocab2.test

@@ -0,0 +1,310 @@
+# 2017 August 10
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# The tests in this file focus on testing the fts5vocab module.
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5vocab2
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(a, b);
+  CREATE VIRTUAL TABLE v1 USING fts5vocab(t1, instance);
+
+  INSERT INTO t1 VALUES('one two', 'two three');
+  INSERT INTO t1 VALUES('three four', 'four five five five');
+}
+
+do_execsql_test 1.1 {
+  SELECT * FROM v1;
+} {
+  five  2 b 1
+  five  2 b 2
+  five  2 b 3
+  four  2 a 1
+  four  2 b 0
+  one   1 a 0
+  three 1 b 1
+  three 2 a 0
+  two   1 a 1
+  two   1 b 0
+}
+
+do_execsql_test 1.2 {
+  SELECT * FROM v1 WHERE term='three';
+} {
+  three 1 b 1
+  three 2 a 0
+}
+
+do_execsql_test 1.3 {
+  BEGIN;
+    DELETE FROM t1 WHERE rowid=2;
+    SELECT * FROM v1;
+  ROLLBACK;
+} {
+  one   1 a 0
+  three 1 b 1
+  two   1 a 1
+  two   1 b 0
+}
+
+do_execsql_test 1.4 {
+  BEGIN;
+    DELETE FROM t1 WHERE rowid=1;
+    SELECT * FROM v1;
+  ROLLBACK;
+} {
+  five  2 b 1
+  five  2 b 2
+  five  2 b 3
+  four  2 a 1
+  four  2 b 0
+  three 2 a 0
+}
+
+do_execsql_test 1.5 {
+  DELETE FROM t1;
+  SELECT * FROM v1;
+} {}
+
+#-------------------------------------------------------------------------
+#
+do_execsql_test 2.0 {
+  DROP TABLE IF EXISTS t1;
+  DROP TABLE IF EXISTS v1;
+
+  CREATE VIRTUAL TABLE t1 USING fts5(a, b, detail=column);
+  CREATE VIRTUAL TABLE v1 USING fts5vocab(t1, instance);
+
+  INSERT INTO t1 VALUES('one two', 'two three');
+  INSERT INTO t1 VALUES('three four', 'four five five five');
+}
+
+do_execsql_test 2.1 {
+  SELECT * FROM v1;
+} {
+  five  2 b {}
+  four  2 a {}
+  four  2 b {}
+  one   1 a {}
+  three 1 b {}
+  three 2 a {}
+  two   1 a {}
+  two   1 b {}
+}
+
+do_execsql_test 2.2 {
+  SELECT * FROM v1 WHERE term='three';
+} {
+  three 1 b {}
+  three 2 a {}
+}
+
+do_execsql_test 2.3 {
+  BEGIN;
+    DELETE FROM t1 WHERE rowid=2;
+    SELECT * FROM v1;
+  ROLLBACK;
+} {
+  one   1 a {}
+  three 1 b {}
+  two   1 a {}
+  two   1 b {}
+}
+
+do_execsql_test 2.4 {
+  BEGIN;
+    DELETE FROM t1 WHERE rowid=1;
+    SELECT * FROM v1;
+  ROLLBACK;
+} {
+  five  2 b {}
+  four  2 a {}
+  four  2 b {}
+  three 2 a {}
+}
+
+do_execsql_test 2.5 {
+  DELETE FROM t1;
+  SELECT * FROM v1;
+} {}
+
+#-------------------------------------------------------------------------
+#
+do_execsql_test 3.0 {
+  DROP TABLE IF EXISTS t1;
+  DROP TABLE IF EXISTS v1;
+
+  CREATE VIRTUAL TABLE t1 USING fts5(a, b, detail=none);
+  CREATE VIRTUAL TABLE v1 USING fts5vocab(t1, instance);
+
+  INSERT INTO t1 VALUES('one two', 'two three');
+  INSERT INTO t1 VALUES('three four', 'four five five five');
+}
+
+do_execsql_test 3.1 {
+  SELECT * FROM v1;
+} {
+  five  2 {} {}
+  four  2 {} {}
+  one   1 {} {}
+  three 1 {} {}
+  three 2 {} {}
+  two   1 {} {}
+}
+
+do_execsql_test 3.2 {
+  SELECT * FROM v1 WHERE term='three';
+} {
+  three 1 {} {}
+  three 2 {} {}
+}
+
+do_execsql_test 3.3 {
+  BEGIN;
+    DELETE FROM t1 WHERE rowid=2;
+    SELECT * FROM v1;
+  ROLLBACK;
+} {
+  one   1 {} {}
+  three 1 {} {}
+  two   1 {} {}
+}
+
+do_execsql_test 3.4 {
+  BEGIN;
+    DELETE FROM t1 WHERE rowid=1;
+    SELECT * FROM v1;
+  ROLLBACK;
+} {
+  five  2 {} {}
+  four  2 {} {}
+  three 2 {} {}
+}
+
+do_execsql_test 3.5 {
+  DELETE FROM t1;
+  SELECT * FROM v1;
+} {}
+
+#-------------------------------------------------------------------------
+#
+reset_db
+do_execsql_test 4.0 {
+  CREATE VIRTUAL TABLE v1 USING fts5vocab(nosuchtable, col);
+}
+
+do_catchsql_test 4.1 {
+  SELECT * FROM v1 WHERE term=='nosuchterm';
+} {1 {no such fts5 table: main.nosuchtable}}
+
+do_execsql_test 4.2.1 {
+  CREATE TABLE nosuchtable(nosuchtable, y, z);
+}
+do_catchsql_test 4.2.2 {
+  SELECT * FROM v1 WHERE term=='nosuchterm';
+} {1 {no such fts5 table: main.nosuchtable}}
+
+ifcapable fts3 {
+  do_execsql_test 4.3.1 {
+    DROP TABLE nosuchtable;
+    CREATE VIRTUAL TABLE nosuchtable USING fts3(a, b);
+  } {}
+  do_catchsql_test 4.3.2 {
+    SELECT * FROM v1 WHERE term=='nosuchterm';
+  } {1 {no such fts5 table: main.nosuchtable}}
+  do_catchsql_test 4.3.3 {
+    INSERT INTO nosuchtable VALUES('id', '*id');
+    SELECT * FROM v1 WHERE term=='nosuchterm';
+  } {1 {no such fts5 table: main.nosuchtable}}
+}
+
+#-------------------------------------------------------------------------
+# Check that the fts5 table cannot be written while there are vocab 
+# cursors open.
+reset_db
+do_execsql_test 5.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(a);
+  CREATE VIRTUAL TABLE v1 USING fts5vocab(t1, instance);
+  INSERT INTO t1 VALUES('one'), ('two'), ('three'), ('four');
+}
+
+do_test 5.1 {
+  list [catch {
+    db eval { SELECT * FROM v1 } {
+      db eval {INSERT INTO t1 VALUES('five')}
+    }
+  } msg] $msg
+} {1 {query aborted}}
+
+do_execsql_test 5.2 {
+  SELECT * FROM t1
+} {one two three four five}
+
+#-------------------------------------------------------------------------
+# Check that the fts5 table cannot be written while there are vocab 
+# cursors open.
+reset_db
+do_execsql_test 5.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(a);
+  CREATE VIRTUAL TABLE v1 USING fts5vocab(t1, instance);
+  WITH s(i) AS (
+    VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<10000
+  )
+  INSERT INTO t1 SELECT 
+    'State Emergency Service (SES), Rural Fire Service (RFS) and Volunteers'
+  FROM s;
+}
+
+do_catchsql_test 5.1 {
+  INSERT INTO t1 SELECT rowid FROM v1
+} {1 {query aborted}}
+
+do_catchsql_test 5.2 {
+  DELETE FROM t1 WHERE rowid>100;
+  INSERT INTO t1 SELECT randomblob(3000) FROM v1
+} {1 {query aborted}}
+
+#-------------------------------------------------------------------------
+reset_db
+sqlite3_fts5_may_be_corrupt 1
+
+do_execsql_test 6.0 {
+  BEGIN TRANSACTION;
+    CREATE VIRTUAL TABLE t1 USING fts5(a,b unindexed,c,tokenize="porter ascii",tokendata=1);
+    REPLACE INTO t1_data VALUES(1,X'03090009');
+    REPLACE INTO t1_data VALUES(10,X'000000000103030003010101020101030101');
+    REPLACE INTO t1_data VALUES(137438953473,X'0000002e023061010202010162010203010163010204010167010601020201016801060102030101690106010204040606060808');
+    REPLACE INTO t1_data VALUES(274877906945,X'0000001f013067020802010202010168020803010203010169020804010204040909');
+    REPLACE INTO t1_data VALUES(412316860417,X'0000002e023061030202010162030203010163030204010167030601020201016803060102030101690306010204040606060808');
+  COMMIT;
+}
+
+do_execsql_test 6.1 {
+  CREATE VIRTUAL TABLE t3 USING fts5vocab('t1', 'row');
+}
+
+do_catchsql_test 6.2 {
+  SELECT * FROM t3;
+} {1 {database disk image is malformed}}
+
+sqlite3_fts5_may_be_corrupt 0
+
+finish_test
+
+

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/README

@@ -0,0 +1,40 @@
+
+
+Organization of test case files:
+
+  lsmtest1.c: Data tests. Tests that perform many inserts and deletes on a 
+              database file, then verify that the contents of the database can
+              be queried.
+
+  lsmtest2.c: Crash tests. Tests that attempt to verify that the database 
+              recovers correctly following an application or system crash.
+
+  lsmtest3.c: Rollback tests. Tests that focus on the explicit rollback of
+              transactions and sub-transactions.
+
+  lsmtest4.c: Multi-client tests.
+
+  lsmtest5.c: Multi-client tests with a different thread for each client.
+
+  lsmtest6.c: OOM injection tests.
+
+  lsmtest7.c: API tests.
+
+  lsmtest8.c: Writer crash tests. Tests in this file attempt to verify that
+              the system recovers and other clients proceed unaffected if
+              a process fails in the middle of a write transaction.
+
+              The difference from lsmtest2.c is that this file tests
+              live-recovery (recovery from a failure that occurs while other
+              clients are still running) whereas lsmtest2.c tests recovery
+              from a system or power failure.
+
+  lsmtest9.c: More data tests. These focus on testing that calling
+              lsm_work(nMerge=1) to compact the database does not corrupt it.
+              In other words, that databases containing block-redirects
+              can be read and written.
+
+
+
+
+

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest1.c

@@ -0,0 +1,656 @@
+
+#include "lsmtest.h"
+
+#define DATA_SEQUENTIAL TEST_DATASOURCE_SEQUENCE
+#define DATA_RANDOM     TEST_DATASOURCE_RANDOM
+
+typedef struct Datatest1 Datatest1;
+typedef struct Datatest2 Datatest2;
+
+/*
+** An instance of the following structure contains parameters used to
+** customize the test function in this file. Test procedure:
+**
+**   1. Create a data-source based on the "datasource definition" vars.
+**
+**   2. Insert nRow key value pairs into the database.
+**
+**   3. Delete all keys from the database. Deletes are done in the same 
+**      order as the inserts.
+**
+** During steps 2 and 3 above, after each Datatest1.nVerify inserts or
+** deletes, the following:
+**
+**   a. Run Datasource.nTest key lookups and check the results are as expected.
+**
+**   b. If Datasource.bTestScan is true, run a handful (8) of range
+**      queries (scanning forwards and backwards). Check that the results
+**      are as expected.
+**
+**   c. Close and reopen the database. Then run (a) and (b) again.
+*/
+struct Datatest1 {
+  /* Datasource definition */
+  DatasourceDefn defn;
+
+  /* Test procedure parameters */
+  int nRow;                       /* Number of rows to insert then delete */
+  int nVerify;                    /* How often to verify the db contents */
+  int nTest;                      /* Number of keys to test (0==all) */
+  int bTestScan;                  /* True to do scan tests */
+};
+
+/*
+** An instance of the following data structure is used to describe the
+** second type of test case in this file. The chief difference between 
+** these tests and those described by Datatest1 is that these tests also
+** experiment with range-delete operations. Tests proceed as follows:
+**
+**     1. Open the datasource described by Datatest2.defn. 
+**
+**     2. Open a connection on an empty database.
+**
+**     3. Do this Datatest2.nIter times:
+**
+**        a) Insert Datatest2.nWrite key-value pairs from the datasource.
+**
+**        b) Select two pseudo-random keys and use them as the start
+**           and end points of a range-delete operation.
+**
+**        c) Verify that the contents of the database are as expected (see
+**           below for details).
+**
+**        d) Close and then reopen the database handle.
+**
+**        e) Verify that the contents of the database are still as expected.
+**
+** The inserts and range deletes are run twice - once on the database being
+** tested and once using a control system (sqlite3, kc etc. - something that 
+** works). In order to verify that the contents of the db being tested are
+** correct, the test runs a bunch of scans and lookups on both the test and
+** control databases. If the results are the same, the test passes.
+*/
+struct Datatest2 {
+  DatasourceDefn defn;
+  int nRange;
+  int nWrite;                     /* Number of writes per iteration */
+  int nIter;                      /* Total number of iterations to run */
+};
+
+/*
+** Generate a unique name for the test case pTest with database system
+** zSystem.
+*/
+static char *getName(const char *zSystem, int bRecover, Datatest1 *pTest){
+  char *zRet;
+  char *zData;
+  zData = testDatasourceName(&pTest->defn);
+  zRet = testMallocPrintf("data.%s.%s.rec=%d.%d.%d", 
+      zSystem, zData, bRecover, pTest->nRow, pTest->nVerify
+  );
+  testFree(zData);
+  return zRet;
+}
+
+int testControlDb(TestDb **ppDb){
+#ifdef HAVE_KYOTOCABINET
+  return tdb_open("kyotocabinet", "tmp.db", 1, ppDb);
+#else
+  return tdb_open("sqlite3", "", 1, ppDb);
+#endif
+}
+
+void testDatasourceFetch(
+  TestDb *pDb,                    /* Database handle */
+  Datasource *pData,
+  int iKey,
+  int *pRc                        /* IN/OUT: Error code */
+){
+  void *pKey; int nKey;           /* Database key to query for */
+  void *pVal; int nVal;           /* Expected result of query */
+
+  testDatasourceEntry(pData, iKey, &pKey, &nKey, &pVal, &nVal);
+  testFetch(pDb, pKey, nKey, pVal, nVal, pRc);
+}
+
+/*
+** This function is called to test that the contents of database pDb
+** are as expected. In this case, expected is defined as containing
+** key-value pairs iFirst through iLast, inclusive, from data source 
+** pData. In other words, a loop like the following could be used to
+** construct a database with identical contents from scratch.
+**
+**   for(i=iFirst; i<=iLast; i++){
+**     testDatasourceEntry(pData, i, &pKey, &nKey, &pVal, &nVal);
+**     // insert (pKey, nKey) -> (pVal, nVal) into database
+**   }
+**
+** The key domain consists of keys 0 to (nRow-1), inclusive, from
+** data source pData. For both scan and lookup tests, keys are selected
+** pseudo-randomly from within this set.
+**
+** This function runs nLookupTest lookup tests and nScanTest scan tests.
+**
+** A lookup test consists of selecting a key from the domain and querying
+** pDb for it. The test fails if the presence of the key and, if present,
+** the associated value do not match the expectations defined above.
+**
+** A scan test involves selecting a key from the domain and running
+** the following queries:
+**
+**   1. Scan all keys equal to or greater than the key, in ascending order.
+**   2. Scan all keys equal to or smaller than the key, in descending order.
+**
+** Additionally, if nLookupTest is greater than zero, the following are
+** run once:
+**
+**   1. Scan all keys in the db, in ascending order.
+**   2. Scan all keys in the db, in descending order.
+**
+** As you would assume, the test fails if the returned values do not match
+** expectations.
+*/
+void testDbContents(
+  TestDb *pDb,                    /* Database handle being tested */
+  Datasource *pData,              /* pDb contains data from here */
+  int nRow,                       /* Size of key domain */
+  int iFirst,                     /* Index of first key from pData in pDb */
+  int iLast,                      /* Index of last key from pData in pDb */
+  int nLookupTest,                /* Number of lookup tests to run */
+  int nScanTest,                  /* Number of scan tests to run */
+  int *pRc                        /* IN/OUT: Error code */
+){
+  int j;
+  int rc = *pRc;
+
+  if( rc==0 && nScanTest ){
+    TestDb *pDb2 = 0;
+
+    /* Open a control db (i.e. one that we assume works) */
+    rc = testControlDb(&pDb2);
+
+    for(j=iFirst; rc==0 && j<=iLast; j++){
+      void *pKey; int nKey;         /* Database key to insert */
+      void *pVal; int nVal;         /* Database value to insert */
+      testDatasourceEntry(pData, j, &pKey, &nKey, &pVal, &nVal);
+      rc = tdb_write(pDb2, pKey, nKey, pVal, nVal);
+    }
+
+    if( rc==0 ){
+      int iKey1;
+      int iKey2;
+      void *pKey1; int nKey1;       /* Start key */
+      void *pKey2; int nKey2;       /* Final key */
+
+      iKey1 = testPrngValue((iFirst<<8) + (iLast<<16)) % nRow;
+      iKey2 = testPrngValue((iLast<<8) + (iFirst<<16)) % nRow;
+      testDatasourceEntry(pData, iKey1, &pKey2, &nKey1, 0, 0);
+      pKey1 = testMalloc(nKey1+1);
+      memcpy(pKey1, pKey2, nKey1+1);
+      testDatasourceEntry(pData, iKey2, &pKey2, &nKey2, 0, 0);
+
+      testScanCompare(pDb2, pDb, 0, 0, 0,         0, 0,         &rc);
+      testScanCompare(pDb2, pDb, 0, 0, 0,         pKey2, nKey2, &rc);
+      testScanCompare(pDb2, pDb, 0, pKey1, nKey1, 0, 0,         &rc);
+      testScanCompare(pDb2, pDb, 0, pKey1, nKey1, pKey2, nKey2, &rc);
+      testScanCompare(pDb2, pDb, 1, 0, 0,         0, 0,         &rc);
+      testScanCompare(pDb2, pDb, 1, 0, 0,         pKey2, nKey2, &rc);
+      testScanCompare(pDb2, pDb, 1, pKey1, nKey1, 0, 0,         &rc);
+      testScanCompare(pDb2, pDb, 1, pKey1, nKey1, pKey2, nKey2, &rc);
+      testFree(pKey1);
+    }
+    tdb_close(pDb2);
+  }
+
+  /* Test some lookups. */
+  for(j=0; rc==0 && j<nLookupTest; j++){
+    int iKey;                     /* Datasource key to test */
+    void *pKey; int nKey;         /* Database key to query for */
+    void *pVal; int nVal;         /* Expected result of query */
+
+    if( nLookupTest>=nRow ){
+      iKey = j;
+    }else{
+      iKey = testPrngValue(j + (iFirst<<8) + (iLast<<16)) % nRow;
+    }
+
+    testDatasourceEntry(pData, iKey, &pKey, &nKey, &pVal, &nVal);
+    if( iFirst>iKey || iKey>iLast ){
+      pVal = 0;
+      nVal = -1;
+    }
+
+    testFetch(pDb, pKey, nKey, pVal, nVal, &rc);
+  }
+
+  *pRc = rc;
+}
+
+/*
+** This function should be called during long running test cases to output
+** the progress dots (...) to stdout.
+*/
+void testCaseProgress(int i, int n, int nDot, int *piDot){
+  int iDot = *piDot;
+  while( iDot < ( ((nDot*2+1) * i) / (n*2) ) ){
+    printf(".");
+    fflush(stdout);
+    iDot++;
+  }
+  *piDot = iDot;
+}
+
+int testCaseNDot(void){ return 20; }
+
+#if 0
+static void printScanCb(
+    void *pCtx, void *pKey, int nKey, void *pVal, int nVal
+){
+  printf("%s\n", (char *)pKey);
+  fflush(stdout);
+}
+#endif
+
+void testReopenRecover(TestDb **ppDb, int *pRc){
+  if( *pRc==0 ){
+    const char *zLib = tdb_library_name(*ppDb);
+    const char *zDflt = tdb_default_db(zLib);
+    testCopyLsmdb(zDflt, "bak.db");
+    testClose(ppDb);
+    testCopyLsmdb("bak.db", zDflt);
+    *pRc = tdb_open(zLib, 0, 0, ppDb);
+  }
+}
+
+
+static void doDataTest1(
+  const char *zSystem,            /* Database system to test */
+  int bRecover,
+  Datatest1 *p,                   /* Structure containing test parameters */
+  int *pRc                        /* OUT: Error code */
+){
+  int i;
+  int iDot;
+  int rc = LSM_OK;
+  Datasource *pData;
+  TestDb *pDb;
+  int iToggle = 0;
+
+  /* Start the test case, open a database and allocate the datasource. */
+  pDb = testOpen(zSystem, 1, &rc);
+  pData = testDatasourceNew(&p->defn);
+
+  i = 0;
+  iDot = 0;
+  while( rc==LSM_OK && i<p->nRow ){
+
+    /* Insert some data */
+    testWriteDatasourceRange(pDb, pData, i, p->nVerify, &rc);
+    i += p->nVerify;
+
+    if( iToggle ) testBegin(pDb, 1, &rc);
+    /* Check that the db content is correct. */
+    testDbContents(pDb, pData, p->nRow, 0, i-1, p->nTest, p->bTestScan, &rc);
+    if( iToggle ) testCommit(pDb, 0, &rc);
+    iToggle = (iToggle+1)%2;
+
+    if( bRecover ){
+      testReopenRecover(&pDb, &rc);
+    }else{
+      testReopen(&pDb, &rc);
+    }
+
+    /* Check that the db content is still correct. */
+    testDbContents(pDb, pData, p->nRow, 0, i-1, p->nTest, p->bTestScan, &rc);
+
+    /* Update the progress dots... */
+    testCaseProgress(i, p->nRow, testCaseNDot()/2, &iDot);
+  }
+
+  i = 0;
+  iDot = 0;
+  while( rc==LSM_OK && i<p->nRow ){
+
+    /* Delete some entries */
+    testDeleteDatasourceRange(pDb, pData, i, p->nVerify, &rc);
+    i += p->nVerify;
+
+    /* Check that the db content is correct. */
+    testDbContents(pDb, pData, p->nRow, i, p->nRow-1,p->nTest,p->bTestScan,&rc);
+
+    /* Close and reopen the database. */
+    if( bRecover ){
+      testReopenRecover(&pDb, &rc);
+    }else{
+      testReopen(&pDb, &rc);
+    }
+
+    /* Check that the db content is still correct. */
+    testDbContents(pDb, pData, p->nRow, i, p->nRow-1,p->nTest,p->bTestScan,&rc);
+
+    /* Update the progress dots... */
+    testCaseProgress(i, p->nRow, testCaseNDot()/2, &iDot);
+  }
+
+  /* Free the datasource, close the database and finish the test case. */
+  testDatasourceFree(pData);
+  tdb_close(pDb);
+  testCaseFinish(rc);
+  *pRc = rc;
+}
+
+
+void test_data_1(
+  const char *zSystem,            /* Database system name */
+  const char *zPattern,           /* Run test cases that match this pattern */
+  int *pRc                        /* IN/OUT: Error code */
+){
+  Datatest1 aTest[] = {
+    { {DATA_RANDOM,     500,600,   1000,2000},     1000,  100,  10,  0},
+    { {DATA_RANDOM,     20,25,     100,200},       1000,  250, 1000, 1},
+    { {DATA_RANDOM,     8,10,      100,200},       1000,  250, 1000, 1},
+    { {DATA_RANDOM,     8,10,      10,20},         1000,  250, 1000, 1},
+    { {DATA_RANDOM,     8,10,      1000,2000},     1000,  250, 1000, 1},
+    { {DATA_RANDOM,     8,100,     10000,20000},    100,   25,  100, 1},
+    { {DATA_RANDOM,     80,100,    10,20},         1000,  250, 1000, 1},
+    { {DATA_RANDOM,     5000,6000, 10,20},          100,   25,  100, 1},
+    { {DATA_SEQUENTIAL, 5,10,      10,20},         1000,  250, 1000, 1},
+    { {DATA_SEQUENTIAL, 5,10,      100,200},       1000,  250, 1000, 1},
+    { {DATA_SEQUENTIAL, 5,10,      1000,2000},     1000,  250, 1000, 1},
+    { {DATA_SEQUENTIAL, 5,100,     10000,20000},    100,   25,  100, 1},
+    { {DATA_RANDOM,     10,10,     100,100},     100000, 1000,  100, 0},
+    { {DATA_SEQUENTIAL, 10,10,     100,100},     100000, 1000,  100, 0},
+  };
+
+  int i;
+  int bRecover;
+
+  for(bRecover=0; bRecover<2; bRecover++){
+    if( bRecover==1 && memcmp(zSystem, "lsm", 3) ) break;
+    for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){
+      char *zName = getName(zSystem, bRecover, &aTest[i]);
+      if( testCaseBegin(pRc, zPattern, "%s", zName) ){
+        doDataTest1(zSystem, bRecover, &aTest[i], pRc);
+      }
+      testFree(zName);
+    }
+  }
+}
+
+void testCompareDb(
+  Datasource *pData,
+  int nData,
+  int iSeed,
+  TestDb *pControl,
+  TestDb *pDb,
+  int *pRc
+){
+  int i;
+
+  static int nCall = 0;
+  nCall++;
+
+  testScanCompare(pControl, pDb, 0, 0, 0,         0, 0,         pRc);
+  testScanCompare(pControl, pDb, 1, 0, 0,         0, 0,         pRc);
+
+  if( *pRc==0 ){
+    int iKey1;
+    int iKey2;
+    void *pKey1; int nKey1;       /* Start key */
+    void *pKey2; int nKey2;       /* Final key */
+
+    iKey1 = testPrngValue(iSeed) % nData;
+    iKey2 = testPrngValue(iSeed+1) % nData;
+    testDatasourceEntry(pData, iKey1, &pKey2, &nKey1, 0, 0);
+    pKey1 = testMalloc(nKey1+1);
+    memcpy(pKey1, pKey2, nKey1+1);
+    testDatasourceEntry(pData, iKey2, &pKey2, &nKey2, 0, 0);
+
+    testScanCompare(pControl, pDb, 0, 0, 0,         pKey2, nKey2, pRc);
+    testScanCompare(pControl, pDb, 0, pKey1, nKey1, 0, 0,         pRc);
+    testScanCompare(pControl, pDb, 0, pKey1, nKey1, pKey2, nKey2, pRc);
+    testScanCompare(pControl, pDb, 1, 0, 0,         pKey2, nKey2, pRc);
+    testScanCompare(pControl, pDb, 1, pKey1, nKey1, 0, 0,         pRc);
+    testScanCompare(pControl, pDb, 1, pKey1, nKey1, pKey2, nKey2, pRc);
+    testFree(pKey1);
+  }
+
+  for(i=0; i<nData && *pRc==0; i++){
+    void *pKey; int nKey;
+    testDatasourceEntry(pData, i, &pKey, &nKey, 0, 0);
+    testFetchCompare(pControl, pDb, pKey, nKey, pRc);
+  }
+}
+
+static void doDataTest2(
+  const char *zSystem,            /* Database system to test */
+  int bRecover,
+  Datatest2 *p,                   /* Structure containing test parameters */
+  int *pRc                        /* OUT: Error code */
+){
+  TestDb *pDb;
+  TestDb *pControl;
+  Datasource *pData;
+  int i;
+  int rc = LSM_OK;
+  int iDot = 0;
+
+  /* Start the test case, open a database and allocate the datasource. */
+  pDb = testOpen(zSystem, 1, &rc);
+  pData = testDatasourceNew(&p->defn);
+  rc = testControlDb(&pControl);
+
+  if( tdb_lsm(pDb) ){
+    int nBuf = 32 * 1024 * 1024;
+    lsm_config(tdb_lsm(pDb), LSM_CONFIG_AUTOFLUSH, &nBuf);
+  }
+
+  for(i=0; rc==0 && i<p->nIter; i++){
+    void *pKey1; int nKey1;
+    void *pKey2; int nKey2;
+    int ii;
+    int nRange = MIN(p->nIter*p->nWrite, p->nRange);
+
+    for(ii=0; rc==0 && ii<p->nWrite; ii++){
+      int iKey = (i*p->nWrite + ii) % p->nRange;
+      testWriteDatasource(pControl, pData, iKey, &rc);
+      testWriteDatasource(pDb, pData, iKey, &rc);
+    }
+
+    testDatasourceEntry(pData, i+1000000, &pKey1, &nKey1, 0, 0);
+    pKey1 = testMallocCopy(pKey1, nKey1);
+    testDatasourceEntry(pData, i+2000000, &pKey2, &nKey2, 0, 0);
+
+    testDeleteRange(pDb, pKey1, nKey1, pKey2, nKey2, &rc);
+    testDeleteRange(pControl, pKey1, nKey1, pKey2, nKey2, &rc);
+    testFree(pKey1);
+
+    testCompareDb(pData, nRange, i, pControl, pDb, &rc);
+    if( bRecover ){
+      testReopenRecover(&pDb, &rc);
+    }else{
+      testReopen(&pDb, &rc);
+    }
+    testCompareDb(pData, nRange, i, pControl, pDb, &rc);
+
+    /* Update the progress dots... */
+    testCaseProgress(i, p->nIter, testCaseNDot(), &iDot);
+  }
+
+  testClose(&pDb);
+  testClose(&pControl);
+  testDatasourceFree(pData);
+  testCaseFinish(rc);
+  *pRc = rc;
+}
+
+static char *getName2(const char *zSystem, int bRecover, Datatest2 *pTest){
+  char *zRet;
+  char *zData;
+  zData = testDatasourceName(&pTest->defn);
+  zRet = testMallocPrintf("data2.%s.%s.rec=%d.%d.%d.%d", 
+      zSystem, zData, bRecover, pTest->nRange, pTest->nWrite, pTest->nIter
+  );
+  testFree(zData);
+  return zRet;
+}
+
+void test_data_2(
+  const char *zSystem,            /* Database system name */
+  const char *zPattern,           /* Run test cases that match this pattern */
+  int *pRc                        /* IN/OUT: Error code */
+){
+  Datatest2 aTest[] = {
+      /* defn,                                 nRange, nWrite, nIter */
+    { {DATA_RANDOM,     20,25,     100,200},   10000,  10,     50   },
+    { {DATA_RANDOM,     20,25,     100,200},   10000,  200,    50   },
+    { {DATA_RANDOM,     20,25,     100,200},   100,    10,     1000 },
+    { {DATA_RANDOM,     20,25,     100,200},   100,    200,    50   },
+  };
+
+  int i;
+  int bRecover;
+
+  for(bRecover=0; bRecover<2; bRecover++){
+    if( bRecover==1 && memcmp(zSystem, "lsm", 3) ) break;
+    for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){
+      char *zName = getName2(zSystem, bRecover, &aTest[i]);
+      if( testCaseBegin(pRc, zPattern, "%s", zName) ){
+        doDataTest2(zSystem, bRecover, &aTest[i], pRc);
+      }
+      testFree(zName);
+    }
+  }
+}
+
+/*************************************************************************
+** Test case data3.*
+*/
+
+typedef struct Datatest3 Datatest3;
+struct Datatest3 {
+  int nRange;                     /* Keys are between 1 and this value, incl. */
+  int nIter;                      /* Number of iterations */
+  int nWrite;                     /* Number of writes per iteration */
+  int nDelete;                    /* Number of deletes per iteration */
+
+  int nValMin;                    /* Minimum value size for writes */
+  int nValMax;                    /* Maximum value size for writes */
+};
+
+void testPutU32(u8 *aBuf, u32 iVal){
+  aBuf[0] = (iVal >> 24) & 0xFF;
+  aBuf[1] = (iVal >> 16) & 0xFF;
+  aBuf[2] = (iVal >>  8) & 0xFF;
+  aBuf[3] = (iVal >>  0) & 0xFF;
+}
+
+void dt3PutKey(u8 *aBuf, int iKey){
+  assert( iKey<100000 && iKey>=0 );
+  sprintf((char *)aBuf, "%.5d", iKey);
+}
+
+static void doDataTest3(
+  const char *zSystem,            /* Database system to test */
+  Datatest3 *p,                   /* Structure containing test parameters */
+  int *pRc                        /* OUT: Error code */
+){
+  int iDot = 0;
+  int rc = *pRc;
+  TestDb *pDb;
+  u8 *abPresent;                  /* Array of boolean */
+  char *aVal;                     /* Buffer to hold values */
+  int i;
+  u32 iSeq = 10;                  /* prng counter */
+
+  abPresent = (u8 *)testMalloc(p->nRange+1);
+  aVal = (char *)testMalloc(p->nValMax+1);
+  pDb = testOpen(zSystem, 1, &rc);
+
+  for(i=0; i<p->nIter && rc==0; i++){
+    int ii;
+
+    testCaseProgress(i, p->nIter, testCaseNDot(), &iDot);
+
+    /* Perform nWrite inserts */
+    for(ii=0; ii<p->nWrite; ii++){
+      u8 aKey[6];
+      u32 iKey;
+      int nVal;
+
+      iKey = (testPrngValue(iSeq++) % p->nRange) + 1;
+      nVal = (testPrngValue(iSeq++) % (p->nValMax - p->nValMin)) + p->nValMin;
+      testPrngString(testPrngValue(iSeq++), aVal, nVal);
+      dt3PutKey(aKey, iKey);
+
+      testWrite(pDb, aKey, sizeof(aKey)-1, aVal, nVal, &rc);
+      abPresent[iKey] = 1;
+    }
+
+    /* Perform nDelete deletes */
+    for(ii=0; ii<p->nDelete; ii++){
+      u8 aKey1[6];
+      u8 aKey2[6];
+      u32 iKey;
+
+      iKey = (testPrngValue(iSeq++) % p->nRange) + 1;
+      dt3PutKey(aKey1, iKey-1);
+      dt3PutKey(aKey2, iKey+1);
+
+      testDeleteRange(pDb, aKey1, sizeof(aKey1)-1, aKey2, sizeof(aKey2)-1, &rc);
+      abPresent[iKey] = 0;
+    }
+
+    testReopen(&pDb, &rc);
+
+    for(ii=1; rc==0 && ii<=p->nRange; ii++){
+      int nDbVal;
+      void *pDbVal;
+      u8 aKey[6];
+      int dbrc;
+
+      dt3PutKey(aKey, ii);
+      dbrc = tdb_fetch(pDb, aKey, sizeof(aKey)-1, &pDbVal, &nDbVal);
+      testCompareInt(0, dbrc, &rc);
+
+      if( abPresent[ii] ){
+        testCompareInt(1, (nDbVal>0), &rc);
+      }else{
+        testCompareInt(1, (nDbVal<0), &rc);
+      }
+    }
+  }
+
+  testClose(&pDb);
+  testCaseFinish(rc);
+  *pRc = rc;
+}
+
+static char *getName3(const char *zSystem, Datatest3 *p){
+  return testMallocPrintf("data3.%s.%d.%d.%d.%d.(%d..%d)",
+      zSystem, p->nRange, p->nIter, p->nWrite, p->nDelete, 
+      p->nValMin, p->nValMax
+  );
+}
+
+void test_data_3(
+  const char *zSystem,            /* Database system name */
+  const char *zPattern,           /* Run test cases that match this pattern */
+  int *pRc                        /* IN/OUT: Error code */
+){
+  Datatest3 aTest[] = {
+    /* nRange, nIter, nWrite, nDelete, nValMin, nValMax */
+    {  100,    1000,  5,      5,       50,      100 },
+    {  100,    1000,  2,      2,        5,       10 },
+  };
+
+  int i;
+
+  for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){
+    char *zName = getName3(zSystem, &aTest[i]);
+    if( testCaseBegin(pRc, zPattern, "%s", zName) ){
+      doDataTest3(zSystem, &aTest[i], pRc);
+    }
+    testFree(zName);
+  }
+}

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest4.c

@@ -0,0 +1,127 @@
+
+/*
+** This file contains test cases involving multiple database clients.
+*/
+
+#include "lsmtest.h"
+
+/*
+** The following code implements test cases "mc1.*".
+**
+** This test case uses one writer and $nReader readers. All connections
+** are driven by a single thread. All connections are opened at the start
+** of the test and remain open until the test is finished.
+**
+** The test consists of $nStep steps. Each step the following is performed:
+**
+**   1. The writer inserts $nWriteStep records into the db.
+**
+**   2. The writer checks that the contents of the db are as expected.
+**
+**   3. Each reader that currently has an open read transaction also checks
+**      that the contents of the db are as expected (according to the snapshot
+**      the read transaction is reading - see below).
+**
+** After step 1, reader 1 opens a read transaction. After step 2, reader
+** 2 opens a read transaction, and so on. At step ($nReader+1), reader 1
+** closes the current read transaction and opens a new one. And so on.
+** The result is that at step N (for N > $nReader), there exists a reader
+** with an open read transaction reading the snapshot committed following
+** steps (N-$nReader-1) to N. 
+*/
+typedef struct Mctest Mctest;
+struct Mctest {
+  DatasourceDefn defn;            /* Datasource to use */
+  int nStep;                      /* Total number of steps in test */
+  int nWriteStep;                 /* Number of rows to insert each step */
+  int nReader;                    /* Number of read connections */
+};
+static void do_mc_test(
+  const char *zSystem,            /* Database system to test */
+  Mctest *pTest,
+  int *pRc                        /* IN/OUT: return code */
+){
+  const int nDomain = pTest->nStep * pTest->nWriteStep;
+  Datasource *pData;              /* Source of data */
+  TestDb *pDb;                    /* First database connection (writer) */
+  int iReader;                    /* Used to iterate through aReader */
+  int iStep;                      /* Current step in test */
+  int iDot = 0;                   /* Current step in test */
+
+  /* Array of reader connections */
+  struct Reader {
+    TestDb *pDb;                  /* Connection handle */
+    int iLast;                    /* Current snapshot contains keys 0..iLast */
+  } *aReader;
+
+  /* Create a data source */
+  pData = testDatasourceNew(&pTest->defn);
+
+  /* Open the writer connection */
+  pDb = testOpen(zSystem, 1, pRc);
+
+  /* Allocate aReader */
+  aReader = (struct Reader *)testMalloc(sizeof(aReader[0]) * pTest->nReader);
+  for(iReader=0; iReader<pTest->nReader; iReader++){
+    aReader[iReader].pDb = testOpen(zSystem, 0, pRc);
+  }
+
+  for(iStep=0; iStep<pTest->nStep; iStep++){
+    int iLast;
+    int iBegin;                   /* Start read trans using aReader[iBegin] */
+
+    /* Insert nWriteStep more records into the database */
+    int iFirst = iStep*pTest->nWriteStep;
+    testWriteDatasourceRange(pDb, pData, iFirst, pTest->nWriteStep, pRc);
+
+    /* Check that the db is Ok according to the writer */
+    iLast = (iStep+1) * pTest->nWriteStep - 1;
+    testDbContents(pDb, pData, nDomain, 0, iLast, iLast, 1, pRc);
+
+    /* Have reader (iStep % nReader) open a read transaction here. */
+    iBegin = (iStep % pTest->nReader);
+    if( iBegin<iStep ) tdb_commit(aReader[iBegin].pDb, 0);
+    tdb_begin(aReader[iBegin].pDb, 1);
+    aReader[iBegin].iLast = iLast;
+
+    /* Check that the db is Ok for each open reader */
+    for(iReader=0; iReader<pTest->nReader && aReader[iReader].iLast; iReader++){
+      iLast = aReader[iReader].iLast;
+      testDbContents(
+          aReader[iReader].pDb, pData, nDomain, 0, iLast, iLast, 1, pRc
+      );
+    }
+
+    /* Report progress */
+    testCaseProgress(iStep, pTest->nStep, testCaseNDot(), &iDot);
+  }
+
+  /* Close all readers */
+  for(iReader=0; iReader<pTest->nReader; iReader++){
+    testClose(&aReader[iReader].pDb);
+  }
+  testFree(aReader);
+
+  /* Close the writer-connection and free the datasource */
+  testClose(&pDb);
+  testDatasourceFree(pData);
+}
+
+
+void test_mc(
+  const char *zSystem,            /* Database system name */
+  const char *zPattern,           /* Run test cases that match this pattern */
+  int *pRc                        /* IN/OUT: Error code */
+){
+  int i;
+  Mctest aTest[] = {
+    { { TEST_DATASOURCE_RANDOM, 10,10, 100,100 }, 100, 10, 5 },
+  };
+
+  for(i=0; i<ArraySize(aTest); i++){
+    if( testCaseBegin(pRc, zPattern, "mc1.%s.%d", zSystem, i) ){
+      do_mc_test(zSystem, &aTest[i], pRc);
+      testCaseFinish(*pRc);
+    }
+  }
+}

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest8.c

@@ -0,0 +1,324 @@
+
+/*
+** This file contains test cases to verify that "live-recovery" following
+** a mid-transaction failure of a writer process.
+*/
+
+
+/* 
+** This test file includes lsmInt.h to get access to the definition of the
+** ShmHeader structure. This is required to cause strategic damage to the
+** shared memory header as part of recovery testing.
+*/
+#include "lsmInt.h"
+
+#include "lsmtest.h"
+
+typedef struct SetupStep SetupStep;
+struct SetupStep {
+  int bFlush;                     /* Flush to disk and checkpoint */
+  int iInsStart;                  /* First key-value from ds to insert */
+  int nIns;                       /* Number of rows to insert */
+  int iDelStart;                  /* First key from ds to delete */
+  int nDel;                       /* Number of rows to delete */
+};
+
+static void doSetupStep(
+  TestDb *pDb, 
+  Datasource *pData, 
+  const SetupStep *pStep, 
+  int *pRc
+){
+  testWriteDatasourceRange(pDb, pData, pStep->iInsStart, pStep->nIns, pRc);
+  testDeleteDatasourceRange(pDb, pData, pStep->iDelStart, pStep->nDel, pRc);
+  if( *pRc==0 ){
+    int nSave = -1;
+    int nBuf = 64;
+    lsm_db *db = tdb_lsm(pDb);
+
+    lsm_config(db, LSM_CONFIG_AUTOFLUSH, &nSave);
+    lsm_config(db, LSM_CONFIG_AUTOFLUSH, &nBuf);
+    lsm_begin(db, 1);
+    lsm_commit(db, 0);
+    lsm_config(db, LSM_CONFIG_AUTOFLUSH, &nSave);
+
+    *pRc = lsm_work(db, 0, 0, 0);
+    if( *pRc==0 ){
+      *pRc = lsm_checkpoint(db, 0);
+    }
+  }
+}
+
+static void doSetupStepArray(
+  TestDb *pDb, 
+  Datasource *pData, 
+  const SetupStep *aStep, 
+  int nStep
+){
+  int i;
+  for(i=0; i<nStep; i++){
+    int rc = 0;
+    doSetupStep(pDb, pData, &aStep[i], &rc);
+    assert( rc==0 );
+  }
+}
+
+static void setupDatabase1(TestDb *pDb, Datasource **ppData){
+  const SetupStep aStep[] = {
+    { 0,                                  1,     2000, 0, 0 },
+    { 1,                                  0,     0, 0, 0 },
+    { 0,                                  10001, 1000, 0, 0 },
+  };
+  const DatasourceDefn defn = {TEST_DATASOURCE_RANDOM, 12, 16, 100, 500};
+  Datasource *pData;
+
+  pData = testDatasourceNew(&defn);
+  doSetupStepArray(pDb, pData, aStep, ArraySize(aStep));
+  if( ppData ){
+    *ppData = pData;
+  }else{
+    testDatasourceFree(pData);
+  }
+}
+
+#include <stdio.h>
+void testReadFile(const char *zFile, int iOff, void *pOut, int nByte, int *pRc){
+  if( *pRc==0 ){
+    FILE *fd;
+    fd = fopen(zFile, "rb");
+    if( fd==0 ){
+      *pRc = 1;
+    }else{
+      if( 0!=fseek(fd, iOff, SEEK_SET) ){
+        *pRc = 1;
+      }else{
+        assert( nByte>=0 );
+        if( (size_t)nByte!=fread(pOut, 1, nByte, fd) ){
+          *pRc = 1;
+        }
+      }
+      fclose(fd);
+    }
+  }
+}
+
+void testWriteFile(
+  const char *zFile, 
+  int iOff, 
+  void *pOut, 
+  int nByte, 
+  int *pRc
+){
+  if( *pRc==0 ){
+    FILE *fd;
+    fd = fopen(zFile, "r+b");
+    if( fd==0 ){
+      *pRc = 1;
+    }else{
+      if( 0!=fseek(fd, iOff, SEEK_SET) ){
+        *pRc = 1;
+      }else{
+        assert( nByte>=0 );
+        if( (size_t)nByte!=fwrite(pOut, 1, nByte, fd) ){
+          *pRc = 1;
+        }
+      }
+      fclose(fd);
+    }
+  }
+}
+
+static ShmHeader *getShmHeader(const char *zDb){
+  int rc = 0;
+  char *zShm = testMallocPrintf("%s-shm", zDb);
+  ShmHeader *pHdr;
+
+  pHdr = testMalloc(sizeof(ShmHeader));
+  testReadFile(zShm, 0, (void *)pHdr, sizeof(ShmHeader), &rc);
+  assert( rc==0 );
+
+  return pHdr;
+}
+
+/*
+** This function makes a copy of the three files associated with LSM 
+** database zDb (i.e. if zDb is "test.db", it makes copies of "test.db",
+** "test.db-log" and "test.db-shm").
+**
+** It then opens a new database connection to the copy with the xLock() call
+** instrumented so that it appears that some other process already connected
+** to the db (holding a shared lock on DMS2). This prevents recovery from
+** running. Then:
+**
+**    1) Check that the checksum of the database is zCksum. 
+**    2) Write a few keys to the database. Then delete the same keys. 
+**    3) Check that the checksum is zCksum.
+**    4) Flush the db to disk and run a checkpoint. 
+**    5) Check once more that the checksum is still zCksum.
+*/
+static void doLiveRecovery(const char *zDb, const char *zCksum, int *pRc){
+  if( *pRc==LSM_OK ){
+    const DatasourceDefn defn = {TEST_DATASOURCE_RANDOM, 20, 25, 100, 500};
+    Datasource *pData;
+    const char *zCopy = "testcopy.lsm";
+    char zCksum2[TEST_CKSUM_BYTES];
+    TestDb *pDb = 0;
+    int rc;
+
+    pData = testDatasourceNew(&defn);
+
+    testCopyLsmdb(zDb, zCopy);
+    rc = tdb_lsm_open("test_no_recovery=1", zCopy, 0, &pDb);
+    if( rc==0 ){
+      ShmHeader *pHdr;
+      lsm_db *db;
+      testCksumDatabase(pDb, zCksum2);
+      testCompareStr(zCksum, zCksum2, &rc);
+
+      testWriteDatasourceRange(pDb, pData, 1, 10, &rc);
+      testDeleteDatasourceRange(pDb, pData, 1, 10, &rc);
+
+      /* Test that the two tree-headers are now consistent. */
+      pHdr = getShmHeader(zCopy);
+      if( rc==0 && memcmp(&pHdr->hdr1, &pHdr->hdr2, sizeof(pHdr->hdr1)) ){
+        rc = 1;
+      }
+      testFree(pHdr);
+
+      if( rc==0 ){
+        int nBuf = 64;
+        db = tdb_lsm(pDb);
+        lsm_config(db, LSM_CONFIG_AUTOFLUSH, &nBuf);
+        lsm_begin(db, 1);
+        lsm_commit(db, 0);
+        rc = lsm_work(db, 0, 0, 0);
+      }
+
+      testCksumDatabase(pDb, zCksum2);
+      testCompareStr(zCksum, zCksum2, &rc);
+    }
+
+    testDatasourceFree(pData);
+    testClose(&pDb);
+    testDeleteLsmdb(zCopy);
+    *pRc = rc;
+  }
+}
+
+static void doWriterCrash1(int *pRc){
+  const int nWrite = 2000;
+  const int nStep = 10;
+  const int iWriteStart = 20000;
+  int rc = 0;
+  TestDb *pDb = 0;
+  Datasource *pData = 0;
+
+  rc = tdb_lsm_open("autowork=0", "testdb.lsm", 1, &pDb);
+  if( rc==0 ){
+    int iDot = 0;
+    char zCksum[TEST_CKSUM_BYTES];
+    int i;
+    setupDatabase1(pDb, &pData);
+    testCksumDatabase(pDb, zCksum);
+    testBegin(pDb, 2, &rc);
+    for(i=0; rc==0 && i<nWrite; i+=nStep){
+      testCaseProgress(i, nWrite, testCaseNDot(), &iDot);
+      testWriteDatasourceRange(pDb, pData, iWriteStart+i, nStep, &rc);
+      doLiveRecovery("testdb.lsm", zCksum, &rc);
+    }
+  }
+  testCommit(pDb, 0, &rc);
+  testClose(&pDb);
+  testDatasourceFree(pData);
+  *pRc = rc;
+}
+
+/*
+** This test case verifies that inconsistent tree-headers in shared-memory
+** are resolved correctly. 
+*/
+static void doWriterCrash2(int *pRc){
+  int rc = 0;
+  TestDb *pDb = 0;
+  Datasource *pData = 0;
+
+  rc = tdb_lsm_open("autowork=0", "testdb.lsm", 1, &pDb);
+  if( rc==0 ){
+    ShmHeader *pHdr1;
+    ShmHeader *pHdr2;
+    char zCksum1[TEST_CKSUM_BYTES];
+    char zCksum2[TEST_CKSUM_BYTES];
+
+    pHdr1 = testMalloc(sizeof(ShmHeader));
+    pHdr2 = testMalloc(sizeof(ShmHeader));
+    setupDatabase1(pDb, &pData);
+
+    /* Grab a copy of the shared-memory header. And the db checksum */
+    testReadFile("testdb.lsm-shm", 0, (void *)pHdr1, sizeof(ShmHeader), &rc);
+    testCksumDatabase(pDb, zCksum1);
+
+    /* Modify the database */
+    testBegin(pDb, 2, &rc);
+    testWriteDatasourceRange(pDb, pData, 30000, 200, &rc);
+    testCommit(pDb, 0, &rc);
+
+    /* Grab a second copy of the shared-memory header. And the db checksum */
+    testReadFile("testdb.lsm-shm", 0, (void *)pHdr2, sizeof(ShmHeader), &rc);
+    testCksumDatabase(pDb, zCksum2);
+    doLiveRecovery("testdb.lsm", zCksum2, &rc);
+
+    /* If both tree-headers are valid, tree-header-1 is used. */
+    memcpy(&pHdr2->hdr1, &pHdr1->hdr1, sizeof(pHdr1->hdr1));
+    pHdr2->bWriter = 1;
+    testWriteFile("testdb.lsm-shm", 0, (void *)pHdr2, sizeof(ShmHeader), &rc);
+    doLiveRecovery("testdb.lsm", zCksum1, &rc);
+
+    /* If both tree-headers are valid, tree-header-1 is used. */
+    memcpy(&pHdr2->hdr1, &pHdr2->hdr2, sizeof(pHdr1->hdr1));
+    memcpy(&pHdr2->hdr2, &pHdr1->hdr1, sizeof(pHdr1->hdr1));
+    pHdr2->bWriter = 1;
+    testWriteFile("testdb.lsm-shm", 0, (void *)pHdr2, sizeof(ShmHeader), &rc);
+    doLiveRecovery("testdb.lsm", zCksum2, &rc);
+
+    /* If tree-header 1 is invalid, tree-header-2 is used */
+    memcpy(&pHdr2->hdr2, &pHdr2->hdr1, sizeof(pHdr1->hdr1));
+    pHdr2->hdr1.aCksum[0] = 5;
+    pHdr2->hdr1.aCksum[0] = 6;
+    pHdr2->bWriter = 1;
+    testWriteFile("testdb.lsm-shm", 0, (void *)pHdr2, sizeof(ShmHeader), &rc);
+    doLiveRecovery("testdb.lsm", zCksum2, &rc);
+
+    /* If tree-header 2 is invalid, tree-header-1 is used */
+    memcpy(&pHdr2->hdr1, &pHdr2->hdr2, sizeof(pHdr1->hdr1));
+    pHdr2->hdr2.aCksum[0] = 5;
+    pHdr2->hdr2.aCksum[0] = 6;
+    pHdr2->bWriter = 1;
+    testWriteFile("testdb.lsm-shm", 0, (void *)pHdr2, sizeof(ShmHeader), &rc);
+    doLiveRecovery("testdb.lsm", zCksum2, &rc);
+
+    testFree(pHdr1);
+    testFree(pHdr2);
+    testClose(&pDb);
+  }
+
+  *pRc = rc;
+}
+
+void do_writer_crash_test(const char *zPattern, int *pRc){
+  struct Test {
+    const char *zName;
+    void (*xFunc)(int *);
+  } aTest[] = {
+    { "writercrash1.lsm", doWriterCrash1 },
+    { "writercrash2.lsm", doWriterCrash2 },
+  };
+  int i;
+  for(i=0; i<ArraySize(aTest); i++){
+    struct Test *p = &aTest[i];
+    if( testCaseBegin(pRc, zPattern, p->zName) ){
+      p->xFunc(pRc);
+      testCaseFinish(*pRc);
+    }
+  }
+
+}

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest9.c

@@ -0,0 +1,140 @@
+
+#include "lsmtest.h"
+
+#define DATA_SEQUENTIAL TEST_DATASOURCE_SEQUENCE
+#define DATA_RANDOM     TEST_DATASOURCE_RANDOM
+
+typedef struct Datatest4 Datatest4;
+
+/*
+** Test overview:
+**
+**   1. Insert (Datatest4.nRec) records into a database.
+**
+**   2. Repeat (Datatest4.nRepeat) times:
+**
+**      2a. Delete 2/3 of the records in the database.
+**
+**      2b. Run lsm_work(nMerge=1).
+**
+**      2c. Insert as many records as were deleted in 2a.
+**
+**      2d. Check database content is as expected.
+**
+**      2e. If (Datatest4.bReopen) is true, close and reopen the database.
+*/
+struct Datatest4 {
+  /* Datasource definition */
+  DatasourceDefn defn;
+
+  int nRec;
+  int nRepeat;
+  int bReopen;
+};
+
+static void doDataTest4(
+  const char *zSystem,            /* Database system to test */
+  Datatest4 *p,                   /* Structure containing test parameters */
+  int *pRc                        /* OUT: Error code */
+){
+  lsm_db *db = 0;
+  TestDb *pDb;
+  TestDb *pControl;
+  Datasource *pData;
+  int i;
+  int rc = 0;
+  int iDot = 0;
+  int bMultiThreaded = 0;         /* True for MT LSM database */
+
+  int nRecOn3 = (p->nRec / 3);
+  int iData = 0;
+
+  /* Start the test case, open a database and allocate the datasource. */
+  rc = testControlDb(&pControl);
+  pDb = testOpen(zSystem, 1, &rc);
+  pData = testDatasourceNew(&p->defn);
+  if( rc==0 ){
+    db = tdb_lsm(pDb);
+    bMultiThreaded = tdb_lsm_multithread(pDb);
+  }
+
+  testWriteDatasourceRange(pControl, pData, iData, nRecOn3*3, &rc);
+  testWriteDatasourceRange(pDb,      pData, iData, nRecOn3*3, &rc);
+
+  for(i=0; rc==0 && i<p->nRepeat; i++){
+
+    testDeleteDatasourceRange(pControl, pData, iData, nRecOn3*2, &rc);
+    testDeleteDatasourceRange(pDb,      pData, iData, nRecOn3*2, &rc);
+
+    if( db ){
+      int nDone;
+#if 0
+      fprintf(stderr, "lsm_work() start...\n"); fflush(stderr);
+#endif
+      do {
+        nDone = 0;
+        rc = lsm_work(db, 1, (1<<30), &nDone);
+      }while( rc==0 && nDone>0 );
+      if( bMultiThreaded && rc==LSM_BUSY ) rc = LSM_OK;
+#if 0 
+      fprintf(stderr, "lsm_work() done...\n"); fflush(stderr);
+#endif
+    }
+
+if( i+1<p->nRepeat ){
+    iData += (nRecOn3*2);
+    testWriteDatasourceRange(pControl, pData, iData+nRecOn3, nRecOn3*2, &rc);
+    testWriteDatasourceRange(pDb,      pData, iData+nRecOn3, nRecOn3*2, &rc);
+
+    testCompareDb(pData, nRecOn3*3, iData, pControl, pDb, &rc);
+
+    /* If Datatest4.bReopen is true, close and reopen the database */
+    if( p->bReopen ){
+      testReopen(&pDb, &rc);
+      if( rc==0 ) db = tdb_lsm(pDb);
+    }
+}
+
+    /* Update the progress dots... */
+    testCaseProgress(i, p->nRepeat, testCaseNDot(), &iDot);
+  }
+
+  testClose(&pDb);
+  testClose(&pControl);
+  testDatasourceFree(pData);
+  testCaseFinish(rc);
+  *pRc = rc;
+}
+
+static char *getName4(const char *zSystem, Datatest4 *pTest){
+  char *zRet;
+  char *zData;
+  zData = testDatasourceName(&pTest->defn);
+  zRet = testMallocPrintf("data4.%s.%s.%d.%d.%d", 
+      zSystem, zData, pTest->nRec, pTest->nRepeat, pTest->bReopen
+  );
+  testFree(zData);
+  return zRet;
+}
+
+void test_data_4(
+  const char *zSystem,            /* Database system name */
+  const char *zPattern,           /* Run test cases that match this pattern */
+  int *pRc                        /* IN/OUT: Error code */
+){
+  Datatest4 aTest[] = {
+      /* defn,                                 nRec, nRepeat, bReopen */
+    { {DATA_RANDOM,     20,25,     500,600}, 10000,      10,       0   },
+    { {DATA_RANDOM,     20,25,     500,600}, 10000,      10,       1   },
+  };
+
+  int i;
+
+  for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){
+    char *zName = getName4(zSystem, &aTest[i]);
+    if( testCaseBegin(pRc, zPattern, "%s", zName) ){
+      doDataTest4(zSystem, &aTest[i], pRc);
+    }
+    testFree(zName);
+  }
+}

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest_func.c

@@ -0,0 +1,177 @@
+
+#include "lsmtest.h"
+
+
+int do_work(int nArg, char **azArg){
+  struct Option {
+    const char *zName;
+  } aOpt [] = {
+    { "-nmerge" },
+    { "-nkb" },
+    { 0 }
+  };
+
+  lsm_db *pDb;
+  int rc;
+  int i;
+  const char *zDb;
+  int nMerge = 1;
+  int nKB = (1<<30);
+
+  if( nArg==0 ) goto usage;
+  zDb = azArg[nArg-1];
+  for(i=0; i<(nArg-1); i++){
+    int iSel;
+    rc = testArgSelect(aOpt, "option", azArg[i], &iSel);
+    if( rc ) return rc;
+    switch( iSel ){
+      case 0:
+        i++;
+        if( i==(nArg-1) ) goto usage;
+        nMerge = atoi(azArg[i]);
+        break;
+      case 1:
+        i++;
+        if( i==(nArg-1) ) goto usage;
+        nKB = atoi(azArg[i]);
+        break;
+    }
+  }
+
+  rc = lsm_new(0, &pDb);
+  if( rc!=LSM_OK ){
+    testPrintError("lsm_open(): rc=%d\n", rc);
+  }else{
+    rc = lsm_open(pDb, zDb);
+    if( rc!=LSM_OK ){
+      testPrintError("lsm_open(): rc=%d\n", rc);
+    }else{
+      int n = -1;
+      lsm_config(pDb, LSM_CONFIG_BLOCK_SIZE, &n);
+      n = n*2;
+      lsm_config(pDb, LSM_CONFIG_AUTOCHECKPOINT, &n);
+
+      rc = lsm_work(pDb, nMerge, nKB, 0);
+      if( rc!=LSM_OK ){
+        testPrintError("lsm_work(): rc=%d\n", rc);
+      }
+    }
+  }
+  if( rc==LSM_OK ){
+    rc = lsm_checkpoint(pDb, 0);
+  }
+
+  lsm_close(pDb);
+  return rc;
+
+ usage:
+  testPrintUsage("?-optimize? ?-n N? DATABASE");
+  return -1;
+}
+
+
+/*
+**   lsmtest show ?-config LSM-CONFIG? DATABASE ?COMMAND ?PGNO??
+*/
+int do_show(int nArg, char **azArg){
+  lsm_db *pDb;
+  int rc;
+  const char *zDb;
+
+  int eOpt = LSM_INFO_DB_STRUCTURE;
+  unsigned int iPg = 0;
+  int bConfig = 0;
+  const char *zConfig = "";
+
+  struct Option {
+    const char *zName;
+    int bConfig;
+    int eOpt;
+  } aOpt [] = { 
+    { "array",       0, LSM_INFO_ARRAY_STRUCTURE },
+    { "array-pages", 0, LSM_INFO_ARRAY_PAGES },
+    { "blocksize",   1, LSM_CONFIG_BLOCK_SIZE },
+    { "pagesize",    1, LSM_CONFIG_PAGE_SIZE },
+    { "freelist",    0, LSM_INFO_FREELIST },
+    { "page-ascii",  0, LSM_INFO_PAGE_ASCII_DUMP },
+    { "page-hex",    0, LSM_INFO_PAGE_HEX_DUMP },
+    { 0, 0 } 
+  };
+
+  char *z = 0; 
+  int iDb = 0;                    /* Index of DATABASE in azArg[] */
+
+  /* Check if there is a "-config" option: */
+  if( nArg>2 && strlen(azArg[0])>1 
+   && memcmp(azArg[0], "-config", strlen(azArg[0]))==0
+  ){
+    zConfig = azArg[1];
+    iDb = 2;
+  }
+  if( nArg<(iDb+1) ) goto usage;
+
+  if( nArg>(iDb+1) ){
+    rc = testArgSelect(aOpt, "option", azArg[iDb+1], &eOpt);
+    if( rc!=0 ) return rc;
+    bConfig = aOpt[eOpt].bConfig;
+    eOpt = aOpt[eOpt].eOpt;
+    if( (bConfig==0 && eOpt==LSM_INFO_FREELIST)
+     || (bConfig==1 && eOpt==LSM_CONFIG_BLOCK_SIZE)
+     || (bConfig==1 && eOpt==LSM_CONFIG_PAGE_SIZE)
+    ){
+      if( nArg!=(iDb+2) ) goto usage;
+    }else{
+      if( nArg!=(iDb+3) ) goto usage;
+      iPg = atoi(azArg[iDb+2]);
+    }
+  }
+  zDb = azArg[iDb];
+
+  rc = lsm_new(0, &pDb);
+  tdb_lsm_configure(pDb, zConfig);
+  if( rc!=LSM_OK ){
+    testPrintError("lsm_new(): rc=%d\n", rc);
+  }else{
+    rc = lsm_open(pDb, zDb);
+    if( rc!=LSM_OK ){
+      testPrintError("lsm_open(): rc=%d\n", rc);
+    }
+  }
+
+  if( rc==LSM_OK ){
+    if( bConfig==0 ){
+      switch( eOpt ){
+        case LSM_INFO_DB_STRUCTURE:
+        case LSM_INFO_FREELIST:
+          rc = lsm_info(pDb, eOpt, &z);
+          break;
+        case LSM_INFO_ARRAY_STRUCTURE:
+        case LSM_INFO_ARRAY_PAGES:
+        case LSM_INFO_PAGE_ASCII_DUMP:
+        case LSM_INFO_PAGE_HEX_DUMP:
+          rc = lsm_info(pDb, eOpt, iPg, &z);
+          break;
+        default:
+          assert( !"no chance" );
+      }
+
+      if( rc==LSM_OK ){
+        printf("%s\n", z ? z : "");
+        fflush(stdout);
+      }
+      lsm_free(lsm_get_env(pDb), z);
+    }else{
+      int iRes = -1;
+      lsm_config(pDb, eOpt, &iRes);
+      printf("%d\n", iRes);
+      fflush(stdout);
+    }
+  }
+
+  lsm_close(pDb);
+  return rc;
+
+ usage:
+  testPrintUsage("DATABASE ?array|page-ascii|page-hex PGNO?");
+  return -1;
+}

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest_mem.c

@@ -0,0 +1,409 @@
+
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+
+#define ArraySize(x) ((int)(sizeof(x) / sizeof((x)[0])))
+
+#define MIN(x,y) ((x)<(y) ? (x) : (y))
+
+typedef unsigned int  u32;
+typedef unsigned char u8;
+typedef long long int i64;
+typedef unsigned long long int u64;
+
+#if defined(__GLIBC__) && defined(LSM_DEBUG_MEM)
+  extern int backtrace(void**,int);
+  extern void backtrace_symbols_fd(void*const*,int,int);
+# define TM_BACKTRACE 12
+#else
+# define backtrace(A,B) 1
+# define backtrace_symbols_fd(A,B,C)
+#endif
+
+
+typedef struct TmBlockHdr TmBlockHdr;
+typedef struct TmAgg TmAgg;
+typedef struct TmGlobal TmGlobal;
+
+struct TmGlobal {
+  /* Linked list of all currently outstanding allocations. And a table of
+  ** all allocations, past and present, indexed by backtrace() info.  */
+  TmBlockHdr *pFirst;
+#ifdef TM_BACKTRACE
+  TmAgg *aHash[10000];
+#endif
+
+  /* Underlying malloc/realloc/free functions */
+  void *(*xMalloc)(int);          /* underlying malloc(3) function */
+  void *(*xRealloc)(void *, int); /* underlying realloc(3) function */
+  void (*xFree)(void *);          /* underlying free(3) function */
+
+  /* Mutex to protect pFirst and aHash */
+  void (*xEnterMutex)(TmGlobal*); /* Call this to enter the mutex */
+  void (*xLeaveMutex)(TmGlobal*); /* Call this to leave mutex */
+  void (*xDelMutex)(TmGlobal*);   /* Call this to delete mutex */
+  void *pMutex;                   /* Mutex handle */
+
+  void *(*xSaveMalloc)(void *, size_t);
+  void *(*xSaveRealloc)(void *, void *, size_t);
+  void (*xSaveFree)(void *, void *);
+
+  /* OOM injection scheduling. If nCountdown is greater than zero when a 
+  ** malloc attempt is made, it is decremented. If this means nCountdown 
+  ** transitions from 1 to 0, then the allocation fails. If bPersist is true 
+  ** when this happens, nCountdown is then incremented back to 1 (so that the 
+  ** next attempt fails too).  
+  */
+  int nCountdown;
+  int bPersist;
+  int bEnable;
+  void (*xHook)(void *);
+  void *pHookCtx;
+};
+
+struct TmBlockHdr {
+  TmBlockHdr *pNext;
+  TmBlockHdr *pPrev;
+  int nByte;
+#ifdef TM_BACKTRACE
+  TmAgg *pAgg;
+#endif
+  u32 iForeGuard;
+};
+
+#ifdef TM_BACKTRACE
+struct TmAgg {
+  int nAlloc;                     /* Number of allocations at this path */
+  int nByte;                      /* Total number of bytes allocated */
+  int nOutAlloc;                  /* Number of outstanding allocations */
+  int nOutByte;                   /* Number of outstanding bytes */
+  void *aFrame[TM_BACKTRACE];     /* backtrace() output */
+  TmAgg *pNext;                   /* Next object in hash-table collision */
+};
+#endif
+
+#define FOREGUARD 0x80F5E153
+#define REARGUARD 0xE4676B53
+static const u32 rearguard = REARGUARD;
+
+#define ROUND8(x) (((x)+7)&~7)
+
+#define BLOCK_HDR_SIZE (ROUND8( sizeof(TmBlockHdr) ))
+
+static void lsmtest_oom_error(void){
+  static int nErr = 0;
+  nErr++;
+}
+
+static void tmEnterMutex(TmGlobal *pTm){
+  pTm->xEnterMutex(pTm);
+}
+static void tmLeaveMutex(TmGlobal *pTm){
+  pTm->xLeaveMutex(pTm);
+}
+
+static void *tmMalloc(TmGlobal *pTm, int nByte){
+  TmBlockHdr *pNew;               /* New allocation header block */
+  u8 *pUser;                      /* Return value */
+  int nReq;                       /* Total number of bytes requested */
+
+  assert( sizeof(rearguard)==4 );
+  nReq = BLOCK_HDR_SIZE + nByte + 4;
+  pNew = (TmBlockHdr *)pTm->xMalloc(nReq);
+  memset(pNew, 0, sizeof(TmBlockHdr));
+
+  tmEnterMutex(pTm);
+  assert( pTm->nCountdown>=0 );
+  assert( pTm->bPersist==0 || pTm->bPersist==1 );
+
+  if( pTm->bEnable && pTm->nCountdown==1 ){
+    /* Simulate an OOM error. */
+    lsmtest_oom_error();
+    pTm->xFree(pNew);
+    pTm->nCountdown = pTm->bPersist;
+    if( pTm->xHook ) pTm->xHook(pTm->pHookCtx);
+    pUser = 0;
+  }else{
+    if( pTm->bEnable && pTm->nCountdown ) pTm->nCountdown--;
+
+    pNew->iForeGuard = FOREGUARD;
+    pNew->nByte = nByte;
+    pNew->pNext = pTm->pFirst;
+
+    if( pTm->pFirst ){
+      pTm->pFirst->pPrev = pNew;
+    }
+    pTm->pFirst = pNew;
+
+    pUser = &((u8 *)pNew)[BLOCK_HDR_SIZE];
+    memset(pUser, 0x56, nByte);
+    memcpy(&pUser[nByte], &rearguard, 4);
+
+#ifdef TM_BACKTRACE
+    {
+      TmAgg *pAgg;
+      int i;
+      u32 iHash = 0;
+      void *aFrame[TM_BACKTRACE];
+      memset(aFrame, 0, sizeof(aFrame));
+      backtrace(aFrame, TM_BACKTRACE);
+
+      for(i=0; i<ArraySize(aFrame); i++){
+        iHash += (u64)(aFrame[i]) + (iHash<<3);
+      }
+      iHash = iHash % ArraySize(pTm->aHash);
+
+      for(pAgg=pTm->aHash[iHash]; pAgg; pAgg=pAgg->pNext){
+        if( memcmp(pAgg->aFrame, aFrame, sizeof(aFrame))==0 ) break;
+      }
+      if( !pAgg ){
+        pAgg = (TmAgg *)pTm->xMalloc(sizeof(TmAgg));
+        memset(pAgg, 0, sizeof(TmAgg));
+        memcpy(pAgg->aFrame, aFrame, sizeof(aFrame));
+        pAgg->pNext = pTm->aHash[iHash];
+        pTm->aHash[iHash] = pAgg;
+      }
+      pAgg->nAlloc++;
+      pAgg->nByte += nByte;
+      pAgg->nOutAlloc++;
+      pAgg->nOutByte += nByte;
+      pNew->pAgg = pAgg;
+    }
+#endif
+  }
+
+  tmLeaveMutex(pTm);
+  return pUser;
+}
+
+static void tmFree(TmGlobal *pTm, void *p){
+  if( p ){
+    TmBlockHdr *pHdr;
+    u8 *pUser = (u8 *)p;
+
+    tmEnterMutex(pTm);
+    pHdr = (TmBlockHdr *)(pUser - BLOCK_HDR_SIZE);
+    assert( pHdr->iForeGuard==FOREGUARD );
+    assert( 0==memcmp(&pUser[pHdr->nByte], &rearguard, 4) );
+
+    if( pHdr->pPrev ){
+      assert( pHdr->pPrev->pNext==pHdr );
+      pHdr->pPrev->pNext = pHdr->pNext;
+    }else{
+      assert( pHdr==pTm->pFirst );
+      pTm->pFirst = pHdr->pNext;
+    }
+    if( pHdr->pNext ){
+      assert( pHdr->pNext->pPrev==pHdr );
+      pHdr->pNext->pPrev = pHdr->pPrev;
+    }
+
+#ifdef TM_BACKTRACE
+    pHdr->pAgg->nOutAlloc--;
+    pHdr->pAgg->nOutByte -= pHdr->nByte;
+#endif
+
+    tmLeaveMutex(pTm);
+    memset(pUser, 0x58, pHdr->nByte);
+    memset(pHdr, 0x57, sizeof(TmBlockHdr));
+    pTm->xFree(pHdr);
+  }
+}
+
+static void *tmRealloc(TmGlobal *pTm, void *p, int nByte){
+  void *pNew;
+
+  pNew = tmMalloc(pTm, nByte);
+  if( pNew && p ){
+    TmBlockHdr *pHdr;
+    u8 *pUser = (u8 *)p;
+    pHdr = (TmBlockHdr *)(pUser - BLOCK_HDR_SIZE);
+    memcpy(pNew, p, MIN(nByte, pHdr->nByte));
+    tmFree(pTm, p);
+  }
+  return pNew;
+}
+
+static void tmMallocOom(
+  TmGlobal *pTm, 
+  int nCountdown, 
+  int bPersist,
+  void (*xHook)(void *),
+  void *pHookCtx
+){
+  assert( nCountdown>=0 );
+  assert( bPersist==0 || bPersist==1 );
+  pTm->nCountdown = nCountdown;
+  pTm->bPersist = bPersist;
+  pTm->xHook = xHook;
+  pTm->pHookCtx = pHookCtx;
+  pTm->bEnable = 1;
+}
+
+static void tmMallocOomEnable(
+  TmGlobal *pTm, 
+  int bEnable
+){
+  pTm->bEnable = bEnable;
+}
+
+static void tmMallocCheck(
+  TmGlobal *pTm,
+  int *pnLeakAlloc,
+  int *pnLeakByte,
+  FILE *pFile
+){
+  TmBlockHdr *pHdr;
+  int nLeak = 0;
+  int nByte = 0;
+
+  if( pTm==0 ) return;
+
+  for(pHdr=pTm->pFirst; pHdr; pHdr=pHdr->pNext){
+    nLeak++; 
+    nByte += pHdr->nByte;
+  }
+  if( pnLeakAlloc ) *pnLeakAlloc = nLeak;
+  if( pnLeakByte ) *pnLeakByte = nByte;
+
+#ifdef TM_BACKTRACE
+  if( pFile ){
+    int i;
+    fprintf(pFile, "LEAKS\n");
+    for(i=0; i<ArraySize(pTm->aHash); i++){
+      TmAgg *pAgg;
+      for(pAgg=pTm->aHash[i]; pAgg; pAgg=pAgg->pNext){
+        if( pAgg->nOutAlloc ){
+          int j;
+          fprintf(pFile, "%d %d ", pAgg->nOutByte, pAgg->nOutAlloc);
+          for(j=0; j<TM_BACKTRACE; j++){
+            fprintf(pFile, "%p ", pAgg->aFrame[j]);
+          }
+          fprintf(pFile, "\n");
+        }
+      }
+    }
+    fprintf(pFile, "\nALLOCATIONS\n");
+    for(i=0; i<ArraySize(pTm->aHash); i++){
+      TmAgg *pAgg;
+      for(pAgg=pTm->aHash[i]; pAgg; pAgg=pAgg->pNext){
+        int j;
+        fprintf(pFile, "%d %d ", pAgg->nByte, pAgg->nAlloc);
+        for(j=0; j<TM_BACKTRACE; j++) fprintf(pFile, "%p ", pAgg->aFrame[j]);
+        fprintf(pFile, "\n");
+      }
+    }
+  }
+#else
+  (void)pFile;
+#endif
+}
+
+
+#include "lsm.h"
+#include "stdlib.h"
+
+typedef struct LsmMutex LsmMutex;
+struct LsmMutex {
+  lsm_env *pEnv;
+  lsm_mutex *pMutex;
+};
+
+static void tmLsmMutexEnter(TmGlobal *pTm){
+  LsmMutex *p = (LsmMutex *)pTm->pMutex;
+  p->pEnv->xMutexEnter(p->pMutex);
+}
+static void tmLsmMutexLeave(TmGlobal *pTm){
+  LsmMutex *p = (LsmMutex *)(pTm->pMutex);
+  p->pEnv->xMutexLeave(p->pMutex);
+}
+static void tmLsmMutexDel(TmGlobal *pTm){
+  LsmMutex *p = (LsmMutex *)pTm->pMutex;
+  pTm->xFree(p);
+}
+static void *tmLsmMalloc(int n){ return malloc(n); }
+static void tmLsmFree(void *ptr){ free(ptr); }
+static void *tmLsmRealloc(void *ptr, int n){ return realloc(ptr, n); }
+
+static void *tmLsmEnvMalloc(lsm_env *p, size_t n){ 
+  return tmMalloc((TmGlobal *)(p->pMemCtx), n); 
+}
+static void tmLsmEnvFree(lsm_env *p, void *ptr){ 
+  tmFree((TmGlobal *)(p->pMemCtx), ptr); 
+}
+static void *tmLsmEnvRealloc(lsm_env *p, void *ptr, size_t n){ 
+  return tmRealloc((TmGlobal *)(p->pMemCtx), ptr, n);
+}
+
+void testMallocInstall(lsm_env *pEnv){
+  TmGlobal *pGlobal;
+  LsmMutex *pMutex;
+  assert( pEnv->pMemCtx==0 );
+
+  /* Allocate and populate a TmGlobal structure. */
+  pGlobal = (TmGlobal *)tmLsmMalloc(sizeof(TmGlobal));
+  memset(pGlobal, 0, sizeof(TmGlobal));
+  pGlobal->xMalloc = tmLsmMalloc;
+  pGlobal->xRealloc = tmLsmRealloc;
+  pGlobal->xFree = tmLsmFree;
+  pMutex = (LsmMutex *)pGlobal->xMalloc(sizeof(LsmMutex));
+  pMutex->pEnv = pEnv;
+  pEnv->xMutexStatic(pEnv, LSM_MUTEX_HEAP, &pMutex->pMutex);
+  pGlobal->xEnterMutex = tmLsmMutexEnter;
+  pGlobal->xLeaveMutex = tmLsmMutexLeave;
+  pGlobal->xDelMutex = tmLsmMutexDel;
+  pGlobal->pMutex = (void *)pMutex;
+
+  pGlobal->xSaveMalloc = pEnv->xMalloc;
+  pGlobal->xSaveRealloc = pEnv->xRealloc;
+  pGlobal->xSaveFree = pEnv->xFree;
+
+  /* Set up pEnv to the use the new TmGlobal */
+  pEnv->pMemCtx = (void *)pGlobal;
+  pEnv->xMalloc = tmLsmEnvMalloc;
+  pEnv->xRealloc = tmLsmEnvRealloc;
+  pEnv->xFree = tmLsmEnvFree;
+}
+
+void testMallocUninstall(lsm_env *pEnv){
+  TmGlobal *p = (TmGlobal *)pEnv->pMemCtx;
+  pEnv->pMemCtx = 0;
+  if( p ){
+    pEnv->xMalloc = p->xSaveMalloc;
+    pEnv->xRealloc = p->xSaveRealloc;
+    pEnv->xFree = p->xSaveFree;
+    p->xDelMutex(p);
+    tmLsmFree(p);
+  }
+}
+
+void testMallocCheck(
+  lsm_env *pEnv,
+  int *pnLeakAlloc,
+  int *pnLeakByte,
+  FILE *pFile
+){
+  if( pEnv->pMemCtx==0 ){
+    *pnLeakAlloc = 0;
+    *pnLeakByte = 0;
+  }else{
+    tmMallocCheck((TmGlobal *)(pEnv->pMemCtx), pnLeakAlloc, pnLeakByte, pFile);
+  }
+}
+
+void testMallocOom(
+  lsm_env *pEnv, 
+  int nCountdown, 
+  int bPersist,
+  void (*xHook)(void *),
+  void *pHookCtx
+){
+  TmGlobal *pTm = (TmGlobal *)(pEnv->pMemCtx);
+  tmMallocOom(pTm, nCountdown, bPersist, xHook, pHookCtx);
+}
+
+void testMallocOomEnable(lsm_env *pEnv, int bEnable){
+  TmGlobal *pTm = (TmGlobal *)(pEnv->pMemCtx);
+  tmMallocOomEnable(pTm, bEnable);
+}

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest_tdb.c

@@ -0,0 +1,846 @@
+
+/*
+** This program attempts to test the correctness of some facets of the 
+** LSM database library. Specifically, that the contents of the database
+** are maintained correctly during a series of inserts and deletes.
+*/
+
+
+#include "lsmtest_tdb.h"
+#include "lsm.h"
+
+#include "lsmtest.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#ifndef _WIN32
+# include <unistd.h>
+#endif
+#include <stdio.h>
+
+
+typedef struct SqlDb SqlDb;
+
+static int error_transaction_function(TestDb *p, int iLevel){ 
+  unused_parameter(p);
+  unused_parameter(iLevel);
+  return -1; 
+}
+
+
+/*************************************************************************
+** Begin wrapper for LevelDB.
+*/
+#ifdef HAVE_LEVELDB
+
+#include <leveldb/c.h>
+
+typedef struct LevelDb LevelDb;
+struct LevelDb {
+  TestDb base;
+  leveldb_t *db;
+  leveldb_options_t *pOpt;
+  leveldb_writeoptions_t *pWriteOpt;
+  leveldb_readoptions_t *pReadOpt;
+
+  char *pVal;
+};
+
+static int test_leveldb_close(TestDb *pTestDb){
+  LevelDb *pDb = (LevelDb *)pTestDb;
+
+  leveldb_close(pDb->db);
+  leveldb_writeoptions_destroy(pDb->pWriteOpt);
+  leveldb_readoptions_destroy(pDb->pReadOpt);
+  leveldb_options_destroy(pDb->pOpt);
+  free(pDb->pVal);
+  free(pDb);
+
+  return 0;
+}
+
+static int test_leveldb_write(
+  TestDb *pTestDb, 
+  void *pKey, 
+  int nKey, 
+  void *pVal, 
+  int nVal
+){
+  LevelDb *pDb = (LevelDb *)pTestDb;
+  char *zErr = 0;
+  leveldb_put(pDb->db, pDb->pWriteOpt, pKey, nKey, pVal, nVal, &zErr);
+  return (zErr!=0);
+}
+
+static int test_leveldb_delete(TestDb *pTestDb, void *pKey, int nKey){
+  LevelDb *pDb = (LevelDb *)pTestDb;
+  char *zErr = 0;
+  leveldb_delete(pDb->db, pDb->pWriteOpt, pKey, nKey, &zErr);
+  return (zErr!=0);
+}
+
+static int test_leveldb_fetch(
+  TestDb *pTestDb, 
+  void *pKey, 
+  int nKey, 
+  void **ppVal, 
+  int *pnVal
+){
+  LevelDb *pDb = (LevelDb *)pTestDb;
+  char *zErr = 0;
+  size_t nVal = 0;
+
+  if( pKey==0 ) return 0;
+  free(pDb->pVal);
+  pDb->pVal = leveldb_get(pDb->db, pDb->pReadOpt, pKey, nKey, &nVal, &zErr);
+  *ppVal = (void *)(pDb->pVal);
+  if( pDb->pVal==0 ){
+    *pnVal = -1;
+  }else{
+    *pnVal = (int)nVal;
+  }
+
+  return (zErr!=0);
+}
+
+static int test_leveldb_scan(
+  TestDb *pTestDb,
+  void *pCtx,
+  int bReverse,
+  void *pKey1, int nKey1,         /* Start of search */
+  void *pKey2, int nKey2,         /* End of search */
+  void (*xCallback)(void *, void *, int , void *, int)
+){
+  LevelDb *pDb = (LevelDb *)pTestDb;
+  leveldb_iterator_t *iter;
+
+  iter = leveldb_create_iterator(pDb->db, pDb->pReadOpt);
+
+  if( bReverse==0 ){
+    if( pKey1 ){
+      leveldb_iter_seek(iter, pKey1, nKey1);
+    }else{
+      leveldb_iter_seek_to_first(iter);
+    }
+  }else{
+    if( pKey2 ){
+      leveldb_iter_seek(iter, pKey2, nKey2);
+
+      if( leveldb_iter_valid(iter)==0 ){
+        leveldb_iter_seek_to_last(iter);
+      }else{
+        const char *k; size_t n;
+        int res;
+        k = leveldb_iter_key(iter, &n);
+        res = memcmp(k, pKey2, MIN(n, nKey2));
+        if( res==0 ) res = n - nKey2;
+        assert( res>=0 );
+        if( res>0 ){
+          leveldb_iter_prev(iter);
+        }
+      }
+    }else{
+      leveldb_iter_seek_to_last(iter);
+    }
+  }
+
+
+  while( leveldb_iter_valid(iter) ){
+    const char *k; size_t n;
+    const char *v; size_t n2;
+    int res;
+
+    k = leveldb_iter_key(iter, &n);
+    if( bReverse==0 && pKey2 ){
+      res = memcmp(k, pKey2, MIN(n, nKey2));
+      if( res==0 ) res = n - nKey2;
+      if( res>0 ) break;
+    }
+    if( bReverse!=0 && pKey1 ){
+      res = memcmp(k, pKey1, MIN(n, nKey1));
+      if( res==0 ) res = n - nKey1;
+      if( res<0 ) break;
+    }
+
+    v = leveldb_iter_value(iter, &n2);
+
+    xCallback(pCtx, (void *)k, n, (void *)v, n2);
+
+    if( bReverse==0 ){
+      leveldb_iter_next(iter);
+    }else{
+      leveldb_iter_prev(iter);
+    }
+  }
+
+  leveldb_iter_destroy(iter);
+  return 0;
+}
+
+static int test_leveldb_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  static const DatabaseMethods LeveldbMethods = {
+    test_leveldb_close,
+    test_leveldb_write,
+    test_leveldb_delete,
+    0,
+    test_leveldb_fetch,
+    test_leveldb_scan,
+    error_transaction_function,
+    error_transaction_function,
+    error_transaction_function
+  };
+
+  LevelDb *pLevelDb;
+  char *zErr = 0;
+
+  if( bClear ){
+    char *zCmd = sqlite3_mprintf("rm -rf %s\n", zFilename);
+    system(zCmd);
+    sqlite3_free(zCmd);
+  }
+
+  pLevelDb = (LevelDb *)malloc(sizeof(LevelDb));
+  memset(pLevelDb, 0, sizeof(LevelDb));
+
+  pLevelDb->pOpt = leveldb_options_create();
+  leveldb_options_set_create_if_missing(pLevelDb->pOpt, 1);
+  pLevelDb->pWriteOpt = leveldb_writeoptions_create();
+  pLevelDb->pReadOpt = leveldb_readoptions_create();
+
+  pLevelDb->db = leveldb_open(pLevelDb->pOpt, zFilename, &zErr);
+
+  if( zErr ){
+    test_leveldb_close((TestDb *)pLevelDb);
+    *ppDb = 0;
+    return 1;
+  }
+
+  *ppDb = (TestDb *)pLevelDb;
+  pLevelDb->base.pMethods = &LeveldbMethods;
+  return 0;
+}
+#endif  /* HAVE_LEVELDB */
+/* 
+** End wrapper for LevelDB.
+*************************************************************************/
+
+#ifdef HAVE_KYOTOCABINET
+static int kc_close(TestDb *pTestDb){
+  return test_kc_close(pTestDb);
+}
+
+static int kc_write(
+  TestDb *pTestDb, 
+  void *pKey, 
+  int nKey, 
+  void *pVal, 
+  int nVal
+){
+  return test_kc_write(pTestDb, pKey, nKey, pVal, nVal);
+}
+
+static int kc_delete(TestDb *pTestDb, void *pKey, int nKey){
+  return test_kc_delete(pTestDb, pKey, nKey);
+}
+
+static int kc_delete_range(
+  TestDb *pTestDb, 
+  void *pKey1, int nKey1,
+  void *pKey2, int nKey2
+){
+  return test_kc_delete_range(pTestDb, pKey1, nKey1, pKey2, nKey2);
+}
+
+static int kc_fetch(
+  TestDb *pTestDb, 
+  void *pKey, 
+  int nKey, 
+  void **ppVal, 
+  int *pnVal
+){
+  if( pKey==0 ) return LSM_OK;
+  return test_kc_fetch(pTestDb, pKey, nKey, ppVal, pnVal);
+}
+
+static int kc_scan(
+  TestDb *pTestDb,
+  void *pCtx,
+  int bReverse,
+  void *pFirst, int nFirst,
+  void *pLast, int nLast,
+  void (*xCallback)(void *, void *, int , void *, int)
+){
+  return test_kc_scan(
+      pTestDb, pCtx, bReverse, pFirst, nFirst, pLast, nLast, xCallback
+  );
+}
+
+static int kc_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  static const DatabaseMethods KcdbMethods = {
+    kc_close,
+    kc_write,
+    kc_delete,
+    kc_delete_range,
+    kc_fetch,
+    kc_scan,
+    error_transaction_function,
+    error_transaction_function,
+    error_transaction_function
+  };
+
+  int rc;
+  TestDb *pTestDb = 0;
+
+  rc = test_kc_open(zFilename, bClear, &pTestDb);
+  if( rc!=0 ){
+    *ppDb = 0;
+    return rc;
+  }
+  pTestDb->pMethods = &KcdbMethods;
+  *ppDb = pTestDb;
+  return 0;
+}
+#endif /* HAVE_KYOTOCABINET */
+/* 
+** End wrapper for Kyoto cabinet.
+*************************************************************************/
+
+#ifdef HAVE_MDB
+static int mdb_close(TestDb *pTestDb){
+  return test_mdb_close(pTestDb);
+}
+
+static int mdb_write(
+  TestDb *pTestDb, 
+  void *pKey, 
+  int nKey, 
+  void *pVal, 
+  int nVal
+){
+  return test_mdb_write(pTestDb, pKey, nKey, pVal, nVal);
+}
+
+static int mdb_delete(TestDb *pTestDb, void *pKey, int nKey){
+  return test_mdb_delete(pTestDb, pKey, nKey);
+}
+
+static int mdb_fetch(
+  TestDb *pTestDb, 
+  void *pKey, 
+  int nKey, 
+  void **ppVal, 
+  int *pnVal
+){
+  if( pKey==0 ) return LSM_OK;
+  return test_mdb_fetch(pTestDb, pKey, nKey, ppVal, pnVal);
+}
+
+static int mdb_scan(
+  TestDb *pTestDb,
+  void *pCtx,
+  int bReverse,
+  void *pFirst, int nFirst,
+  void *pLast, int nLast,
+  void (*xCallback)(void *, void *, int , void *, int)
+){
+  return test_mdb_scan(
+      pTestDb, pCtx, bReverse, pFirst, nFirst, pLast, nLast, xCallback
+  );
+}
+
+static int mdb_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  static const DatabaseMethods KcdbMethods = {
+    mdb_close,
+    mdb_write,
+    mdb_delete,
+    0,
+    mdb_fetch,
+    mdb_scan,
+    error_transaction_function,
+    error_transaction_function,
+    error_transaction_function
+  };
+
+  int rc;
+  TestDb *pTestDb = 0;
+
+  rc = test_mdb_open(zSpec, zFilename, bClear, &pTestDb);
+  if( rc!=0 ){
+    *ppDb = 0;
+    return rc;
+  }
+  pTestDb->pMethods = &KcdbMethods;
+  *ppDb = pTestDb;
+  return 0;
+}
+#endif /* HAVE_MDB */
+
+/*************************************************************************
+** Begin wrapper for SQLite.
+*/
+
+/*
+** nOpenTrans:
+**   The number of open nested transactions, in the same sense as used
+**   by the tdb_begin/commit/rollback and SQLite 4 KV interfaces. If this
+**   value is 0, there are no transactions open at all. If it is 1, then
+**   there is a read transaction. If it is 2 or greater, then there are
+**   (nOpenTrans-1) nested write transactions open.
+*/
+struct SqlDb {
+  TestDb base;
+  sqlite3 *db;
+  sqlite3_stmt *pInsert;
+  sqlite3_stmt *pDelete;
+  sqlite3_stmt *pDeleteRange;
+  sqlite3_stmt *pFetch;
+  sqlite3_stmt *apScan[8];
+
+  int nOpenTrans;
+
+  /* Used by sql_fetch() to allocate space for results */
+  int nAlloc;
+  u8 *aAlloc;
+};
+
+static int sql_close(TestDb *pTestDb){
+  SqlDb *pDb = (SqlDb *)pTestDb;
+  sqlite3_finalize(pDb->pInsert);
+  sqlite3_finalize(pDb->pDelete);
+  sqlite3_finalize(pDb->pDeleteRange);
+  sqlite3_finalize(pDb->pFetch);
+  sqlite3_finalize(pDb->apScan[0]);
+  sqlite3_finalize(pDb->apScan[1]);
+  sqlite3_finalize(pDb->apScan[2]);
+  sqlite3_finalize(pDb->apScan[3]);
+  sqlite3_finalize(pDb->apScan[4]);
+  sqlite3_finalize(pDb->apScan[5]);
+  sqlite3_finalize(pDb->apScan[6]);
+  sqlite3_finalize(pDb->apScan[7]);
+  sqlite3_close(pDb->db);
+  free((char *)pDb->aAlloc);
+  free((char *)pDb);
+  return SQLITE_OK;
+}
+
+static int sql_write(
+  TestDb *pTestDb, 
+  void *pKey, 
+  int nKey, 
+  void *pVal, 
+  int nVal
+){
+  SqlDb *pDb = (SqlDb *)pTestDb;
+  sqlite3_bind_blob(pDb->pInsert, 1, pKey, nKey, SQLITE_STATIC);
+  sqlite3_bind_blob(pDb->pInsert, 2, pVal, nVal, SQLITE_STATIC);
+  sqlite3_step(pDb->pInsert);
+  return sqlite3_reset(pDb->pInsert);
+}
+
+static int sql_delete(TestDb *pTestDb, void *pKey, int nKey){
+  SqlDb *pDb = (SqlDb *)pTestDb;
+  sqlite3_bind_blob(pDb->pDelete, 1, pKey, nKey, SQLITE_STATIC);
+  sqlite3_step(pDb->pDelete);
+  return sqlite3_reset(pDb->pDelete);
+}
+
+static int sql_delete_range(
+  TestDb *pTestDb, 
+  void *pKey1, int nKey1,
+  void *pKey2, int nKey2
+){
+  SqlDb *pDb = (SqlDb *)pTestDb;
+  sqlite3_bind_blob(pDb->pDeleteRange, 1, pKey1, nKey1, SQLITE_STATIC);
+  sqlite3_bind_blob(pDb->pDeleteRange, 2, pKey2, nKey2, SQLITE_STATIC);
+  sqlite3_step(pDb->pDeleteRange);
+  return sqlite3_reset(pDb->pDeleteRange);
+}
+
+static int sql_fetch(
+  TestDb *pTestDb, 
+  void *pKey, 
+  int nKey, 
+  void **ppVal, 
+  int *pnVal
+){
+  SqlDb *pDb = (SqlDb *)pTestDb;
+  int rc;
+
+  sqlite3_reset(pDb->pFetch);
+  if( pKey==0 ){
+    assert( ppVal==0 );
+    assert( pnVal==0 );
+    return LSM_OK;
+  }
+
+  sqlite3_bind_blob(pDb->pFetch, 1, pKey, nKey, SQLITE_STATIC);
+  rc = sqlite3_step(pDb->pFetch);
+  if( rc==SQLITE_ROW ){
+    int nVal = sqlite3_column_bytes(pDb->pFetch, 0);
+    u8 *aVal = (void *)sqlite3_column_blob(pDb->pFetch, 0);
+
+    if( nVal>pDb->nAlloc ){
+      free(pDb->aAlloc);
+      pDb->aAlloc = (u8 *)malloc(nVal*2);
+      pDb->nAlloc = nVal*2;
+    }
+    memcpy(pDb->aAlloc, aVal, nVal);
+    *pnVal = nVal;
+    *ppVal = (void *)pDb->aAlloc;
+  }else{
+    *pnVal = -1;
+    *ppVal = 0;
+  }
+
+  rc = sqlite3_reset(pDb->pFetch);
+  return rc;
+}
+
+static int sql_scan(
+  TestDb *pTestDb,
+  void *pCtx,
+  int bReverse,
+  void *pFirst, int nFirst,
+  void *pLast, int nLast,
+  void (*xCallback)(void *, void *, int , void *, int)
+){
+  SqlDb *pDb = (SqlDb *)pTestDb;
+  sqlite3_stmt *pScan;
+
+  assert( bReverse==1 || bReverse==0 );
+  pScan = pDb->apScan[(pFirst==0) + (pLast==0)*2 + bReverse*4];
+
+  if( pFirst ) sqlite3_bind_blob(pScan, 1, pFirst, nFirst, SQLITE_STATIC);
+  if( pLast ) sqlite3_bind_blob(pScan, 2, pLast, nLast, SQLITE_STATIC);
+
+  while( SQLITE_ROW==sqlite3_step(pScan) ){
+    void *pKey; int nKey;
+    void *pVal; int nVal;
+
+    nKey = sqlite3_column_bytes(pScan, 0);
+    pKey = (void *)sqlite3_column_blob(pScan, 0);
+    nVal = sqlite3_column_bytes(pScan, 1);
+    pVal = (void *)sqlite3_column_blob(pScan, 1);
+
+    xCallback(pCtx, pKey, nKey, pVal, nVal);
+  }
+  return sqlite3_reset(pScan);
+}
+
+static int sql_begin(TestDb *pTestDb, int iLevel){
+  int i;
+  SqlDb *pDb = (SqlDb *)pTestDb;
+
+  /* iLevel==0 is a no-op */
+  if( iLevel==0 ) return 0;
+
+  /* If there are no transactions at all open, open a read transaction. */
+  if( pDb->nOpenTrans==0 ){
+    int rc = sqlite3_exec(pDb->db, 
+        "BEGIN; SELECT * FROM sqlite_schema LIMIT 1;" , 0, 0, 0
+    );
+    if( rc!=0 ) return rc;
+    pDb->nOpenTrans = 1;
+  }
+
+  /* Open any required write transactions */
+  for(i=pDb->nOpenTrans; i<iLevel; i++){
+    char *zSql = sqlite3_mprintf("SAVEPOINT x%d", i);
+    int rc = sqlite3_exec(pDb->db, zSql, 0, 0, 0);
+    sqlite3_free(zSql);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  pDb->nOpenTrans = iLevel;
+  return 0;
+}
+
+static int sql_commit(TestDb *pTestDb, int iLevel){
+  SqlDb *pDb = (SqlDb *)pTestDb;
+  assert( iLevel>=0 );
+
+  /* Close the read transaction if requested. */
+  if( pDb->nOpenTrans>=1 && iLevel==0 ){
+    int rc = sqlite3_exec(pDb->db, "COMMIT", 0, 0, 0);
+    if( rc!=0 ) return rc;
+    pDb->nOpenTrans = 0;
+  }
+
+  /* Close write transactions as required */
+  if( pDb->nOpenTrans>iLevel ){
+    char *zSql = sqlite3_mprintf("RELEASE x%d", iLevel);
+    int rc = sqlite3_exec(pDb->db, zSql, 0, 0, 0);
+    sqlite3_free(zSql);
+    if( rc!=0 ) return rc;
+  }
+
+  pDb->nOpenTrans = iLevel;
+  return 0;
+}
+
+static int sql_rollback(TestDb *pTestDb, int iLevel){
+  SqlDb *pDb = (SqlDb *)pTestDb;
+  assert( iLevel>=0 );
+
+  if( pDb->nOpenTrans>=1 && iLevel==0 ){
+    /* Close the read transaction if requested. */
+    int rc = sqlite3_exec(pDb->db, "ROLLBACK", 0, 0, 0);
+    if( rc!=0 ) return rc;
+  }else if( pDb->nOpenTrans>1 && iLevel==1 ){
+    /* Or, rollback and close the top-level write transaction */
+    int rc = sqlite3_exec(pDb->db, "ROLLBACK TO x1; RELEASE x1;", 0, 0, 0);
+    if( rc!=0 ) return rc;
+  }else{
+    /* Or, just roll back some nested transactions */
+    char *zSql = sqlite3_mprintf("ROLLBACK TO x%d", iLevel-1);
+    int rc = sqlite3_exec(pDb->db, zSql, 0, 0, 0);
+    sqlite3_free(zSql);
+    if( rc!=0 ) return rc;
+  }
+
+  pDb->nOpenTrans = iLevel;
+  return 0;
+}
+
+static int sql_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  static const DatabaseMethods SqlMethods = {
+    sql_close,
+    sql_write,
+    sql_delete,
+    sql_delete_range,
+    sql_fetch,
+    sql_scan,
+    sql_begin,
+    sql_commit,
+    sql_rollback
+  };
+  const char *zCreate = "CREATE TABLE IF NOT EXISTS t1(k PRIMARY KEY, v)";
+  const char *zInsert = "REPLACE INTO t1 VALUES(?, ?)";
+  const char *zDelete = "DELETE FROM t1 WHERE k = ?";
+  const char *zRange = "DELETE FROM t1 WHERE k>? AND k<?";
+  const char *zFetch  = "SELECT v FROM t1 WHERE k = ?";
+
+  const char *zScan0  = "SELECT * FROM t1 WHERE k BETWEEN ?1 AND ?2 ORDER BY k";
+  const char *zScan1  = "SELECT * FROM t1 WHERE k <= ?2 ORDER BY k";
+  const char *zScan2  = "SELECT * FROM t1 WHERE k >= ?1 ORDER BY k";
+  const char *zScan3  = "SELECT * FROM t1 ORDER BY k";
+
+  const char *zScan4  = 
+    "SELECT * FROM t1 WHERE k BETWEEN ?1 AND ?2 ORDER BY k DESC";
+  const char *zScan5  = "SELECT * FROM t1 WHERE k <= ?2 ORDER BY k DESC";
+  const char *zScan6  = "SELECT * FROM t1 WHERE k >= ?1 ORDER BY k DESC";
+  const char *zScan7  = "SELECT * FROM t1 ORDER BY k DESC";
+
+  int rc;
+  SqlDb *pDb;
+  char *zPragma;
+
+  if( bClear && zFilename && zFilename[0] ){
+    unlink(zFilename);
+  }
+
+  pDb = (SqlDb *)malloc(sizeof(SqlDb));
+  memset(pDb, 0, sizeof(SqlDb));
+  pDb->base.pMethods = &SqlMethods;
+
+  if( 0!=(rc = sqlite3_open(zFilename, &pDb->db))
+   || 0!=(rc = sqlite3_exec(pDb->db, zCreate, 0, 0, 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zInsert, -1, &pDb->pInsert, 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zDelete, -1, &pDb->pDelete, 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zRange, -1, &pDb->pDeleteRange, 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zFetch, -1, &pDb->pFetch, 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zScan0, -1, &pDb->apScan[0], 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zScan1, -1, &pDb->apScan[1], 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zScan2, -1, &pDb->apScan[2], 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zScan3, -1, &pDb->apScan[3], 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zScan4, -1, &pDb->apScan[4], 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zScan5, -1, &pDb->apScan[5], 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zScan6, -1, &pDb->apScan[6], 0))
+   || 0!=(rc = sqlite3_prepare_v2(pDb->db, zScan7, -1, &pDb->apScan[7], 0))
+  ){
+    *ppDb = 0;
+    sql_close((TestDb *)pDb);
+    return rc;
+  }
+
+  zPragma = sqlite3_mprintf("PRAGMA page_size=%d", TESTDB_DEFAULT_PAGE_SIZE);
+  sqlite3_exec(pDb->db, zPragma, 0, 0, 0);
+  sqlite3_free(zPragma);
+  zPragma = sqlite3_mprintf("PRAGMA cache_size=%d", TESTDB_DEFAULT_CACHE_SIZE);
+  sqlite3_exec(pDb->db, zPragma, 0, 0, 0);
+  sqlite3_free(zPragma);
+
+  /* sqlite3_exec(pDb->db, "PRAGMA locking_mode=EXCLUSIVE", 0, 0, 0); */
+  sqlite3_exec(pDb->db, "PRAGMA synchronous=OFF", 0, 0, 0);
+  sqlite3_exec(pDb->db, "PRAGMA journal_mode=WAL", 0, 0, 0);
+  sqlite3_exec(pDb->db, "PRAGMA wal_autocheckpoint=4096", 0, 0, 0);
+  if( zSpec ){
+    rc = sqlite3_exec(pDb->db, zSpec, 0, 0, 0);
+    if( rc!=SQLITE_OK ){
+      sql_close((TestDb *)pDb);
+      return rc;
+    }
+  }
+
+  *ppDb = (TestDb *)pDb;
+  return 0;
+}
+/* 
+** End wrapper for SQLite.
+*************************************************************************/
+
+/*************************************************************************
+** Begin exported functions.
+*/
+static struct Lib {
+  const char *zName;
+  const char *zDefaultDb;
+  int (*xOpen)(const char *, const char *zFilename, int bClear, TestDb **ppDb);
+} aLib[] = {
+  { "sqlite3",      "testdb.sqlite",    sql_open },
+  { "lsm_small",    "testdb.lsm_small", test_lsm_small_open },
+  { "lsm_lomem",    "testdb.lsm_lomem", test_lsm_lomem_open },
+  { "lsm_lomem2",   "testdb.lsm_lomem2", test_lsm_lomem2_open },
+#ifdef HAVE_ZLIB
+  { "lsm_zip",      "testdb.lsm_zip",   test_lsm_zip_open },
+#endif
+  { "lsm",          "testdb.lsm",       test_lsm_open },
+#ifdef LSM_MUTEX_PTHREADS
+  { "lsm_mt2",      "testdb.lsm_mt2",   test_lsm_mt2 },
+  { "lsm_mt3",      "testdb.lsm_mt3",   test_lsm_mt3 },
+#endif
+#ifdef HAVE_LEVELDB
+  { "leveldb",      "testdb.leveldb",   test_leveldb_open },
+#endif
+#ifdef HAVE_KYOTOCABINET
+  { "kyotocabinet", "testdb.kc",        kc_open },
+#endif
+#ifdef HAVE_MDB
+  { "mdb", "./testdb.mdb",        mdb_open }
+#endif
+};
+
+const char *tdb_system_name(int i){
+  if( i<0 || i>=ArraySize(aLib) ) return 0;
+  return aLib[i].zName;
+}
+
+const char *tdb_default_db(const char *zSys){
+  int i;
+  for(i=0; i<ArraySize(aLib); i++){
+    if( strcmp(aLib[i].zName, zSys)==0 ) return aLib[i].zDefaultDb;
+  }
+  return 0;
+}
+
+int tdb_open(const char *zLib, const char *zDb, int bClear, TestDb **ppDb){
+  int i;
+  int rc = 1;
+  const char *zSpec = 0;
+
+  int nLib = 0;
+  while( zLib[nLib] && zLib[nLib]!=' ' ){
+    nLib++;
+  }
+  zSpec = &zLib[nLib];
+  while( *zSpec==' ' ) zSpec++;
+  if( *zSpec=='\0' ) zSpec = 0;
+
+  for(i=0; i<ArraySize(aLib); i++){
+    if( (int)strlen(aLib[i].zName)==nLib
+        && 0==memcmp(zLib, aLib[i].zName, nLib) ){
+      rc = aLib[i].xOpen(zSpec, (zDb ? zDb : aLib[i].zDefaultDb), bClear, ppDb);
+      if( rc==0 ){
+        (*ppDb)->zLibrary = aLib[i].zName;
+      }
+      break;
+    }
+  }
+
+  if( rc ){
+    /* Failed to find the requested database library. Return an error. */
+    *ppDb = 0;
+  }
+  return rc;
+}
+
+int tdb_close(TestDb *pDb){
+  if( pDb ){
+    return pDb->pMethods->xClose(pDb);
+  }
+  return 0;
+}
+
+int tdb_write(TestDb *pDb, void *pKey, int nKey, void *pVal, int nVal){
+  return pDb->pMethods->xWrite(pDb, pKey, nKey, pVal, nVal);
+}
+
+int tdb_delete(TestDb *pDb, void *pKey, int nKey){
+  return pDb->pMethods->xDelete(pDb, pKey, nKey);
+}
+
+int tdb_delete_range(
+    TestDb *pDb, void *pKey1, int nKey1, void *pKey2, int nKey2
+){
+  return pDb->pMethods->xDeleteRange(pDb, pKey1, nKey1, pKey2, nKey2);
+}
+
+int tdb_fetch(TestDb *pDb, void *pKey, int nKey, void **ppVal, int *pnVal){
+  return pDb->pMethods->xFetch(pDb, pKey, nKey, ppVal, pnVal);
+}
+
+int tdb_scan(
+  TestDb *pDb,                    /* Database handle */
+  void *pCtx,                     /* Context pointer to pass to xCallback */
+  int bReverse,                   /* True to scan in reverse order */
+  void *pKey1, int nKey1,         /* Start of search */
+  void *pKey2, int nKey2,         /* End of search */
+  void (*xCallback)(void *pCtx, void *pKey, int nKey, void *pVal, int nVal)
+){
+  return pDb->pMethods->xScan(
+      pDb, pCtx, bReverse, pKey1, nKey1, pKey2, nKey2, xCallback
+  );
+}
+
+int tdb_begin(TestDb *pDb, int iLevel){
+  return pDb->pMethods->xBegin(pDb, iLevel);
+}
+int tdb_commit(TestDb *pDb, int iLevel){
+  return pDb->pMethods->xCommit(pDb, iLevel);
+}
+int tdb_rollback(TestDb *pDb, int iLevel){
+  return pDb->pMethods->xRollback(pDb, iLevel);
+}
+
+int tdb_transaction_support(TestDb *pDb){
+  return (pDb->pMethods->xBegin != error_transaction_function);
+}
+
+const char *tdb_library_name(TestDb *pDb){
+  return pDb->zLibrary;
+}
+
+/* 
+** End exported functions.
+*************************************************************************/

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest_tdb.h

@@ -0,0 +1,174 @@
+
+/*
+** This file is the interface to a very simple database library used for
+** testing. The interface is similar to that of the LSM. The main virtue 
+** of this library is that the same API may be used to access a key-value
+** store implemented by LSM, SQLite or another database system. Which 
+** makes it easy to use for correctness and performance tests.
+*/
+
+#ifndef __WRAPPER_H_
+#define __WRAPPER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lsm.h"
+
+typedef struct TestDb TestDb;
+
+/*
+** Open a new database connection. The first argument is the name of the
+** database library to use. e.g. something like:
+**
+**     "sqlite3"
+**     "lsm"
+**
+** See function tdb_system_name() for a list of available database systems.
+**
+** The second argument is the name of the database to open (e.g. a filename).
+**
+** If the third parameter is non-zero, then any existing database by the
+** name of zDb is removed before opening a new one. If it is zero, then an
+** existing database may be opened.
+*/
+int tdb_open(const char *zLibrary, const char *zDb, int bClear, TestDb **ppDb);
+
+/*
+** Close a database handle.
+*/
+int tdb_close(TestDb *pDb);
+
+/*
+** Write a new key/value into the database.
+*/
+int tdb_write(TestDb *pDb, void *pKey, int nKey, void *pVal, int nVal);
+
+/*
+** Delete a key from the database.
+*/
+int tdb_delete(TestDb *pDb, void *pKey, int nKey);
+
+/*
+** Delete a range of keys from the database.
+*/
+int tdb_delete_range(TestDb *, void *pKey1, int nKey1, void *pKey2, int nKey2);
+
+/*
+** Query the database for key (pKey/nKey). If no entry is found, set *ppVal
+** to 0 and *pnVal to -1 before returning. Otherwise, set *ppVal and *pnVal
+** to a pointer to and size of the value associated with (pKey/nKey).
+*/
+int tdb_fetch(TestDb *pDb, void *pKey, int nKey, void **ppVal, int *pnVal);
+
+/*
+** Open and close nested transactions. Currently, these functions only 
+** work for SQLite3 and LSM systems. Use the tdb_transaction_support() 
+** function to determine if a given TestDb handle supports these methods.
+**
+** These functions and the iLevel parameter follow the same conventions as
+** the SQLite 4 transaction interface. Note that this is slightly different
+** from the way LSM does things. As follows:
+**
+** tdb_begin():
+**   A successful call to tdb_begin() with (iLevel>1) guarantees that 
+**   there are at least (iLevel-1) write transactions open. If iLevel==1,
+**   then it guarantees that at least a read-transaction is open. Calling
+**   tdb_begin() with iLevel==0 is a no-op.
+**
+** tdb_commit():
+**   A successful call to tdb_commit() with (iLevel>1) guarantees that 
+**   there are at most (iLevel-1) write transactions open. If iLevel==1,
+**   then it guarantees that there are no write transactions open (although
+**   a read-transaction may remain open).  Calling tdb_commit() with 
+**   iLevel==0 ensures that all transactions, read or write, have been 
+**   closed and committed.
+**
+** tdb_rollback():
+**   This call is similar to tdb_commit(), except that instead of committing
+**   transactions, it reverts them. For example, calling tdb_rollback() with
+**   iLevel==2 ensures that there is at most one write transaction open, and
+**   restores the database to the state that it was in when that transaction
+**   was opened.
+**
+**   In other words, tdb_commit() just closes transactions - tdb_rollback()
+**   closes transactions and then restores the database to the state it
+**   was in before those transactions were even opened.
+*/
+int tdb_begin(TestDb *pDb, int iLevel);
+int tdb_commit(TestDb *pDb, int iLevel);
+int tdb_rollback(TestDb *pDb, int iLevel);
+
+/*
+** Return true if transactions are supported, or false otherwise.
+*/
+int tdb_transaction_support(TestDb *pDb);
+
+/*
+** Return the name of the database library (as passed to tdb_open()) used
+** by the handled passed as the first argument.
+*/
+const char *tdb_library_name(TestDb *pDb);
+
+/*
+** Scan a range of database keys. Invoke the callback function for each
+** key visited.
+*/
+int tdb_scan(
+  TestDb *pDb,                    /* Database handle */
+  void *pCtx,                     /* Context pointer to pass to xCallback */
+  int bReverse,                   /* True to scan in reverse order */
+  void *pKey1, int nKey1,         /* Start of search */
+  void *pKey2, int nKey2,         /* End of search */
+  void (*xCallback)(void *pCtx, void *pKey, int nKey, void *pVal, int nVal)
+);
+
+const char *tdb_system_name(int i);
+const char *tdb_default_db(const char *zSys);
+
+int tdb_lsm_open(const char *zCfg, const char *zDb, int bClear, TestDb **ppDb);
+
+/*
+** If the TestDb handle passed as an argument is a wrapper around an LSM
+** database, return the LSM handle. Otherwise, if the argument is some other
+** database system, return NULL.
+*/
+lsm_db *tdb_lsm(TestDb *pDb);
+
+/*
+** Return true if the db passed as an argument is a multi-threaded LSM
+** connection.
+*/
+int tdb_lsm_multithread(TestDb *pDb);
+
+/*
+** Return a pointer to the lsm_env object used by all lsm database
+** connections initialized as a copy of the object returned by 
+** lsm_default_env(). It may be modified (e.g. to override functions)
+** if the caller can guarantee that it is not already in use.
+*/
+lsm_env *tdb_lsm_env(void);
+
+/*
+** The following functions only work with LSM database handles. It is
+** illegal to call them with any other type of database handle specified
+** as an argument.
+*/
+void tdb_lsm_enable_log(TestDb *pDb, int bEnable);
+void tdb_lsm_application_crash(TestDb *pDb);
+void tdb_lsm_prepare_system_crash(TestDb *pDb);
+void tdb_lsm_system_crash(TestDb *pDb);
+void tdb_lsm_prepare_sync_crash(TestDb *pDb, int iSync);
+
+
+void tdb_lsm_safety(TestDb *pDb, int eMode);
+void tdb_lsm_config_work_hook(TestDb *pDb, void (*)(lsm_db *, void *), void *);
+void tdb_lsm_write_hook(TestDb *, void(*)(void*,int,lsm_i64,int,int), void*);
+int tdb_lsm_config_str(TestDb *pDb, const char *zStr);
+
+#ifdef __cplusplus
+}  /* End of the 'extern "C"' block */
+#endif
+
+#endif

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest_tdb2.cc

@@ -0,0 +1,369 @@
+
+
+#include "lsmtest.h"
+#include <stdlib.h>
+
+#ifdef HAVE_KYOTOCABINET
+#include "kcpolydb.h"
+extern "C" {
+  struct KcDb {
+    TestDb base;
+    kyotocabinet::TreeDB* db;
+    char *pVal;
+  };
+}
+
+int test_kc_open(const char *zFilename, int bClear, TestDb **ppDb){
+  KcDb *pKcDb;
+  int ok;
+  int rc = 0;
+
+  if( bClear ){
+    char *zCmd = sqlite3_mprintf("rm -rf %s\n", zFilename);
+    system(zCmd);
+    sqlite3_free(zCmd);
+  }
+
+  pKcDb = (KcDb *)malloc(sizeof(KcDb));
+  memset(pKcDb, 0, sizeof(KcDb));
+
+
+  pKcDb->db = new kyotocabinet::TreeDB();
+  pKcDb->db->tune_page(TESTDB_DEFAULT_PAGE_SIZE);
+  pKcDb->db->tune_page_cache(
+      TESTDB_DEFAULT_PAGE_SIZE * TESTDB_DEFAULT_CACHE_SIZE
+  );
+  ok = pKcDb->db->open(zFilename,
+      kyotocabinet::PolyDB::OWRITER | kyotocabinet::PolyDB::OCREATE
+  );
+  if( ok==0 ){
+    free(pKcDb);
+    pKcDb = 0;
+    rc = 1;
+  }
+
+  *ppDb = (TestDb *)pKcDb;
+  return rc;
+}
+
+int test_kc_close(TestDb *pDb){
+  KcDb *pKcDb = (KcDb *)pDb;
+  if( pKcDb->pVal ){
+    delete [] pKcDb->pVal;
+  }
+  pKcDb->db->close();
+  delete pKcDb->db;
+  free(pKcDb);
+  return 0;
+}
+
+int test_kc_write(TestDb *pDb, void *pKey, int nKey, void *pVal, int nVal){
+  KcDb *pKcDb = (KcDb *)pDb;
+  int ok;
+
+  ok = pKcDb->db->set((const char *)pKey, nKey, (const char *)pVal, nVal);
+  return (ok ? 0 : 1);
+}
+
+int test_kc_delete(TestDb *pDb, void *pKey, int nKey){
+  KcDb *pKcDb = (KcDb *)pDb;
+  int ok;
+
+  ok = pKcDb->db->remove((const char *)pKey, nKey);
+  return (ok ? 0 : 1);
+}
+
+int test_kc_delete_range(
+  TestDb *pDb, 
+  void *pKey1, int nKey1,
+  void *pKey2, int nKey2
+){
+  int res;
+  KcDb *pKcDb = (KcDb *)pDb;
+  kyotocabinet::DB::Cursor* pCur = pKcDb->db->cursor();
+
+  if( pKey1 ){
+    res = pCur->jump((const char *)pKey1, nKey1);
+  }else{
+    res = pCur->jump();
+  }
+
+  while( 1 ){
+    const char *pKey; size_t nKey;
+    const char *pVal; size_t nVal;
+
+    pKey = pCur->get(&nKey, &pVal, &nVal);
+    if( pKey==0 ) break;
+
+#ifndef NDEBUG
+    if( pKey1 ){
+      res = memcmp(pKey, pKey1, MIN((size_t)nKey1, nKey));
+      assert( res>0 || (res==0 && nKey>nKey1) );
+    }
+#endif
+
+    if( pKey2 ){
+      res = memcmp(pKey, pKey2, MIN((size_t)nKey2, nKey));
+      if( res>0 || (res==0 && (size_t)nKey2<nKey) ){
+        delete [] pKey;
+        break;
+      }
+    }
+    pCur->remove();
+    delete [] pKey;
+  }
+
+  delete pCur;
+  return 0;
+}
+
+int test_kc_fetch(
+  TestDb *pDb, 
+  void *pKey, 
+  int nKey, 
+  void **ppVal,
+  int *pnVal
+){
+  KcDb *pKcDb = (KcDb *)pDb;
+  size_t nVal;
+
+  if( pKcDb->pVal ){
+    delete [] pKcDb->pVal;
+    pKcDb->pVal = 0;
+  }
+
+  pKcDb->pVal = pKcDb->db->get((const char *)pKey, nKey, &nVal);
+  if( pKcDb->pVal ){
+    *ppVal = pKcDb->pVal;
+    *pnVal = nVal;
+  }else{
+    *ppVal = 0;
+    *pnVal = -1;
+  }
+
+  return 0;
+}
+
+int test_kc_scan(
+  TestDb *pDb,                    /* Database handle */
+  void *pCtx,                     /* Context pointer to pass to xCallback */
+  int bReverse,                   /* True for a reverse order scan */
+  void *pKey1, int nKey1,         /* Start of search */
+  void *pKey2, int nKey2,         /* End of search */
+  void (*xCallback)(void *pCtx, void *pKey, int nKey, void *pVal, int nVal)
+){
+  KcDb *pKcDb = (KcDb *)pDb;
+  kyotocabinet::DB::Cursor* pCur = pKcDb->db->cursor();
+  int res;
+
+  if( bReverse==0 ){
+    if( pKey1 ){
+      res = pCur->jump((const char *)pKey1, nKey1);
+    }else{
+      res = pCur->jump();
+    }
+  }else{
+    if( pKey2 ){
+      res = pCur->jump_back((const char *)pKey2, nKey2);
+    }else{
+      res = pCur->jump_back();
+    }
+  }
+
+  while( res ){
+    const char *pKey; size_t nKey;
+    const char *pVal; size_t nVal;
+    pKey = pCur->get(&nKey, &pVal, &nVal);
+
+    if( bReverse==0 && pKey2 ){
+      res = memcmp(pKey, pKey2, MIN((size_t)nKey2, nKey));
+      if( res>0 || (res==0 && (size_t)nKey2<nKey) ){
+        delete [] pKey;
+        break;
+      }
+    }else if( bReverse!=0 && pKey1 ){
+      res = memcmp(pKey, pKey1, MIN((size_t)nKey1, nKey));
+      if( res<0 || (res==0 && (size_t)nKey1>nKey) ){
+        delete [] pKey;
+        break;
+      }
+    }
+
+    xCallback(pCtx, (void *)pKey, (int)nKey, (void *)pVal, (int)nVal);
+    delete [] pKey;
+
+    if( bReverse ){
+      res = pCur->step_back();
+    }else{
+      res = pCur->step();
+    }
+  }
+
+  delete pCur;
+  return 0;
+}
+#endif /* HAVE_KYOTOCABINET */
+
+#ifdef HAVE_MDB 
+#include "lmdb.h"
+
+extern "C" {
+  struct MdbDb {
+    TestDb base;
+    MDB_env *env;
+    MDB_dbi dbi;
+  };
+}
+
+int test_mdb_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  MDB_txn *txn;
+  MdbDb *pMdb;
+  int rc;
+
+  if( bClear ){
+    char *zCmd = sqlite3_mprintf("rm -rf %s\n", zFilename);
+    system(zCmd);
+    sqlite3_free(zCmd);
+  }
+
+  pMdb = (MdbDb *)malloc(sizeof(MdbDb));
+  memset(pMdb, 0, sizeof(MdbDb));
+
+  rc = mdb_env_create(&pMdb->env);
+  if( rc==0 ) rc = mdb_env_set_mapsize(pMdb->env, 1*1024*1024*1024);
+  if( rc==0 ) rc = mdb_env_open(pMdb->env, zFilename, MDB_NOSYNC|MDB_NOSUBDIR, 0600);
+  if( rc==0 ) rc = mdb_txn_begin(pMdb->env, NULL, 0, &txn);
+  if( rc==0 ){
+    rc = mdb_open(txn, NULL, 0, &pMdb->dbi);
+    mdb_txn_commit(txn);
+  }
+
+  *ppDb = (TestDb *)pMdb;
+  return rc;
+}
+
+int test_mdb_close(TestDb *pDb){
+  MdbDb *pMdb = (MdbDb *)pDb;
+
+  mdb_close(pMdb->env, pMdb->dbi);
+  mdb_env_close(pMdb->env);
+  free(pMdb);
+  return 0;
+}
+
+int test_mdb_write(TestDb *pDb, void *pKey, int nKey, void *pVal, int nVal){
+  int rc;
+  MdbDb *pMdb = (MdbDb *)pDb;
+  MDB_val val;
+  MDB_val key;
+  MDB_txn *txn;
+
+  val.mv_size = nVal; 
+  val.mv_data = pVal;
+  key.mv_size = nKey; 
+  key.mv_data = pKey;
+
+  rc = mdb_txn_begin(pMdb->env, NULL, 0, &txn);
+  if( rc==0 ){
+    rc = mdb_put(txn, pMdb->dbi, &key, &val, 0);
+    if( rc==0 ){
+      rc = mdb_txn_commit(txn);
+    }else{
+      mdb_txn_abort(txn);
+    }
+  }
+  
+  return rc;
+}
+
+int test_mdb_delete(TestDb *pDb, void *pKey, int nKey){
+  int rc;
+  MdbDb *pMdb = (MdbDb *)pDb;
+  MDB_val key;
+  MDB_txn *txn;
+
+  key.mv_size = nKey; 
+  key.mv_data = pKey;
+  rc = mdb_txn_begin(pMdb->env, NULL, 0, &txn);
+  if( rc==0 ){
+    rc = mdb_del(txn, pMdb->dbi, &key, 0);
+    if( rc==0 ){
+      rc = mdb_txn_commit(txn);
+    }else{
+      mdb_txn_abort(txn);
+    }
+  }
+  
+  return rc;
+}
+
+int test_mdb_fetch(
+  TestDb *pDb, 
+  void *pKey, 
+  int nKey, 
+  void **ppVal,
+  int *pnVal
+){
+  int rc;
+  MdbDb *pMdb = (MdbDb *)pDb;
+  MDB_val key;
+  MDB_txn *txn;
+
+  key.mv_size = nKey;
+  key.mv_data = pKey;
+
+  rc = mdb_txn_begin(pMdb->env, NULL, MDB_RDONLY, &txn);
+  if( rc==0 ){
+    MDB_val val = {0, 0};
+    rc = mdb_get(txn, pMdb->dbi, &key, &val);
+    if( rc==MDB_NOTFOUND ){
+      rc = 0;
+      *ppVal = 0;
+      *pnVal = -1;
+    }else{
+      *ppVal = val.mv_data;
+      *pnVal = val.mv_size;
+    }
+    mdb_txn_commit(txn);
+  }
+
+  return rc;
+}
+
+int test_mdb_scan(
+  TestDb *pDb,                    /* Database handle */
+  void *pCtx,                     /* Context pointer to pass to xCallback */
+  int bReverse,                   /* True for a reverse order scan */
+  void *pKey1, int nKey1,         /* Start of search */
+  void *pKey2, int nKey2,         /* End of search */
+  void (*xCallback)(void *pCtx, void *pKey, int nKey, void *pVal, int nVal)
+){
+  MdbDb *pMdb = (MdbDb *)pDb;
+  int rc;
+  MDB_cursor_op op = bReverse ? MDB_PREV : MDB_NEXT;
+  MDB_txn *txn;
+
+  rc = mdb_txn_begin(pMdb->env, NULL, MDB_RDONLY, &txn);
+  if( rc==0 ){
+    MDB_cursor *csr;
+    MDB_val key = {0, 0};
+    MDB_val val = {0, 0};
+
+    rc = mdb_cursor_open(txn, pMdb->dbi, &csr);
+    if( rc==0 ){
+      while( mdb_cursor_get(csr, &key, &val, op)==0 ){
+        xCallback(pCtx, key.mv_data, key.mv_size, val.mv_data, val.mv_size);
+      }
+      mdb_cursor_close(csr);
+    }
+  }
+
+  return rc;
+}
+
+#endif /* HAVE_MDB */

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest_tdb3.c

@@ -0,0 +1,1429 @@
+
+#include "lsmtest_tdb.h"
+#include "lsm.h"
+#include "lsmtest.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#ifndef _WIN32
+# include <unistd.h>
+#endif
+#include <stdio.h>
+
+#ifndef _WIN32
+# include <sys/time.h>
+#endif
+
+typedef struct LsmDb LsmDb;
+typedef struct LsmWorker LsmWorker;
+typedef struct LsmFile LsmFile;
+
+#define LSMTEST_DFLT_MT_MAX_CKPT (8*1024)
+#define LSMTEST_DFLT_MT_MIN_CKPT (2*1024)
+
+#ifdef LSM_MUTEX_PTHREADS
+#include <pthread.h>
+
+#define LSMTEST_THREAD_CKPT      1
+#define LSMTEST_THREAD_WORKER    2
+#define LSMTEST_THREAD_WORKER_AC 3
+
+/*
+** There are several different types of worker threads that run in different
+** test configurations, depending on the value of LsmWorker.eType.
+**
+**   1. Checkpointer.
+**   2. Worker with auto-checkpoint.
+**   3. Worker without auto-checkpoint.
+*/
+struct LsmWorker {
+  LsmDb *pDb;                     /* Main database structure */
+  lsm_db *pWorker;                /* Worker database handle */
+  pthread_t worker_thread;        /* Worker thread */
+  pthread_cond_t worker_cond;     /* Condition var the worker waits on */
+  pthread_mutex_t worker_mutex;   /* Mutex used with worker_cond */
+  int bDoWork;                    /* Set to true by client when there is work */
+  int worker_rc;                  /* Store error code here */
+  int eType;                      /* LSMTEST_THREAD_XXX constant */
+  int bBlock;
+};
+#else
+struct LsmWorker { int worker_rc; int bBlock; };
+#endif
+
+static void mt_shutdown(LsmDb *);
+
+lsm_env *tdb_lsm_env(void){
+  static int bInit = 0;
+  static lsm_env env;
+  if( bInit==0 ){
+    memcpy(&env, lsm_default_env(), sizeof(env));
+    bInit = 1;
+  }
+  return &env;
+}
+
+typedef struct FileSector FileSector;
+typedef struct FileData FileData;
+
+struct FileSector {
+  u8 *aOld;                       /* Old data for this sector */
+};
+
+struct FileData {
+  int nSector;                    /* Allocated size of apSector[] array */
+  FileSector *aSector;            /* Array of file sectors */
+};
+
+/*
+** bPrepareCrash:
+**   If non-zero, the file wrappers maintain enough in-memory data to
+**   simulate the effect of a power-failure on the file-system (i.e. that
+**   unsynced sectors may be written, not written, or overwritten with
+**   arbitrary data when the crash occurs).
+**
+** bCrashed:
+**   Set to true after a crash is simulated. Once this variable is true, all
+**   VFS methods other than xClose() return LSM_IOERR as soon as they are
+**   called (without affecting the contents of the file-system).
+**
+** env:
+**   The environment object used by all lsm_db* handles opened by this
+**   object (i.e. LsmDb.db plus any worker connections). Variable env.pVfsCtx
+**   always points to the containing LsmDb structure.
+*/
+struct LsmDb {
+  TestDb base;                    /* Base class - methods table */
+  lsm_env env;                    /* Environment used by connection db */
+  char *zName;                    /* Database file name */
+  lsm_db *db;                     /* LSM database handle */
+
+  lsm_cursor *pCsr;               /* Cursor held open during read transaction */
+  void *pBuf;                     /* Buffer for tdb_fetch() output */
+  int nBuf;                       /* Allocated (not used) size of pBuf */
+
+  /* Crash testing related state */
+  int bCrashed;                   /* True once a crash has occurred */
+  int nAutoCrash;                 /* Number of syncs until a crash */
+  int bPrepareCrash;              /* True to store writes in memory */
+
+  /* Unsynced data (while crash testing) */
+  int szSector;                   /* Assumed size of disk sectors (512B) */
+  FileData aFile[2];              /* Database and log file data */
+
+  /* Other test instrumentation */
+  int bNoRecovery;                /* If true, assume DMS2 is locked */
+
+  /* Work hook redirection */
+  void (*xWork)(lsm_db *, void *);
+  void *pWorkCtx;
+
+  /* IO logging hook */
+  void (*xWriteHook)(void *, int, lsm_i64, int, int);
+  void *pWriteCtx;
+  
+  /* Worker threads (for lsm_mt) */
+  int nMtMinCkpt;
+  int nMtMaxCkpt;
+  int eMode;
+  int nWorker;
+  LsmWorker *aWorker;
+};
+
+#define LSMTEST_MODE_SINGLETHREAD    1
+#define LSMTEST_MODE_BACKGROUND_CKPT 2
+#define LSMTEST_MODE_BACKGROUND_WORK 3
+#define LSMTEST_MODE_BACKGROUND_BOTH 4
+
+/*************************************************************************
+**************************************************************************
+** Begin test VFS code.
+*/
+
+struct LsmFile {
+  lsm_file *pReal;                /* Real underlying file */
+  int bLog;                       /* True for log file. False for db file */
+  LsmDb *pDb;                     /* Database handle that uses this file */
+};
+
+static int testEnvFullpath(
+  lsm_env *pEnv,                  /* Environment for current LsmDb */
+  const char *zFile,              /* Relative path name */
+  char *zOut,                     /* Output buffer */
+  int *pnOut                      /* IN/OUT: Size of output buffer */
+){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  return pRealEnv->xFullpath(pRealEnv, zFile, zOut, pnOut);
+}
+
+static int testEnvOpen(
+  lsm_env *pEnv,                  /* Environment for current LsmDb */
+  const char *zFile,              /* Name of file to open */
+  int flags,
+  lsm_file **ppFile               /* OUT: New file handle object */
+){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  LsmDb *pDb = (LsmDb *)pEnv->pVfsCtx;
+  int rc;                         /* Return Code */
+  LsmFile *pRet;                  /* The new file handle */
+  int nFile;                      /* Length of string zFile in bytes */
+
+  nFile = strlen(zFile);
+  pRet = (LsmFile *)testMalloc(sizeof(LsmFile));
+  pRet->pDb = pDb;
+  pRet->bLog = (nFile > 4 && 0==memcmp("-log", &zFile[nFile-4], 4));
+
+  rc = pRealEnv->xOpen(pRealEnv, zFile, flags, &pRet->pReal);
+  if( rc!=LSM_OK ){
+    testFree(pRet);
+    pRet = 0;
+  }
+
+  *ppFile = (lsm_file *)pRet;
+  return rc;
+}
+
+static int testEnvRead(lsm_file *pFile, lsm_i64 iOff, void *pData, int nData){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  LsmFile *p = (LsmFile *)pFile;
+  if( p->pDb->bCrashed ) return LSM_IOERR;
+  return pRealEnv->xRead(p->pReal, iOff, pData, nData);
+}
+
+static int testEnvWrite(lsm_file *pFile, lsm_i64 iOff, void *pData, int nData){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  LsmFile *p = (LsmFile *)pFile;
+  LsmDb *pDb = p->pDb;
+
+  if( pDb->bCrashed ) return LSM_IOERR;
+
+  if( pDb->bPrepareCrash ){
+    FileData *pData2 = &pDb->aFile[p->bLog];
+    int iFirst;                 
+    int iLast;
+    int iSector;
+
+    iFirst = (int)(iOff / pDb->szSector);
+    iLast =  (int)((iOff + nData - 1) / pDb->szSector);
+
+    if( pData2->nSector<(iLast+1) ){
+      int nNew = ( ((iLast + 1) + 63) / 64 ) * 64;
+      assert( nNew>iLast );
+      pData2->aSector = (FileSector *)testRealloc(
+          pData2->aSector, nNew*sizeof(FileSector)
+      );
+      memset(&pData2->aSector[pData2->nSector], 
+          0, (nNew - pData2->nSector) * sizeof(FileSector)
+      );
+      pData2->nSector = nNew;
+    }
+
+    for(iSector=iFirst; iSector<=iLast; iSector++){
+      if( pData2->aSector[iSector].aOld==0 ){
+        u8 *aOld = (u8 *)testMalloc(pDb->szSector);
+        pRealEnv->xRead(
+            p->pReal, (lsm_i64)iSector*pDb->szSector, aOld, pDb->szSector
+        );
+        pData2->aSector[iSector].aOld = aOld;
+      }
+    }
+  }
+
+  if( pDb->xWriteHook ){
+    int rc;
+    int nUs;
+    struct timeval t1;
+    struct timeval t2;
+
+    gettimeofday(&t1, 0);
+    assert( nData>0 );
+    rc = pRealEnv->xWrite(p->pReal, iOff, pData, nData);
+    gettimeofday(&t2, 0);
+
+    nUs = (t2.tv_sec - t1.tv_sec) * 1000000 + (t2.tv_usec - t1.tv_usec);
+    pDb->xWriteHook(pDb->pWriteCtx, p->bLog, iOff, nData, nUs);
+    return rc;
+  }
+
+  return pRealEnv->xWrite(p->pReal, iOff, pData, nData);
+}
+
+static void doSystemCrash(LsmDb *pDb);
+
+static int testEnvSync(lsm_file *pFile){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  LsmFile *p = (LsmFile *)pFile;
+  LsmDb *pDb = p->pDb;
+  FileData *pData = &pDb->aFile[p->bLog];
+  int i;
+
+  if( pDb->bCrashed ) return LSM_IOERR;
+
+  if( pDb->nAutoCrash ){
+    pDb->nAutoCrash--;
+    if( pDb->nAutoCrash==0 ){
+      doSystemCrash(pDb);
+      pDb->bCrashed = 1;
+      return LSM_IOERR;
+    }
+  }
+
+  if( pDb->bPrepareCrash ){
+    for(i=0; i<pData->nSector; i++){
+      testFree(pData->aSector[i].aOld);
+      pData->aSector[i].aOld = 0;
+    }
+  }
+
+  if( pDb->xWriteHook ){
+    int rc;
+    int nUs;
+    struct timeval t1;
+    struct timeval t2;
+
+    gettimeofday(&t1, 0);
+    rc = pRealEnv->xSync(p->pReal);
+    gettimeofday(&t2, 0);
+
+    nUs = (t2.tv_sec - t1.tv_sec) * 1000000 + (t2.tv_usec - t1.tv_usec);
+    pDb->xWriteHook(pDb->pWriteCtx, p->bLog, 0, 0, nUs);
+    return rc;
+  }
+
+  return pRealEnv->xSync(p->pReal);
+}
+
+static int testEnvTruncate(lsm_file *pFile, lsm_i64 iOff){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  LsmFile *p = (LsmFile *)pFile;
+  if( p->pDb->bCrashed ) return LSM_IOERR;
+  return pRealEnv->xTruncate(p->pReal, iOff);
+}
+
+static int testEnvSectorSize(lsm_file *pFile){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  LsmFile *p = (LsmFile *)pFile;
+  return pRealEnv->xSectorSize(p->pReal);
+}
+
+static int testEnvRemap(
+  lsm_file *pFile, 
+  lsm_i64 iMin, 
+  void **ppOut,
+  lsm_i64 *pnOut
+){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  LsmFile *p = (LsmFile *)pFile;
+  return pRealEnv->xRemap(p->pReal, iMin, ppOut, pnOut);
+}
+
+static int testEnvFileid(
+  lsm_file *pFile, 
+  void *ppOut,
+  int *pnOut
+){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  LsmFile *p = (LsmFile *)pFile;
+  return pRealEnv->xFileid(p->pReal, ppOut, pnOut);
+}
+
+static int testEnvClose(lsm_file *pFile){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  LsmFile *p = (LsmFile *)pFile;
+
+  pRealEnv->xClose(p->pReal);
+  testFree(p);
+  return LSM_OK;
+}
+
+static int testEnvUnlink(lsm_env *pEnv, const char *zFile){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  unused_parameter(pEnv);
+  return pRealEnv->xUnlink(pRealEnv, zFile);
+}
+
+static int testEnvLock(lsm_file *pFile, int iLock, int eType){
+  LsmFile *p = (LsmFile *)pFile;
+  lsm_env *pRealEnv = tdb_lsm_env();
+
+  if( iLock==2 && eType==LSM_LOCK_EXCL && p->pDb->bNoRecovery ){
+    return LSM_BUSY;
+  }
+  return pRealEnv->xLock(p->pReal, iLock, eType);
+}
+
+static int testEnvTestLock(lsm_file *pFile, int iLock, int nLock, int eType){
+  LsmFile *p = (LsmFile *)pFile;
+  lsm_env *pRealEnv = tdb_lsm_env();
+
+  if( iLock==2 && eType==LSM_LOCK_EXCL && p->pDb->bNoRecovery ){
+    return LSM_BUSY;
+  }
+  return pRealEnv->xTestLock(p->pReal, iLock, nLock, eType);
+}
+
+static int testEnvShmMap(lsm_file *pFile, int iRegion, int sz, void **pp){
+  LsmFile *p = (LsmFile *)pFile;
+  lsm_env *pRealEnv = tdb_lsm_env();
+  return pRealEnv->xShmMap(p->pReal, iRegion, sz, pp);
+}
+
+static void testEnvShmBarrier(void){
+}
+
+static int testEnvShmUnmap(lsm_file *pFile, int bDel){
+  LsmFile *p = (LsmFile *)pFile;
+  lsm_env *pRealEnv = tdb_lsm_env();
+  return pRealEnv->xShmUnmap(p->pReal, bDel);
+}
+
+static int testEnvSleep(lsm_env *pEnv, int us){
+  lsm_env *pRealEnv = tdb_lsm_env();
+  return pRealEnv->xSleep(pRealEnv, us);
+}
+
+static void doSystemCrash(LsmDb *pDb){
+  lsm_env *pEnv = tdb_lsm_env();
+  int iFile;
+  int iSeed = pDb->aFile[0].nSector + pDb->aFile[1].nSector;
+
+  char *zFile = pDb->zName;
+  char *zFree = 0;
+
+  for(iFile=0; iFile<2; iFile++){
+    lsm_file *pFile = 0;
+    int i;
+
+    pEnv->xOpen(pEnv, zFile, 0, &pFile);
+    for(i=0; i<pDb->aFile[iFile].nSector; i++){
+      u8 *aOld = pDb->aFile[iFile].aSector[i].aOld;
+      if( aOld ){
+        int iOpt = testPrngValue(iSeed++) % 3;
+        switch( iOpt ){
+          case 0:
+            break;
+
+          case 1:
+            testPrngArray(iSeed++, (u32 *)aOld, pDb->szSector/4);
+            /* Fall-through */
+
+          case 2:
+            pEnv->xWrite(
+                pFile, (lsm_i64)i * pDb->szSector, aOld, pDb->szSector
+            );
+            break;
+        }
+        testFree(aOld);
+        pDb->aFile[iFile].aSector[i].aOld = 0;
+      }
+    }
+    pEnv->xClose(pFile);
+    zFree = zFile = sqlite3_mprintf("%s-log", pDb->zName);
+  }
+
+  sqlite3_free(zFree);
+}
+/*
+** End test VFS code.
+**************************************************************************
+*************************************************************************/
+
+/*************************************************************************
+**************************************************************************
+** Begin test compression hooks.
+*/
+
+#ifdef HAVE_ZLIB
+#include <zlib.h>
+
+static int testZipBound(void *pCtx, int nSrc){
+  return compressBound(nSrc);
+}
+
+static int testZipCompress(
+  void *pCtx,                     /* Context pointer */
+  char *aOut, int *pnOut,         /* OUT: Buffer containing compressed data */
+  const char *aIn, int nIn        /* Buffer containing input data */
+){
+  uLongf n = *pnOut;              /* In/out buffer size for compress() */
+  int rc;                         /* compress() return code */
+ 
+  rc = compress((Bytef*)aOut, &n, (Bytef*)aIn, nIn);
+  *pnOut = n;
+  return (rc==Z_OK ? 0 : LSM_ERROR);
+}
+
+static int testZipUncompress(
+  void *pCtx,                     /* Context pointer */
+  char *aOut, int *pnOut,         /* OUT: Buffer containing uncompressed data */
+  const char *aIn, int nIn        /* Buffer containing input data */
+){
+  uLongf n = *pnOut;              /* In/out buffer size for uncompress() */
+  int rc;                         /* uncompress() return code */
+
+  rc = uncompress((Bytef*)aOut, &n, (Bytef*)aIn, nIn);
+  *pnOut = n;
+  return (rc==Z_OK ? 0 : LSM_ERROR);
+}
+
+static int testConfigureCompression(lsm_db *pDb){
+  static lsm_compress zip = {
+    0,                            /* Context pointer (unused) */
+    1,                            /* Id value */
+    testZipBound,                 /* xBound method */
+    testZipCompress,              /* xCompress method */
+    testZipUncompress             /* xUncompress method */
+  };
+  return lsm_config(pDb, LSM_CONFIG_SET_COMPRESSION, &zip);
+}
+#endif /* ifdef HAVE_ZLIB */
+
+/*
+** End test compression hooks.
+**************************************************************************
+*************************************************************************/
+
+static int test_lsm_close(TestDb *pTestDb){
+  int i;
+  int rc = LSM_OK;
+  LsmDb *pDb = (LsmDb *)pTestDb;
+
+  lsm_csr_close(pDb->pCsr);
+  lsm_close(pDb->db);
+
+  /* If this is a multi-threaded database, wait on the worker threads. */
+  mt_shutdown(pDb);
+  for(i=0; i<pDb->nWorker && rc==LSM_OK; i++){
+    rc = pDb->aWorker[i].worker_rc;
+  }
+
+  for(i=0; i<pDb->aFile[0].nSector; i++){
+    testFree(pDb->aFile[0].aSector[i].aOld);
+  }
+  testFree(pDb->aFile[0].aSector);
+  for(i=0; i<pDb->aFile[1].nSector; i++){
+    testFree(pDb->aFile[1].aSector[i].aOld);
+  }
+  testFree(pDb->aFile[1].aSector);
+
+  memset(pDb, sizeof(LsmDb), 0x11);
+  testFree((char *)pDb->pBuf);
+  testFree((char *)pDb);
+  return rc;
+}
+
+static void mt_signal_worker(LsmDb*, int);
+
+static int waitOnCheckpointer(LsmDb *pDb, lsm_db *db){
+  int nSleep = 0;
+  int nKB;
+  int rc;
+
+  do {
+    nKB = 0;
+    rc = lsm_info(db, LSM_INFO_CHECKPOINT_SIZE, &nKB);
+    if( rc!=LSM_OK || nKB<pDb->nMtMaxCkpt ) break;
+#ifdef LSM_MUTEX_PTHREADS
+    mt_signal_worker(pDb, 
+        (pDb->eMode==LSMTEST_MODE_BACKGROUND_CKPT ? 0 : 1)
+    );
+#endif
+    usleep(5000);
+    nSleep += 5;
+  }while( 1 );
+
+#if 0
+    if( nSleep ) printf("# waitOnCheckpointer(): nSleep=%d\n", nSleep);
+#endif
+
+  return rc;
+}
+
+static int waitOnWorker(LsmDb *pDb){
+  int rc;
+  int nLimit = -1;
+  int nSleep = 0;
+
+  rc = lsm_config(pDb->db, LSM_CONFIG_AUTOFLUSH, &nLimit);
+  do {
+    int nOld, nNew, rc2;
+    rc2 = lsm_info(pDb->db, LSM_INFO_TREE_SIZE, &nOld, &nNew);
+    if( rc2!=LSM_OK ) return rc2;
+    if( nOld==0 || nNew<(nLimit/2) ) break;
+#ifdef LSM_MUTEX_PTHREADS
+    mt_signal_worker(pDb, 0);
+#endif
+    usleep(5000);
+    nSleep += 5;
+  }while( 1 );
+
+#if 0
+  if( nSleep ) printf("# waitOnWorker(): nSleep=%d\n", nSleep);
+#endif
+
+  return rc;
+}
+
+static int test_lsm_write(
+  TestDb *pTestDb, 
+  void *pKey, 
+  int nKey, 
+  void *pVal,
+  int nVal
+){
+  LsmDb *pDb = (LsmDb *)pTestDb;
+  int rc = LSM_OK;
+
+  if( pDb->eMode==LSMTEST_MODE_BACKGROUND_CKPT ){
+    rc = waitOnCheckpointer(pDb, pDb->db);
+  }else if( 
+      pDb->eMode==LSMTEST_MODE_BACKGROUND_WORK
+   || pDb->eMode==LSMTEST_MODE_BACKGROUND_BOTH 
+  ){
+    rc = waitOnWorker(pDb);
+  }
+
+  if( rc==LSM_OK ){
+    rc = lsm_insert(pDb->db, pKey, nKey, pVal, nVal);
+  }
+  return rc;
+}
+
+static int test_lsm_delete(TestDb *pTestDb, void *pKey, int nKey){
+  LsmDb *pDb = (LsmDb *)pTestDb;
+  return lsm_delete(pDb->db, pKey, nKey);
+}
+
+static int test_lsm_delete_range(
+  TestDb *pTestDb, 
+  void *pKey1, int nKey1,
+  void *pKey2, int nKey2
+){
+  LsmDb *pDb = (LsmDb *)pTestDb;
+  return lsm_delete_range(pDb->db, pKey1, nKey1, pKey2, nKey2);
+}
+
+static int test_lsm_fetch(
+  TestDb *pTestDb, 
+  void *pKey, 
+  int nKey, 
+  void **ppVal, 
+  int *pnVal
+){
+  int rc;
+  LsmDb *pDb = (LsmDb *)pTestDb;
+  lsm_cursor *csr;
+
+  if( pKey==0 ) return LSM_OK;
+
+  if( pDb->pCsr==0 ){
+    rc = lsm_csr_open(pDb->db, &csr);
+    if( rc!=LSM_OK ) return rc;
+  }else{
+    csr = pDb->pCsr;
+  }
+
+  rc = lsm_csr_seek(csr, pKey, nKey, LSM_SEEK_EQ);
+  if( rc==LSM_OK ){
+    if( lsm_csr_valid(csr) ){
+      const void *pVal; int nVal;
+      rc = lsm_csr_value(csr, &pVal, &nVal);
+      if( nVal>pDb->nBuf ){
+        testFree(pDb->pBuf);
+        pDb->pBuf = testMalloc(nVal*2);
+        pDb->nBuf = nVal*2;
+      }
+      memcpy(pDb->pBuf, pVal, nVal);
+      *ppVal = pDb->pBuf;
+      *pnVal = nVal;
+    }else{
+      *ppVal = 0;
+      *pnVal = -1;
+    }
+  }
+  if( pDb->pCsr==0 ){
+    lsm_csr_close(csr);
+  }
+  return rc;
+}
+
+static int test_lsm_scan(
+  TestDb *pTestDb,
+  void *pCtx,
+  int bReverse,
+  void *pFirst, int nFirst,
+  void *pLast, int nLast,
+  void (*xCallback)(void *, void *, int , void *, int)
+){
+  LsmDb *pDb = (LsmDb *)pTestDb;
+  lsm_cursor *csr;
+  lsm_cursor *csr2 = 0;
+  int rc;
+
+  if( pDb->pCsr==0 ){
+    rc = lsm_csr_open(pDb->db, &csr);
+    if( rc!=LSM_OK ) return rc;
+  }else{
+    rc = LSM_OK;
+    csr = pDb->pCsr;
+  }
+
+  /* To enhance testing, if both pLast and pFirst are defined, seek the
+  ** cursor to the "end" boundary here. Then the next block seeks it to
+  ** the "start" ready for the scan. The point is to test that cursors
+  ** can be reused.  */
+  if( pLast && pFirst ){
+    if( bReverse ){
+      rc = lsm_csr_seek(csr, pFirst, nFirst, LSM_SEEK_LE);
+    }else{
+      rc = lsm_csr_seek(csr, pLast, nLast, LSM_SEEK_GE);
+    }
+  }
+
+  if( bReverse ){
+    if( pLast ){
+      rc = lsm_csr_seek(csr, pLast, nLast, LSM_SEEK_LE);
+    }else{
+      rc = lsm_csr_last(csr);
+    }
+  }else{
+    if( pFirst ){
+      rc = lsm_csr_seek(csr, pFirst, nFirst, LSM_SEEK_GE);
+    }else{
+      rc = lsm_csr_first(csr);
+    }
+  }
+
+  while( rc==LSM_OK && lsm_csr_valid(csr) ){
+    const void *pKey; int nKey;
+    const void *pVal; int nVal;
+    int cmp;
+
+    lsm_csr_key(csr, &pKey, &nKey);
+    lsm_csr_value(csr, &pVal, &nVal);
+
+    if( bReverse && pFirst ){
+      cmp = memcmp(pFirst, pKey, MIN(nKey, nFirst));
+      if( cmp>0 || (cmp==0 && nFirst>nKey) ) break;
+    }else if( bReverse==0 && pLast ){
+      cmp = memcmp(pLast, pKey, MIN(nKey, nLast));
+      if( cmp<0 || (cmp==0 && nLast<nKey) ) break;
+    }
+
+    xCallback(pCtx, (void *)pKey, nKey, (void *)pVal, nVal);
+
+    if( bReverse ){
+      rc = lsm_csr_prev(csr);
+    }else{
+      rc = lsm_csr_next(csr);
+    }
+  }
+
+  if( pDb->pCsr==0 ){
+    lsm_csr_close(csr);
+  }
+  return rc;
+}
+
+static int test_lsm_begin(TestDb *pTestDb, int iLevel){
+  int rc = LSM_OK;
+  LsmDb *pDb = (LsmDb *)pTestDb;
+
+  /* iLevel==0 is a no-op. */
+  if( iLevel==0 ) return 0;
+
+  if( pDb->pCsr==0 ) rc = lsm_csr_open(pDb->db, &pDb->pCsr);
+  if( rc==LSM_OK && iLevel>1 ){
+    rc = lsm_begin(pDb->db, iLevel-1);
+  }
+
+  return rc;
+}
+static int test_lsm_commit(TestDb *pTestDb, int iLevel){
+  LsmDb *pDb = (LsmDb *)pTestDb;
+
+  /* If iLevel==0, close any open read transaction */
+  if( iLevel==0 && pDb->pCsr ){
+    lsm_csr_close(pDb->pCsr);
+    pDb->pCsr = 0;
+  }
+
+  /* If iLevel==0, close any open read transaction */
+  return lsm_commit(pDb->db, MAX(0, iLevel-1));
+}
+static int test_lsm_rollback(TestDb *pTestDb, int iLevel){
+  LsmDb *pDb = (LsmDb *)pTestDb;
+
+  /* If iLevel==0, close any open read transaction */
+  if( iLevel==0 && pDb->pCsr ){
+    lsm_csr_close(pDb->pCsr);
+    pDb->pCsr = 0;
+  }
+
+  return lsm_rollback(pDb->db, MAX(0, iLevel-1));
+}
+
+/*
+** A log message callback registered with lsm connections. Prints all 
+** messages to stderr.
+*/
+static void xLog(void *pCtx, int rc, const char *z){
+  unused_parameter(rc);
+  /* fprintf(stderr, "lsm: rc=%d \"%s\"\n", rc, z); */
+  if( pCtx ) fprintf(stderr, "%s: ", (char *)pCtx);
+  fprintf(stderr, "%s\n", z);
+  fflush(stderr);
+}
+
+static void xWorkHook(lsm_db *db, void *pArg){
+  LsmDb *p = (LsmDb *)pArg;
+  if( p->xWork ) p->xWork(db, p->pWorkCtx);
+}
+
+#define TEST_NO_RECOVERY -1
+#define TEST_COMPRESSION -3
+
+#define TEST_MT_MODE     -2
+#define TEST_MT_MIN_CKPT -4
+#define TEST_MT_MAX_CKPT -5
+
+
+int test_lsm_config_str(
+  LsmDb *pLsm,
+  lsm_db *db, 
+  int bWorker,
+  const char *zStr,
+  int *pnThread
+){
+  struct CfgParam {
+    const char *zParam;
+    int bWorker;
+    int eParam;
+  } aParam[] = {
+    { "autoflush",        0, LSM_CONFIG_AUTOFLUSH },
+    { "page_size",        0, LSM_CONFIG_PAGE_SIZE },
+    { "block_size",       0, LSM_CONFIG_BLOCK_SIZE },
+    { "safety",           0, LSM_CONFIG_SAFETY },
+    { "autowork",         0, LSM_CONFIG_AUTOWORK },
+    { "autocheckpoint",   0, LSM_CONFIG_AUTOCHECKPOINT },
+    { "mmap",             0, LSM_CONFIG_MMAP },
+    { "use_log",          0, LSM_CONFIG_USE_LOG },
+    { "automerge",        0, LSM_CONFIG_AUTOMERGE },
+    { "max_freelist",     0, LSM_CONFIG_MAX_FREELIST },
+    { "multi_proc",       0, LSM_CONFIG_MULTIPLE_PROCESSES },
+    { "worker_automerge", 1, LSM_CONFIG_AUTOMERGE },
+    { "test_no_recovery", 0, TEST_NO_RECOVERY },
+    { "bg_min_ckpt",      0, TEST_NO_RECOVERY },
+
+    { "mt_mode",          0, TEST_MT_MODE },
+    { "mt_min_ckpt",      0, TEST_MT_MIN_CKPT },
+    { "mt_max_ckpt",      0, TEST_MT_MAX_CKPT },
+
+#ifdef HAVE_ZLIB
+    { "compression",      0, TEST_COMPRESSION },
+#endif
+    { 0, 0 }
+  };
+  const char *z = zStr;
+  int nThread = 1;
+
+  if( zStr==0 ) return 0;
+
+  assert( db );
+  while( z[0] ){
+    const char *zStart;
+
+    /* Skip whitespace */
+    while( *z==' ' ) z++;
+    zStart = z;
+
+    while( *z && *z!='=' ) z++;
+    if( *z ){
+      int eParam;
+      int i;
+      int iVal;
+      int iMul = 1;
+      int rc;
+      char zParam[32];
+      int nParam = z-zStart;
+      if( nParam==0 || nParam>sizeof(zParam)-1 ) goto syntax_error;
+
+      memcpy(zParam, zStart, nParam);
+      zParam[nParam] = '\0';
+      rc = testArgSelect(aParam, "param", zParam, &i);
+      if( rc!=0 ) return rc;
+      eParam = aParam[i].eParam;
+
+      z++;
+      zStart = z;
+      while( *z>='0' && *z<='9' ) z++;
+      if( *z=='k' || *z=='K' ){
+        iMul = 1;
+        z++;
+      }else if( *z=='M' || *z=='M' ){
+        iMul = 1024;
+        z++;
+      }
+      nParam = z-zStart;
+      if( nParam==0 || nParam>sizeof(zParam)-1 ) goto syntax_error;
+      memcpy(zParam, zStart, nParam);
+      zParam[nParam] = '\0';
+      iVal = atoi(zParam) * iMul;
+
+      if( eParam>0 ){
+        if( bWorker || aParam[i].bWorker==0 ){
+          lsm_config(db, eParam, &iVal);
+        }
+      }else{
+        switch( eParam ){
+          case TEST_NO_RECOVERY:
+            if( pLsm ) pLsm->bNoRecovery = iVal;
+            break;
+          case TEST_MT_MODE:
+            if( pLsm ) nThread = iVal;
+            break;
+          case TEST_MT_MIN_CKPT:
+            if( pLsm && iVal>0 ) pLsm->nMtMinCkpt = iVal*1024;
+            break;
+          case TEST_MT_MAX_CKPT:
+            if( pLsm && iVal>0 ) pLsm->nMtMaxCkpt = iVal*1024;
+            break;
+#ifdef HAVE_ZLIB
+          case TEST_COMPRESSION:
+            testConfigureCompression(db);
+            break;
+#endif
+        }
+      }
+    }else if( z!=zStart ){
+      goto syntax_error;
+    }
+  }
+
+  if( pnThread ) *pnThread = nThread;
+  if( pLsm && pLsm->nMtMaxCkpt < pLsm->nMtMinCkpt ){
+    pLsm->nMtMinCkpt = pLsm->nMtMaxCkpt;
+  }
+
+  return 0;
+ syntax_error:
+  testPrintError("syntax error at: \"%s\"\n", z);
+  return 1;
+}
+
+int tdb_lsm_config_str(TestDb *pDb, const char *zStr){
+  int rc = 0;
+  if( tdb_lsm(pDb) ){
+#ifdef LSM_MUTEX_PTHREADS
+    int i;
+#endif
+    LsmDb *pLsm = (LsmDb *)pDb;
+
+    rc = test_lsm_config_str(pLsm, pLsm->db, 0, zStr, 0);
+#ifdef LSM_MUTEX_PTHREADS
+    for(i=0; rc==0 && i<pLsm->nWorker; i++){
+      rc = test_lsm_config_str(0, pLsm->aWorker[i].pWorker, 1, zStr, 0);
+    }
+#endif
+  }
+  return rc;
+}
+
+int tdb_lsm_configure(lsm_db *db, const char *zConfig){
+  return test_lsm_config_str(0, db, 0, zConfig, 0);
+}
+
+static int testLsmStartWorkers(LsmDb *, int, const char *, const char *);
+
+static int testLsmOpen(
+  const char *zCfg,
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  static const DatabaseMethods LsmMethods = {
+    test_lsm_close,
+    test_lsm_write,
+    test_lsm_delete,
+    test_lsm_delete_range,
+    test_lsm_fetch,
+    test_lsm_scan,
+    test_lsm_begin,
+    test_lsm_commit,
+    test_lsm_rollback
+  };
+
+  int rc;
+  int nFilename;
+  LsmDb *pDb;
+
+  /* If the bClear flag is set, delete any existing database. */
+  assert( zFilename);
+  if( bClear ) testDeleteLsmdb(zFilename);
+  nFilename = strlen(zFilename);
+
+  pDb = (LsmDb *)testMalloc(sizeof(LsmDb) + nFilename + 1);
+  memset(pDb, 0, sizeof(LsmDb));
+  pDb->base.pMethods = &LsmMethods;
+  pDb->zName = (char *)&pDb[1];
+  memcpy(pDb->zName, zFilename, nFilename + 1);
+
+  /* Default the sector size used for crash simulation to 512 bytes. 
+  ** Todo: There should be an OS method to obtain this value - just as
+  ** there is in SQLite. For now, LSM assumes that it is smaller than
+  ** the page size (default 4KB).
+  */
+  pDb->szSector = 256;
+
+  /* Default values for the mt_min_ckpt and mt_max_ckpt parameters. */
+  pDb->nMtMinCkpt = LSMTEST_DFLT_MT_MIN_CKPT;
+  pDb->nMtMaxCkpt = LSMTEST_DFLT_MT_MAX_CKPT;
+
+  memcpy(&pDb->env, tdb_lsm_env(), sizeof(lsm_env));
+  pDb->env.pVfsCtx = (void *)pDb;
+  pDb->env.xFullpath = testEnvFullpath;
+  pDb->env.xOpen = testEnvOpen;
+  pDb->env.xRead = testEnvRead;
+  pDb->env.xWrite = testEnvWrite;
+  pDb->env.xTruncate = testEnvTruncate;
+  pDb->env.xSync = testEnvSync;
+  pDb->env.xSectorSize = testEnvSectorSize;
+  pDb->env.xRemap = testEnvRemap;
+  pDb->env.xFileid = testEnvFileid;
+  pDb->env.xClose = testEnvClose;
+  pDb->env.xUnlink = testEnvUnlink;
+  pDb->env.xLock = testEnvLock;
+  pDb->env.xTestLock = testEnvTestLock;
+  pDb->env.xShmBarrier = testEnvShmBarrier;
+  pDb->env.xShmMap = testEnvShmMap;
+  pDb->env.xShmUnmap = testEnvShmUnmap;
+  pDb->env.xSleep = testEnvSleep;
+
+  rc = lsm_new(&pDb->env, &pDb->db);
+  if( rc==LSM_OK ){
+    int nThread = 1;
+    lsm_config_log(pDb->db, xLog, 0);
+    lsm_config_work_hook(pDb->db, xWorkHook, (void *)pDb);
+
+    rc = test_lsm_config_str(pDb, pDb->db, 0, zCfg, &nThread);
+    if( rc==LSM_OK ) rc = lsm_open(pDb->db, zFilename);
+
+    pDb->eMode = nThread;
+#ifdef LSM_MUTEX_PTHREADS
+    if( rc==LSM_OK && nThread>1 ){
+      testLsmStartWorkers(pDb, nThread, zFilename, zCfg);
+    }
+#endif
+
+    if( rc!=LSM_OK ){
+      test_lsm_close((TestDb *)pDb);
+      pDb = 0;
+    }
+  }
+
+  *ppDb = (TestDb *)pDb;
+  return rc;
+}
+
+int test_lsm_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  return testLsmOpen(zSpec, zFilename, bClear, ppDb);
+}
+
+int test_lsm_small_open(
+  const char *zSpec, 
+  const char *zFile, 
+  int bClear, 
+  TestDb **ppDb
+){
+  const char *zCfg = "page_size=256 block_size=64 mmap=1024";
+  return testLsmOpen(zCfg, zFile, bClear, ppDb);
+}
+
+int test_lsm_lomem_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+    /* "max_freelist=4 autocheckpoint=32" */
+  const char *zCfg = 
+    "page_size=256 block_size=64 autoflush=16 "
+    "autocheckpoint=32"
+    "mmap=0 "
+  ;
+  return testLsmOpen(zCfg, zFilename, bClear, ppDb);
+}
+
+int test_lsm_lomem2_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+    /* "max_freelist=4 autocheckpoint=32" */
+  const char *zCfg = 
+    "page_size=512 block_size=64 autoflush=0 mmap=0 "
+  ;
+  return testLsmOpen(zCfg, zFilename, bClear, ppDb);
+}
+
+int test_lsm_zip_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  const char *zCfg = 
+    "page_size=256 block_size=64 autoflush=16 "
+    "autocheckpoint=32 compression=1 mmap=0 "
+  ;
+  return testLsmOpen(zCfg, zFilename, bClear, ppDb);
+}
+
+lsm_db *tdb_lsm(TestDb *pDb){
+  if( pDb->pMethods->xClose==test_lsm_close ){
+    return ((LsmDb *)pDb)->db;
+  }
+  return 0;
+}
+
+int tdb_lsm_multithread(TestDb *pDb){
+  int ret = 0;
+  if( tdb_lsm(pDb) ){
+    ret = ((LsmDb*)pDb)->eMode!=LSMTEST_MODE_SINGLETHREAD;
+  }
+  return ret;
+}
+
+void tdb_lsm_enable_log(TestDb *pDb, int bEnable){
+  lsm_db *db = tdb_lsm(pDb);
+  if( db ){
+    lsm_config_log(db, (bEnable ? xLog : 0), (void *)"client");
+  }
+}
+
+void tdb_lsm_application_crash(TestDb *pDb){
+  if( tdb_lsm(pDb) ){
+    LsmDb *p = (LsmDb *)pDb;
+    p->bCrashed = 1;
+  }
+}
+
+void tdb_lsm_prepare_system_crash(TestDb *pDb){
+  if( tdb_lsm(pDb) ){
+    LsmDb *p = (LsmDb *)pDb;
+    p->bPrepareCrash = 1;
+  }
+}
+
+void tdb_lsm_system_crash(TestDb *pDb){
+  if( tdb_lsm(pDb) ){
+    LsmDb *p = (LsmDb *)pDb;
+    p->bCrashed = 1;
+    doSystemCrash(p);
+  }
+}
+
+void tdb_lsm_safety(TestDb *pDb, int eMode){
+  assert( eMode==LSM_SAFETY_OFF 
+       || eMode==LSM_SAFETY_NORMAL 
+       || eMode==LSM_SAFETY_FULL 
+  );
+  if( tdb_lsm(pDb) ){
+    int iParam = eMode;
+    LsmDb *p = (LsmDb *)pDb;
+    lsm_config(p->db, LSM_CONFIG_SAFETY, &iParam);
+  }
+}
+
+void tdb_lsm_prepare_sync_crash(TestDb *pDb, int iSync){
+  assert( iSync>0 );
+  if( tdb_lsm(pDb) ){
+    LsmDb *p = (LsmDb *)pDb;
+    p->nAutoCrash = iSync;
+    p->bPrepareCrash = 1;
+  }
+}
+
+void tdb_lsm_config_work_hook(
+  TestDb *pDb, 
+  void (*xWork)(lsm_db *, void *), 
+  void *pWorkCtx
+){
+  if( tdb_lsm(pDb) ){
+    LsmDb *p = (LsmDb *)pDb;
+    p->xWork = xWork;
+    p->pWorkCtx = pWorkCtx;
+  }
+}
+
+void tdb_lsm_write_hook(
+  TestDb *pDb, 
+  void (*xWrite)(void *, int, lsm_i64, int, int),
+  void *pWriteCtx
+){
+  if( tdb_lsm(pDb) ){
+    LsmDb *p = (LsmDb *)pDb;
+    p->xWriteHook = xWrite;
+    p->pWriteCtx = pWriteCtx;
+  }
+}
+
+int tdb_lsm_open(const char *zCfg, const char *zDb, int bClear, TestDb **ppDb){
+  return testLsmOpen(zCfg, zDb, bClear, ppDb);
+}
+
+#ifdef LSM_MUTEX_PTHREADS
+
+/*
+** Signal worker thread iWorker that there may be work to do.
+*/
+static void mt_signal_worker(LsmDb *pDb, int iWorker){
+  LsmWorker *p = &pDb->aWorker[iWorker];
+  pthread_mutex_lock(&p->worker_mutex);
+  p->bDoWork = 1;
+  pthread_cond_signal(&p->worker_cond);
+  pthread_mutex_unlock(&p->worker_mutex);
+}
+
+/*
+** This routine is used as the main() for all worker threads.
+*/
+static void *worker_main(void *pArg){
+  LsmWorker *p = (LsmWorker *)pArg;
+  lsm_db *pWorker;                /* Connection to access db through */
+
+  pthread_mutex_lock(&p->worker_mutex);
+  while( (pWorker = p->pWorker) ){
+    int rc = LSM_OK;
+
+    /* Do some work. If an error occurs, exit. */
+
+    pthread_mutex_unlock(&p->worker_mutex);
+    if( p->eType==LSMTEST_THREAD_CKPT ){
+      int nKB = 0;
+      rc = lsm_info(pWorker, LSM_INFO_CHECKPOINT_SIZE, &nKB);
+      if( rc==LSM_OK && nKB>=p->pDb->nMtMinCkpt ){
+        rc = lsm_checkpoint(pWorker, 0);
+      }
+    }else{
+      int nWrite;
+      do {
+
+        if( p->eType==LSMTEST_THREAD_WORKER ){
+          waitOnCheckpointer(p->pDb, pWorker);
+        }
+
+        nWrite = 0;
+        rc = lsm_work(pWorker, 0, 256, &nWrite);
+
+        if( p->eType==LSMTEST_THREAD_WORKER && nWrite ){
+          mt_signal_worker(p->pDb, 1);
+        }
+      }while( nWrite && p->pWorker );
+    }
+    pthread_mutex_lock(&p->worker_mutex);
+
+    if( rc!=LSM_OK && rc!=LSM_BUSY ){
+      p->worker_rc = rc;
+      break;
+    }
+
+    /* The thread will wake up when it is signaled either because another
+    ** thread has created some work for this one or because the connection
+    ** is being closed.  */
+    if( p->pWorker && p->bDoWork==0 ){
+      pthread_cond_wait(&p->worker_cond, &p->worker_mutex);
+    }
+    p->bDoWork = 0;
+  }
+  pthread_mutex_unlock(&p->worker_mutex);
+  
+  return 0;
+}
+
+
+static void mt_stop_worker(LsmDb *pDb, int iWorker){
+  LsmWorker *p = &pDb->aWorker[iWorker];
+  if( p->pWorker ){
+    void *pDummy;
+    lsm_db *pWorker;
+
+    /* Signal the worker to stop */
+    pthread_mutex_lock(&p->worker_mutex);
+    pWorker = p->pWorker;
+    p->pWorker = 0;
+    pthread_cond_signal(&p->worker_cond);
+    pthread_mutex_unlock(&p->worker_mutex);
+
+    /* Join the worker thread. */
+    pthread_join(p->worker_thread, &pDummy);
+
+    /* Free resources allocated in mt_start_worker() */
+    pthread_cond_destroy(&p->worker_cond);
+    pthread_mutex_destroy(&p->worker_mutex);
+    lsm_close(pWorker);
+  }
+}
+
+static void mt_shutdown(LsmDb *pDb){
+  int i;
+  for(i=0; i<pDb->nWorker; i++){
+    mt_stop_worker(pDb, i);
+  }
+}
+
+/*
+** This callback is invoked by LSM when the client database writes to
+** the database file (i.e. to flush the contents of the in-memory tree).
+** This implies there may be work to do on the database, so signal
+** the worker threads.
+*/
+static void mt_client_work_hook(lsm_db *db, void *pArg){
+  LsmDb *pDb = (LsmDb *)pArg;     /* LsmDb database handle */
+
+  /* Invoke the user level work-hook, if any. */
+  if( pDb->xWork ) pDb->xWork(db, pDb->pWorkCtx);
+
+  /* Wake up worker thread 0. */
+  mt_signal_worker(pDb, 0);
+}
+
+static void mt_worker_work_hook(lsm_db *db, void *pArg){
+  LsmDb *pDb = (LsmDb *)pArg;     /* LsmDb database handle */
+
+  /* Invoke the user level work-hook, if any. */
+  if( pDb->xWork ) pDb->xWork(db, pDb->pWorkCtx);
+}
+
+/*
+** Launch worker thread iWorker for database connection pDb.
+*/
+static int mt_start_worker(
+  LsmDb *pDb,                     /* Main database structure */
+  int iWorker,                    /* Worker number to start */
+  const char *zFilename,          /* File name of database to open */
+  const char *zCfg,               /* Connection configuration string */
+  int eType                       /* Type of worker thread */
+){
+  int rc = 0;                     /* Return code */
+  LsmWorker *p;                   /* Object to initialize */
+
+  assert( iWorker<pDb->nWorker );
+  assert( eType==LSMTEST_THREAD_CKPT 
+       || eType==LSMTEST_THREAD_WORKER 
+       || eType==LSMTEST_THREAD_WORKER_AC 
+  );
+
+  p = &pDb->aWorker[iWorker];
+  p->eType = eType;
+  p->pDb = pDb;
+
+  /* Open the worker connection */
+  if( rc==0 ) rc = lsm_new(&pDb->env, &p->pWorker);
+  if( zCfg ){
+    test_lsm_config_str(pDb, p->pWorker, 1, zCfg, 0);
+  }
+  if( rc==0 ) rc = lsm_open(p->pWorker, zFilename);
+  lsm_config_log(p->pWorker, xLog, (void *)"worker");
+
+  /* Configure the work-hook */
+  if( rc==0 ){
+    lsm_config_work_hook(p->pWorker, mt_worker_work_hook, (void *)pDb);
+  }
+
+  if( eType==LSMTEST_THREAD_WORKER ){
+    test_lsm_config_str(0, p->pWorker, 1, "autocheckpoint=0", 0);
+  }
+
+  /* Kick off the worker thread. */
+  if( rc==0 ) rc = pthread_cond_init(&p->worker_cond, 0);
+  if( rc==0 ) rc = pthread_mutex_init(&p->worker_mutex, 0);
+  if( rc==0 ) rc = pthread_create(&p->worker_thread, 0, worker_main, (void *)p);
+
+  return rc;
+}
+
+
+static int testLsmStartWorkers(
+  LsmDb *pDb, int eModel, const char *zFilename, const char *zCfg
+){
+  int rc;
+
+  if( eModel<1 || eModel>4 ) return 1;
+  if( eModel==1 ) return 0;
+
+  /* Configure a work-hook for the client connection. Worker 0 is signalled
+  ** every time the users connection writes to the database.  */
+  lsm_config_work_hook(pDb->db, mt_client_work_hook, (void *)pDb);
+
+  /* Allocate space for two worker connections. They may not both be
+  ** used, but both are allocated.  */
+  pDb->aWorker = (LsmWorker *)testMalloc(sizeof(LsmWorker) * 2);
+  memset(pDb->aWorker, 0, sizeof(LsmWorker) * 2);
+
+  switch( eModel ){
+    case LSMTEST_MODE_BACKGROUND_CKPT:
+      pDb->nWorker = 1;
+      test_lsm_config_str(0, pDb->db, 0, "autocheckpoint=0", 0);
+      rc = mt_start_worker(pDb, 0, zFilename, zCfg, LSMTEST_THREAD_CKPT);
+      break;
+
+    case LSMTEST_MODE_BACKGROUND_WORK:
+      pDb->nWorker = 1;
+      test_lsm_config_str(0, pDb->db, 0, "autowork=0", 0);
+      rc = mt_start_worker(pDb, 0, zFilename, zCfg, LSMTEST_THREAD_WORKER_AC);
+      break;
+
+    case LSMTEST_MODE_BACKGROUND_BOTH:
+      pDb->nWorker = 2;
+      test_lsm_config_str(0, pDb->db, 0, "autowork=0", 0);
+      rc = mt_start_worker(pDb, 0, zFilename, zCfg, LSMTEST_THREAD_WORKER);
+      if( rc==0 ){
+        rc = mt_start_worker(pDb, 1, zFilename, zCfg, LSMTEST_THREAD_CKPT);
+      }
+      break;
+  }
+
+  return rc;
+}
+
+
+int test_lsm_mt2(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  const char *zCfg = "mt_mode=2";
+  return testLsmOpen(zCfg, zFilename, bClear, ppDb);
+}
+
+int test_lsm_mt3(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  const char *zCfg = "mt_mode=4";
+  return testLsmOpen(zCfg, zFilename, bClear, ppDb);
+}
+
+#else
+static void mt_shutdown(LsmDb *pDb) { 
+  unused_parameter(pDb); 
+}
+int test_lsm_mt(const char *zFilename, int bClear, TestDb **ppDb){
+  unused_parameter(zFilename);
+  unused_parameter(bClear);
+  unused_parameter(ppDb);
+  testPrintError("threads unavailable - recompile with LSM_MUTEX_PTHREADS\n");
+  return 1;
+}
+#endif

local-test-sqlite3-delta-02/afc-sqlite3/ext/lsm1/lsm-test/lsmtest_tdb4.c

@@ -0,0 +1,980 @@
+
+/*
+** This file contains the TestDb bt wrapper.
+*/
+
+#include "lsmtest_tdb.h"
+#include "lsmtest.h"
+#include <unistd.h>
+#include "bt.h"
+
+#include <pthread.h>
+
+typedef struct BtDb BtDb;
+typedef struct BtFile BtFile;
+
+/* Background checkpointer interface (see implementations below). */
+typedef struct bt_ckpter bt_ckpter;
+static int bgc_attach(BtDb *pDb, const char*);
+static int bgc_detach(BtDb *pDb);
+
+/*
+** Each database or log file opened by a database handle is wrapped by
+** an object of the following type.
+*/
+struct BtFile {
+  BtDb *pBt;                      /* Database handle that opened this file */
+  bt_env *pVfs;                   /* Underlying VFS */
+  bt_file *pFile;                 /* File handle belonging to underlying VFS */
+  int nSectorSize;                /* Size of sectors in bytes */
+  int nSector;                    /* Allocated size of nSector array */
+  u8 **apSector;                  /* Original sector data */
+};
+
+/*
+** nCrashSync:
+**   If this value is non-zero, then a "crash-test" is running. If
+**   nCrashSync==1, then the crash is simulated during the very next 
+**   call to the xSync() VFS method (on either the db or log file).
+**   If nCrashSync==2, the following call to xSync(), and so on.
+**
+** bCrash:
+**   After a crash is simulated, this variable is set. Any subsequent
+**   attempts to write to a file or modify the file system in any way 
+**   fail once this is set. All the caller can do is close the connection.
+**
+** bFastInsert:
+**   If this variable is set to true, then a BT_CONTROL_FAST_INSERT_OP
+**   control is issued before each callto BtReplace() or BtCsrOpen().
+*/
+struct BtDb {
+  TestDb base;                    /* Base class */
+  bt_db *pBt;                     /* bt database handle */
+  sqlite4_env *pEnv;              /* SQLite environment (for malloc/free) */
+  bt_env *pVfs;                   /* Underlying VFS */
+  int bFastInsert;                /* True to use fast-insert */
+
+  /* Space for bt_fetch() results */
+  u8 *aBuffer;                    /* Space to store results */
+  int nBuffer;                    /* Allocated size of aBuffer[] in bytes */
+  int nRef;
+
+  /* Background checkpointer used by mt connections */
+  bt_ckpter *pCkpter;
+
+  /* Stuff used for crash test simulation */
+  BtFile *apFile[2];              /* Database and log files used by pBt */
+  bt_env env;                     /* Private VFS for this object */
+  int nCrashSync;                 /* Number of syncs until crash (see above) */
+  int bCrash;                     /* True once a crash has been simulated */
+};
+
+static int btVfsFullpath(
+  sqlite4_env *pEnv, 
+  bt_env *pVfs, 
+  const char *z, 
+  char **pzOut
+){
+  BtDb *pBt = (BtDb*)pVfs->pVfsCtx;
+  if( pBt->bCrash ) return SQLITE4_IOERR;
+  return pBt->pVfs->xFullpath(pEnv, pBt->pVfs, z, pzOut);
+}
+
+static int btVfsOpen(
+  sqlite4_env *pEnv, 
+  bt_env *pVfs, 
+  const char *zFile, 
+  int flags, bt_file **ppFile
+){
+  BtFile *p;
+  BtDb *pBt = (BtDb*)pVfs->pVfsCtx;
+  int rc;
+
+  if( pBt->bCrash ) return SQLITE4_IOERR;
+
+  p = (BtFile*)testMalloc(sizeof(BtFile));
+  if( !p ) return SQLITE4_NOMEM;
+  if( flags & BT_OPEN_DATABASE ){
+    pBt->apFile[0] = p;
+  }else if( flags & BT_OPEN_LOG ){
+    pBt->apFile[1] = p;
+  }
+  if( (flags & BT_OPEN_SHARED)==0 ){
+    p->pBt = pBt; 
+  }
+  p->pVfs = pBt->pVfs; 
+
+  rc = pBt->pVfs->xOpen(pEnv, pVfs, zFile, flags, &p->pFile);
+  if( rc!=SQLITE4_OK ){
+    testFree(p);
+    p = 0;
+  }else{
+    pBt->nRef++;
+  }
+
+  *ppFile = (bt_file*)p;
+  return rc;
+}
+
+static int btVfsSize(bt_file *pFile, sqlite4_int64 *piRes){
+  BtFile *p = (BtFile*)pFile;
+  if( p->pBt && p->pBt->bCrash ) return SQLITE4_IOERR;
+  return p->pVfs->xSize(p->pFile, piRes);
+}
+
+static int btVfsRead(bt_file *pFile, sqlite4_int64 iOff, void *pBuf, int nBuf){
+  BtFile *p = (BtFile*)pFile;
+  if( p->pBt && p->pBt->bCrash ) return SQLITE4_IOERR;
+  return p->pVfs->xRead(p->pFile, iOff, pBuf, nBuf);
+}
+
+static int btFlushSectors(BtFile *p, int iFile){
+  sqlite4_int64 iSz;
+  int rc;
+  int i;
+  u8 *aTmp = 0;
+
+  rc = p->pBt->pVfs->xSize(p->pFile, &iSz);
+  for(i=0; rc==SQLITE4_OK && i<p->nSector; i++){
+    if( p->pBt->bCrash && p->apSector[i] ){
+
+      /* The system is simulating a crash. There are three choices for
+      ** this sector:
+      **
+      **   1) Leave it as it is (simulating a successful write),
+      **   2) Restore the original data (simulating a lost write),
+      **   3) Populate the disk sector with garbage data.
+      */
+      sqlite4_int64 iSOff = p->nSectorSize*i;
+      int nWrite = MIN(p->nSectorSize, iSz - iSOff);
+
+      if( nWrite ){
+        u8 *aWrite = 0;
+        int iOpt = (testPrngValue(i) % 3) + 1;
+        if( iOpt==1 ){
+          aWrite = p->apSector[i];
+        }else if( iOpt==3 ){
+          if( aTmp==0 ) aTmp = testMalloc(p->nSectorSize);
+          aWrite = aTmp;
+          testPrngArray(i*13, (u32*)aWrite, nWrite/sizeof(u32));
+        }
+
+#if 0
+fprintf(stderr, "handle sector %d of %s with %s\n", i, 
+    iFile==0 ? "db" : "log",
+    iOpt==1 ? "rollback" : iOpt==2 ? "write" : "omit"
+);
+fflush(stderr);
+#endif
+
+        if( aWrite ){
+          rc = p->pBt->pVfs->xWrite(p->pFile, iSOff, aWrite, nWrite);
+        }
+      }
+    }
+    testFree(p->apSector[i]);
+    p->apSector[i] = 0;
+  }
+
+  testFree(aTmp);
+  return rc;
+}
+
+static int btSaveSectors(BtFile *p, sqlite4_int64 iOff, int nBuf){
+  int rc;
+  sqlite4_int64 iSz;              /* Size of file on disk */
+  int iFirst;                     /* First sector affected */
+  int iSector;                    /* Current sector */
+  int iLast;                      /* Last sector affected */
+
+  if( p->nSectorSize==0 ){
+    p->nSectorSize = p->pBt->pVfs->xSectorSize(p->pFile);
+    if( p->nSectorSize<512 ) p->nSectorSize = 512;
+  }
+  iLast = (iOff+nBuf-1) / p->nSectorSize;
+  iFirst = iOff / p->nSectorSize;
+
+  rc = p->pBt->pVfs->xSize(p->pFile, &iSz);
+  for(iSector=iFirst; rc==SQLITE4_OK && iSector<=iLast; iSector++){
+    int nRead;
+    sqlite4_int64 iSOff = iSector * p->nSectorSize;
+    u8 *aBuf = testMalloc(p->nSectorSize);
+    nRead = MIN(p->nSectorSize, (iSz - iSOff));
+    if( nRead>0 ){
+      rc = p->pBt->pVfs->xRead(p->pFile, iSOff, aBuf, nRead);
+    }
+
+    while( rc==SQLITE4_OK && iSector>=p->nSector ){
+      int nNew = p->nSector + 32;
+      u8 **apNew = (u8**)testMalloc(nNew * sizeof(u8*));
+      memcpy(apNew, p->apSector, p->nSector*sizeof(u8*));
+      testFree(p->apSector);
+      p->apSector = apNew;
+      p->nSector = nNew;
+    }
+
+    p->apSector[iSector] = aBuf;
+  }
+
+  return rc;
+}
+
+static int btVfsWrite(bt_file *pFile, sqlite4_int64 iOff, void *pBuf, int nBuf){
+  BtFile *p = (BtFile*)pFile;
+  if( p->pBt && p->pBt->bCrash ) return SQLITE4_IOERR;
+  if( p->pBt && p->pBt->nCrashSync ){
+    btSaveSectors(p, iOff, nBuf);
+  }
+  return p->pVfs->xWrite(p->pFile, iOff, pBuf, nBuf);
+}
+
+static int btVfsTruncate(bt_file *pFile, sqlite4_int64 iOff){
+  BtFile *p = (BtFile*)pFile;
+  if( p->pBt && p->pBt->bCrash ) return SQLITE4_IOERR;
+  return p->pVfs->xTruncate(p->pFile, iOff);
+}
+
+static int btVfsSync(bt_file *pFile){
+  int rc = SQLITE4_OK;
+  BtFile *p = (BtFile*)pFile;
+  BtDb *pBt = p->pBt;
+
+  if( pBt ){
+    if( pBt->bCrash ) return SQLITE4_IOERR;
+    if( pBt->nCrashSync ){
+      pBt->nCrashSync--;
+      pBt->bCrash = (pBt->nCrashSync==0);
+      if( pBt->bCrash ){
+        btFlushSectors(pBt->apFile[0], 0);
+        btFlushSectors(pBt->apFile[1], 1);
+        rc = SQLITE4_IOERR;
+      }else{
+        btFlushSectors(p, 0);
+      }
+    }
+  }
+
+  if( rc==SQLITE4_OK ){
+    rc = p->pVfs->xSync(p->pFile);
+  }
+  return rc;
+}
+
+static int btVfsSectorSize(bt_file *pFile){
+  BtFile *p = (BtFile*)pFile;
+  return p->pVfs->xSectorSize(p->pFile);
+}
+
+static void btDeref(BtDb *p){
+  p->nRef--;
+  assert( p->nRef>=0 );
+  if( p->nRef<=0 ) testFree(p);
+}
+
+static int btVfsClose(bt_file *pFile){
+  BtFile *p = (BtFile*)pFile;
+  BtDb *pBt = p->pBt;
+  int rc;
+  if( pBt ){
+    btFlushSectors(p, 0);
+    if( p==pBt->apFile[0] ) pBt->apFile[0] = 0;
+    if( p==pBt->apFile[1] ) pBt->apFile[1] = 0;
+  }
+  testFree(p->apSector);
+  rc = p->pVfs->xClose(p->pFile);
+#if 0
+  btDeref(p->pBt);
+#endif
+  testFree(p);
+  return rc;
+}
+
+static int btVfsUnlink(sqlite4_env *pEnv, bt_env *pVfs, const char *zFile){
+  BtDb *pBt = (BtDb*)pVfs->pVfsCtx;
+  if( pBt->bCrash ) return SQLITE4_IOERR;
+  return pBt->pVfs->xUnlink(pEnv, pBt->pVfs, zFile);
+}
+
+static int btVfsLock(bt_file *pFile, int iLock, int eType){
+  BtFile *p = (BtFile*)pFile;
+  if( p->pBt && p->pBt->bCrash ) return SQLITE4_IOERR;
+  return p->pVfs->xLock(p->pFile, iLock, eType);
+}
+
+static int btVfsTestLock(bt_file *pFile, int iLock, int nLock, int eType){
+  BtFile *p = (BtFile*)pFile;
+  if( p->pBt && p->pBt->bCrash ) return SQLITE4_IOERR;
+  return p->pVfs->xTestLock(p->pFile, iLock, nLock, eType);
+}
+
+static int btVfsShmMap(bt_file *pFile, int iChunk, int sz, void **ppOut){
+  BtFile *p = (BtFile*)pFile;
+  if( p->pBt && p->pBt->bCrash ) return SQLITE4_IOERR;
+  return p->pVfs->xShmMap(p->pFile, iChunk, sz, ppOut);
+}
+
+static void btVfsShmBarrier(bt_file *pFile){
+  BtFile *p = (BtFile*)pFile;
+  return p->pVfs->xShmBarrier(p->pFile);
+}
+
+static int btVfsShmUnmap(bt_file *pFile, int bDelete){
+  BtFile *p = (BtFile*)pFile;
+  if( p->pBt && p->pBt->bCrash ) return SQLITE4_IOERR;
+  return p->pVfs->xShmUnmap(p->pFile, bDelete);
+}
+
+static int bt_close(TestDb *pTestDb){
+  BtDb *p = (BtDb*)pTestDb;
+  int rc = sqlite4BtClose(p->pBt);
+  free(p->aBuffer);
+  if( p->apFile[0] ) p->apFile[0]->pBt = 0;
+  if( p->apFile[1] ) p->apFile[1]->pBt = 0;
+  bgc_detach(p);
+  testFree(p);
+  return rc;
+}
+
+static int btMinTransaction(BtDb *p, int iMin, int *piLevel){
+  int iLevel;
+  int rc = SQLITE4_OK;
+
+  iLevel = sqlite4BtTransactionLevel(p->pBt);
+  if( iLevel<iMin ){ 
+    rc = sqlite4BtBegin(p->pBt, iMin); 
+    *piLevel = iLevel;
+  }else{
+    *piLevel = -1;
+  }
+
+  return rc;
+}
+static int btRestoreTransaction(BtDb *p, int iLevel, int rcin){
+  int rc = rcin;
+  if( iLevel>=0 ){
+    if( rc==SQLITE4_OK ){
+      rc = sqlite4BtCommit(p->pBt, iLevel);
+    }else{
+      sqlite4BtRollback(p->pBt, iLevel);
+    }
+    assert( iLevel==sqlite4BtTransactionLevel(p->pBt) );
+  }
+  return rc;
+}
+
+static int bt_write(TestDb *pTestDb, void *pK, int nK, void *pV, int nV){
+  BtDb *p = (BtDb*)pTestDb;
+  int iLevel;
+  int rc;
+
+  rc = btMinTransaction(p, 2, &iLevel);
+  if( rc==SQLITE4_OK ){
+    if( p->bFastInsert ) sqlite4BtControl(p->pBt, BT_CONTROL_FAST_INSERT_OP, 0);
+    rc = sqlite4BtReplace(p->pBt, pK, nK, pV, nV);
+    rc = btRestoreTransaction(p, iLevel, rc);
+  }
+  return rc;
+}
+
+static int bt_delete(TestDb *pTestDb, void *pK, int nK){
+  return bt_write(pTestDb, pK, nK, 0, -1);
+}
+
+static int bt_delete_range(
+  TestDb *pTestDb, 
+  void *pKey1, int nKey1,
+  void *pKey2, int nKey2
+){
+  BtDb *p = (BtDb*)pTestDb;
+  bt_cursor *pCsr = 0;
+  int rc = SQLITE4_OK;
+  int iLevel;
+
+  rc = btMinTransaction(p, 2, &iLevel);
+  if( rc==SQLITE4_OK ){
+    if( p->bFastInsert ) sqlite4BtControl(p->pBt, BT_CONTROL_FAST_INSERT_OP, 0);
+    rc = sqlite4BtCsrOpen(p->pBt, 0, &pCsr);
+  }
+  while( rc==SQLITE4_OK ){
+    const void *pK;
+    int n;
+    int nCmp;
+    int res;
+
+    rc = sqlite4BtCsrSeek(pCsr, pKey1, nKey1, BT_SEEK_GE);
+    if( rc==SQLITE4_INEXACT ) rc = SQLITE4_OK;
+    if( rc!=SQLITE4_OK ) break;
+
+    rc = sqlite4BtCsrKey(pCsr, &pK, &n);
+    if( rc!=SQLITE4_OK ) break;
+
+    nCmp = MIN(n, nKey1);
+    res = memcmp(pKey1, pK, nCmp);
+    assert( res<0 || (res==0 && nKey1<=n) );
+    if( res==0 && nKey1==n ){
+      rc = sqlite4BtCsrNext(pCsr);
+      if( rc!=SQLITE4_OK ) break;
+      rc = sqlite4BtCsrKey(pCsr, &pK, &n);
+      if( rc!=SQLITE4_OK ) break;
+    }
+
+    nCmp = MIN(n, nKey2);
+    res = memcmp(pKey2, pK, nCmp);
+    if( res<0 || (res==0 && nKey2<=n) ) break;
+    
+    rc = sqlite4BtDelete(pCsr);
+  }
+  if( rc==SQLITE4_NOTFOUND ) rc = SQLITE4_OK;
+
+  sqlite4BtCsrClose(pCsr);
+
+  rc = btRestoreTransaction(p, iLevel, rc);
+  return rc;
+}
+
+static int bt_fetch(
+  TestDb *pTestDb, 
+  void *pK, int nK, 
+  void **ppVal, int *pnVal
+){
+  BtDb *p = (BtDb*)pTestDb;
+  bt_cursor *pCsr = 0;
+  int iLevel;
+  int rc = SQLITE4_OK;
+
+  iLevel = sqlite4BtTransactionLevel(p->pBt);
+  if( iLevel==0 ){ 
+    rc = sqlite4BtBegin(p->pBt, 1); 
+    if( rc!=SQLITE4_OK ) return rc;
+  }
+
+  if( p->bFastInsert ) sqlite4BtControl(p->pBt, BT_CONTROL_FAST_INSERT_OP, 0);
+  rc = sqlite4BtCsrOpen(p->pBt, 0, &pCsr);
+  if( rc==SQLITE4_OK ){
+    rc = sqlite4BtCsrSeek(pCsr, pK, nK, BT_SEEK_EQ);
+    if( rc==SQLITE4_OK ){
+      const void *pV = 0;
+      int nV = 0;
+      rc = sqlite4BtCsrData(pCsr, 0, -1, &pV, &nV);
+      if( rc==SQLITE4_OK ){
+        if( nV>p->nBuffer ){
+          free(p->aBuffer);
+          p->aBuffer = (u8*)malloc(nV*2);
+          p->nBuffer = nV*2;
+        }
+        memcpy(p->aBuffer, pV, nV);
+        *pnVal = nV;
+        *ppVal = (void*)(p->aBuffer);
+      }
+
+    }else if( rc==SQLITE4_INEXACT || rc==SQLITE4_NOTFOUND ){
+      *ppVal = 0;
+      *pnVal = -1;
+      rc = SQLITE4_OK;
+    }
+    sqlite4BtCsrClose(pCsr);
+  }
+
+  if( iLevel==0 ) sqlite4BtCommit(p->pBt, 0); 
+  return rc;
+}
+
+static int bt_scan(
+  TestDb *pTestDb,
+  void *pCtx,
+  int bReverse,
+  void *pFirst, int nFirst,
+  void *pLast, int nLast,
+  void (*xCallback)(void *, void *, int , void *, int)
+){
+  BtDb *p = (BtDb*)pTestDb;
+  bt_cursor *pCsr = 0;
+  int rc;
+  int iLevel;
+
+  rc = btMinTransaction(p, 1, &iLevel);
+
+  if( rc==SQLITE4_OK ){
+    if( p->bFastInsert ) sqlite4BtControl(p->pBt, BT_CONTROL_FAST_INSERT_OP, 0);
+    rc = sqlite4BtCsrOpen(p->pBt, 0, &pCsr);
+  }
+  if( rc==SQLITE4_OK ){
+    if( bReverse ){
+      if( pLast ){
+        rc = sqlite4BtCsrSeek(pCsr, pLast, nLast, BT_SEEK_LE);
+      }else{
+        rc = sqlite4BtCsrLast(pCsr);
+      }
+    }else{
+      rc = sqlite4BtCsrSeek(pCsr, pFirst, nFirst, BT_SEEK_GE);
+    }
+    if( rc==SQLITE4_INEXACT ) rc = SQLITE4_OK;
+
+    while( rc==SQLITE4_OK ){
+      const void *pK = 0; int nK = 0;
+      const void *pV = 0; int nV = 0;
+
+      rc = sqlite4BtCsrKey(pCsr, &pK, &nK);
+      if( rc==SQLITE4_OK ){
+        rc = sqlite4BtCsrData(pCsr, 0, -1, &pV, &nV);
+      }
+
+      if( rc!=SQLITE4_OK ) break;
+      if( bReverse ){
+        if( pFirst ){
+          int res;
+          int nCmp = MIN(nK, nFirst);
+          res = memcmp(pFirst, pK, nCmp);
+          if( res>0 || (res==0 && nK<nFirst) ) break;
+        }
+      }else{
+        if( pLast ){
+          int res;
+          int nCmp = MIN(nK, nLast);
+          res = memcmp(pLast, pK, nCmp);
+          if( res<0 || (res==0 && nK>nLast) ) break;
+        }
+      }
+
+      xCallback(pCtx, (void*)pK, nK, (void*)pV, nV);
+      if( bReverse ){
+        rc = sqlite4BtCsrPrev(pCsr);
+      }else{
+        rc = sqlite4BtCsrNext(pCsr);
+      }
+    }
+    if( rc==SQLITE4_NOTFOUND ) rc = SQLITE4_OK;
+
+    sqlite4BtCsrClose(pCsr);
+  }
+
+  rc = btRestoreTransaction(p, iLevel, rc);
+  return rc;
+}
+
+static int bt_begin(TestDb *pTestDb, int iLvl){
+  BtDb *p = (BtDb*)pTestDb;
+  int rc = sqlite4BtBegin(p->pBt, iLvl);
+  return rc;
+}
+
+static int bt_commit(TestDb *pTestDb, int iLvl){
+  BtDb *p = (BtDb*)pTestDb;
+  int rc = sqlite4BtCommit(p->pBt, iLvl);
+  return rc;
+}
+
+static int bt_rollback(TestDb *pTestDb, int iLvl){
+  BtDb *p = (BtDb*)pTestDb;
+  int rc = sqlite4BtRollback(p->pBt, iLvl);
+  return rc;
+}
+
+static int testParseOption(
+  const char **pzIn,              /* IN/OUT: pointer to next option */
+  const char **pzOpt,             /* OUT: nul-terminated option name */
+  const char **pzArg,             /* OUT: nul-terminated option argument */
+  char *pSpace                    /* Temporary space for output params */
+){
+  const char *p = *pzIn;
+  const char *pStart;
+  int n;
+
+  char *pOut = pSpace;
+
+  while( *p==' ' ) p++;
+  pStart = p;
+  while( *p && *p!='=' ) p++;
+  if( *p==0 ) return 1;
+
+  n = (p - pStart);
+  memcpy(pOut, pStart, n);
+  *pzOpt = pOut;
+  pOut += n;
+  *pOut++ = '\0';
+
+  p++;
+  pStart = p;
+  while( *p && *p!=' ' ) p++;
+  n = (p - pStart);
+
+  memcpy(pOut, pStart, n);
+  *pzArg = pOut;
+  pOut += n;
+  *pOut++ = '\0';
+
+  *pzIn = p;
+  return 0;
+}
+
+static int testParseInt(const char *z, int *piVal){
+  int i = 0;
+  const char *p = z;
+
+  while( *p>='0' && *p<='9' ){
+    i = i*10 + (*p - '0');
+    p++;
+  }
+  if( *p=='K' || *p=='k' ){
+    i = i * 1024;
+    p++;
+  }else if( *p=='M' || *p=='m' ){
+    i = i * 1024 * 1024;
+    p++;
+  }
+
+  if( *p ) return SQLITE4_ERROR;
+  *piVal = i;
+  return SQLITE4_OK;
+}
+
+static int testBtConfigure(BtDb *pDb, const char *zCfg, int *pbMt){
+  int rc = SQLITE4_OK;
+
+  if( zCfg ){
+    struct CfgParam {
+      const char *zParam;
+      int eParam;
+    } aParam[] = {
+      { "safety",         BT_CONTROL_SAFETY },
+      { "autockpt",       BT_CONTROL_AUTOCKPT },
+      { "multiproc",      BT_CONTROL_MULTIPROC },
+      { "blksz",          BT_CONTROL_BLKSZ },
+      { "pagesz",         BT_CONTROL_PAGESZ },
+      { "mt",             -1 },
+      { "fastinsert",     -2 },
+      { 0, 0 }
+    };
+    const char *z = zCfg;
+    int n = strlen(z);
+    char *aSpace;
+    const char *zOpt;
+    const char *zArg;
+
+    aSpace = (char*)testMalloc(n+2);
+    while( rc==SQLITE4_OK && 0==testParseOption(&z, &zOpt, &zArg, aSpace) ){
+      int i;
+      int iVal;
+      rc = testArgSelect(aParam, "param", zOpt, &i);
+      if( rc!=SQLITE4_OK ) break;
+
+      rc = testParseInt(zArg, &iVal);
+      if( rc!=SQLITE4_OK ) break;
+
+      switch( aParam[i].eParam ){
+        case -1:
+          *pbMt = iVal;
+          break;
+        case -2:
+          pDb->bFastInsert = 1;
+          break;
+        default:
+          rc = sqlite4BtControl(pDb->pBt, aParam[i].eParam, (void*)&iVal);
+          break;
+      }
+    }
+    testFree(aSpace);
+  }
+
+  return rc;
+}
+
+
+int test_bt_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+
+  static const DatabaseMethods SqlMethods = {
+    bt_close,
+    bt_write,
+    bt_delete,
+    bt_delete_range,
+    bt_fetch,
+    bt_scan,
+    bt_begin,
+    bt_commit,
+    bt_rollback
+  };
+  BtDb *p = 0;
+  bt_db *pBt = 0;
+  int rc;
+  sqlite4_env *pEnv = sqlite4_env_default();
+
+  if( bClear && zFilename && zFilename[0] ){
+    char *zLog = sqlite3_mprintf("%s-wal", zFilename);
+    unlink(zFilename);
+    unlink(zLog);
+    sqlite3_free(zLog);
+  }
+  
+  rc = sqlite4BtNew(pEnv, 0, &pBt);
+  if( rc==SQLITE4_OK ){
+    int mt = 0;                   /* True for multi-threaded connection */
+
+    p = (BtDb*)testMalloc(sizeof(BtDb));
+    p->base.pMethods = &SqlMethods;
+    p->pBt = pBt;
+    p->pEnv = pEnv;
+    p->nRef = 1;
+
+    p->env.pVfsCtx = (void*)p;
+    p->env.xFullpath = btVfsFullpath;
+    p->env.xOpen = btVfsOpen;
+    p->env.xSize = btVfsSize;
+    p->env.xRead = btVfsRead;
+    p->env.xWrite = btVfsWrite;
+    p->env.xTruncate = btVfsTruncate;
+    p->env.xSync = btVfsSync;
+    p->env.xSectorSize = btVfsSectorSize;
+    p->env.xClose = btVfsClose;
+    p->env.xUnlink = btVfsUnlink;
+    p->env.xLock = btVfsLock;
+    p->env.xTestLock = btVfsTestLock;
+    p->env.xShmMap = btVfsShmMap;
+    p->env.xShmBarrier = btVfsShmBarrier;
+    p->env.xShmUnmap = btVfsShmUnmap;
+
+    sqlite4BtControl(pBt, BT_CONTROL_GETVFS, (void*)&p->pVfs);
+    sqlite4BtControl(pBt, BT_CONTROL_SETVFS, (void*)&p->env);
+
+    rc = testBtConfigure(p, zSpec, &mt);
+    if( rc==SQLITE4_OK ){
+      rc = sqlite4BtOpen(pBt, zFilename);
+    }
+
+    if( rc==SQLITE4_OK && mt ){
+      int nAuto = 0;
+      rc = bgc_attach(p, zSpec);
+      sqlite4BtControl(pBt, BT_CONTROL_AUTOCKPT, (void*)&nAuto);
+    }
+  }
+
+  if( rc!=SQLITE4_OK && p ){
+    bt_close(&p->base);
+  }
+
+  *ppDb = &p->base;
+  return rc;
+}
+
+int test_fbt_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  return test_bt_open("fast=1", zFilename, bClear, ppDb);
+}
+
+int test_fbts_open(
+  const char *zSpec, 
+  const char *zFilename, 
+  int bClear, 
+  TestDb **ppDb
+){
+  return test_bt_open("fast=1 blksz=32K pagesz=512", zFilename, bClear, ppDb);
+}
+
+
+void tdb_bt_prepare_sync_crash(TestDb *pTestDb, int iSync){
+  BtDb *p = (BtDb*)pTestDb;
+  assert( pTestDb->pMethods->xClose==bt_close );
+  assert( p->bCrash==0 );
+  p->nCrashSync = iSync;
+}
+
+bt_db *tdb_bt(TestDb *pDb){
+  if( pDb->pMethods->xClose==bt_close ){
+    return ((BtDb *)pDb)->pBt;
+  }
+  return 0;
+}
+
+/*************************************************************************
+** Beginning of code for background checkpointer.
+*/
+
+struct bt_ckpter {
+  sqlite4_buffer file;            /* File name */
+  sqlite4_buffer spec;            /* Options */
+  int nLogsize;                   /* Minimum log size to checkpoint */
+  int nRef;                       /* Number of clients */
+
+  int bDoWork;                    /* Set by client threads */
+  pthread_t ckpter_thread;        /* Checkpointer thread */
+  pthread_cond_t ckpter_cond;     /* Condition var the ckpter waits on */
+  pthread_mutex_t ckpter_mutex;   /* Mutex used with ckpter_cond */
+
+  bt_ckpter *pNext;               /* Next object in list at gBgc.pCkpter */
+};
+
+static struct GlobalBackgroundCheckpointer {
+  bt_ckpter *pCkpter;             /* Linked list of checkpointers */
+} gBgc;
+
+static void *bgc_main(void *pArg){
+  BtDb *pDb = 0;
+  int rc;
+  int mt;
+  bt_ckpter *pCkpter = (bt_ckpter*)pArg;
+
+  rc = test_bt_open("", (char*)pCkpter->file.p, 0, (TestDb**)&pDb);
+  assert( rc==SQLITE4_OK );
+  rc = testBtConfigure(pDb, (char*)pCkpter->spec.p, &mt);
+
+  while( pCkpter->nRef>0 ){
+    bt_db *db = pDb->pBt;
+    int nLog = 0;
+
+    sqlite4BtBegin(db, 1);
+    sqlite4BtCommit(db, 0);
+    sqlite4BtControl(db, BT_CONTROL_LOGSIZE, (void*)&nLog);
+
+    if( nLog>=pCkpter->nLogsize ){
+      int rc;
+      bt_checkpoint ckpt;
+      memset(&ckpt, 0, sizeof(bt_checkpoint));
+      ckpt.nFrameBuffer = nLog/2;
+      rc = sqlite4BtControl(db, BT_CONTROL_CHECKPOINT, (void*)&ckpt);
+      assert( rc==SQLITE4_OK );
+      sqlite4BtControl(db, BT_CONTROL_LOGSIZE, (void*)&nLog);
+    }
+
+    /* The thread will wake up when it is signaled either because another
+    ** thread has created some work for this one or because the connection
+    ** is being closed.  */
+    pthread_mutex_lock(&pCkpter->ckpter_mutex);
+    if( pCkpter->bDoWork==0 ){
+      pthread_cond_wait(&pCkpter->ckpter_cond, &pCkpter->ckpter_mutex);
+    }
+    pCkpter->bDoWork = 0;
+    pthread_mutex_unlock(&pCkpter->ckpter_mutex);
+  }
+
+  if( pDb ) bt_close((TestDb*)pDb);
+  return 0;
+}
+
+static void bgc_logsize_cb(void *pCtx, int nLogsize){
+  bt_ckpter *p = (bt_ckpter*)pCtx;
+  if( nLogsize>=p->nLogsize ){
+    pthread_mutex_lock(&p->ckpter_mutex);
+    p->bDoWork = 1;
+    pthread_cond_signal(&p->ckpter_cond);
+    pthread_mutex_unlock(&p->ckpter_mutex);
+  }
+}
+
+static int bgc_attach(BtDb *pDb, const char *zSpec){
+  int rc;
+  int n;
+  bt_info info;
+  bt_ckpter *pCkpter;
+
+  /* Figure out the full path to the database opened by handle pDb. */
+  info.eType = BT_INFO_FILENAME;
+  info.pgno = 0;
+  sqlite4_buffer_init(&info.output, 0);
+  rc = sqlite4BtControl(pDb->pBt, BT_CONTROL_INFO, (void*)&info);
+  if( rc!=SQLITE4_OK ) return rc;
+
+  sqlite4_mutex_enter(sqlite4_mutex_alloc(pDb->pEnv, SQLITE4_MUTEX_STATIC_KV));
+
+  /* Search for an existing bt_ckpter object. */
+  n = info.output.n;
+  for(pCkpter=gBgc.pCkpter; pCkpter; pCkpter=pCkpter->pNext){
+    if( n==pCkpter->file.n && 0==memcmp(info.output.p, pCkpter->file.p, n) ){
+      break;
+    }
+  }
+
+  /* Failed to find a suitable checkpointer. Create a new one. */
+  if( pCkpter==0 ){
+    bt_logsizecb cb;
+
+    pCkpter = testMalloc(sizeof(bt_ckpter));
+    memcpy(&pCkpter->file, &info.output, sizeof(sqlite4_buffer));
+    info.output.p = 0;
+    pCkpter->pNext = gBgc.pCkpter;
+    pCkpter->nLogsize = 1000;
+    gBgc.pCkpter = pCkpter;
+    pCkpter->nRef = 1;
+
+    sqlite4_buffer_init(&pCkpter->spec, 0);
+    rc = sqlite4_buffer_set(&pCkpter->spec, zSpec, strlen(zSpec)+1);
+    assert( rc==SQLITE4_OK );
+
+    /* Kick off the checkpointer thread. */
+    if( rc==0 ) rc = pthread_cond_init(&pCkpter->ckpter_cond, 0);
+    if( rc==0 ) rc = pthread_mutex_init(&pCkpter->ckpter_mutex, 0);
+    if( rc==0 ){
+      rc = pthread_create(&pCkpter->ckpter_thread, 0, bgc_main, (void*)pCkpter);
+    }
+    assert( rc==0 ); /* todo: Fix this */
+
+    /* Set up the logsize callback for the client thread */
+    cb.pCtx = (void*)pCkpter;
+    cb.xLogsize = bgc_logsize_cb;
+    sqlite4BtControl(pDb->pBt, BT_CONTROL_LOGSIZECB, (void*)&cb);
+  }else{
+    pCkpter->nRef++;
+  }
+
+  /* Assuming a checkpointer was encountered or effected, attach the 
+  ** connection to it.  */
+  if( pCkpter ){
+    pDb->pCkpter = pCkpter;
+  }
+
+  sqlite4_mutex_leave(sqlite4_mutex_alloc(pDb->pEnv, SQLITE4_MUTEX_STATIC_KV));
+  sqlite4_buffer_clear(&info.output);
+  return rc;
+}
+
+static int bgc_detach(BtDb *pDb){
+  int rc = SQLITE4_OK;
+  bt_ckpter *pCkpter = pDb->pCkpter;
+  if( pCkpter ){
+    int bShutdown = 0;            /* True if this is the last reference */
+
+    sqlite4_mutex_enter(sqlite4_mutex_alloc(pDb->pEnv,SQLITE4_MUTEX_STATIC_KV));
+    pCkpter->nRef--;
+    if( pCkpter->nRef==0 ){
+      bt_ckpter **pp;
+
+      *pp = pCkpter->pNext;
+      for(pp=&gBgc.pCkpter; *pp!=pCkpter; pp=&((*pp)->pNext));
+      bShutdown = 1;
+    }
+    sqlite4_mutex_leave(sqlite4_mutex_alloc(pDb->pEnv,SQLITE4_MUTEX_STATIC_KV));
+
+    if( bShutdown ){
+      void *pDummy;
+
+      /* Signal the checkpointer thread. */
+      pthread_mutex_lock(&pCkpter->ckpter_mutex);
+      pCkpter->bDoWork = 1;
+      pthread_cond_signal(&pCkpter->ckpter_cond);
+      pthread_mutex_unlock(&pCkpter->ckpter_mutex);
+
+      /* Join the checkpointer thread. */
+      pthread_join(pCkpter->ckpter_thread, &pDummy);
+      pthread_cond_destroy(&pCkpter->ckpter_cond);
+      pthread_mutex_destroy(&pCkpter->ckpter_mutex);
+
+      sqlite4_buffer_clear(&pCkpter->file);
+      sqlite4_buffer_clear(&pCkpter->spec);
+      testFree(pCkpter);
+    }
+
+    pDb->pCkpter = 0;
+  }
+  return rc;
+}
+
+/*
+** End of background checkpointer.
+*************************************************************************/