test/fts3malloc.test - external/github.com/pwnall/sqlite - Git at Google

 # 2009 October 22
 #
 # 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 contains tests to verify that malloc() errors that occur
 # within the FTS3 module code are handled correctly.
 #

 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 ifcapable !fts3 { finish_test ; return }
 source $testdir/malloc_common.tcl
 source $testdir/fts3_common.tcl

 # Ensure the lookaside buffer is disabled for these tests.
 #
 sqlite3 db test.db
 sqlite3_db_config_lookaside db 0 0 0

 set sqlite_fts3_enable_parentheses 1
 set DO_MALLOC_TEST 1

 # Test organization:
 #
 # fts3_malloc-1.*: Test OOM during CREATE and DROP table statements.
 # fts3_malloc-2.*: Test OOM during SELECT operations.
 # fts3_malloc-3.*: Test OOM during SELECT operations with a larger database.
 # fts3_malloc-4.*: Test OOM during database write operations.
 #
 #

 #-------------------------------------------------------------------------
 # This proc is used to test a single SELECT statement. Parameter $name is
 # passed a name for the test case (i.e. "fts3_malloc-1.4.1") and parameter
 # $sql is passed the text of the SELECT statement. Parameter $result is
 # set to the expected output if the SELECT statement is successfully
 # executed using [db eval].
 #
 # Example:
 #
 #   do_select_test testcase-1.1 "SELECT 1+1, 1+2" {1 2}
 #
 # If global variable DO_MALLOC_TEST is set to a non-zero value, or if
 # it is not defined at all, then OOM testing is performed on the SELECT
 # statement. Each OOM test case is said to pass if either (a) executing
 # the SELECT statement succeeds and the results match those specified
 # by parameter $result, or (b) TCL throws an "out of memory" error.
 #
 # If DO_MALLOC_TEST is defined and set to zero, then the SELECT statement
 # is executed just once. In this case the test case passes if the results
 # match the expected results passed via parameter $result.
 #
 proc do_select_test {name sql result} {
   doPassiveTest $name $sql [list 0 $result]
 }

 proc do_error_test {name sql error} {
   doPassiveTest $name $sql [list 1 $error]
 }

 proc doPassiveTest {name sql catchres} {
   if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }

   if {$::DO_MALLOC_TEST} {
     set answers [list {1 {out of memory}} $catchres]
     set modes [list 100000 transient 1 persistent]
   } else {
     set answers [list $catchres]
     set modes [list 0 nofail]
   }
   set str [join $answers " OR "]

   foreach {nRepeat zName} $modes {
     for {set iFail 1} 1 {incr iFail} {
       if {$::DO_MALLOC_TEST} {sqlite3_memdebug_fail $iFail -repeat $nRepeat}

       set res [catchsql $sql]
       if {[lsearch $answers $res]>=0} {
         set res $str
       }
       do_test $name.$zName.$iFail [list set {} $res] $str
       set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
       if {$nFail==0} break
     }
   }
 }


 #-------------------------------------------------------------------------
 # Test a single write to the database. In this case a  "write" is a
 # DELETE, UPDATE or INSERT statement.
 #
 # If OOM testing is performed, there are several acceptable outcomes:
 #
 #   1) The write succeeds. No error is returned.
 #
 #   2) An "out of memory" exception is thrown and:
 #
 #     a) The statement has no effect, OR
 #     b) The current transaction is rolled back, OR
 #     c) The statement succeeds. This can only happen if the connection
 #        is in auto-commit mode (after the statement is executed, so this
 #        includes COMMIT statements).
 #
 # If the write operation eventually succeeds, zero is returned. If a
 # transaction is rolled back, non-zero is returned.
 #
 # Parameter $name is the name to use for the test case (or test cases).
 # The second parameter, $tbl, should be the name of the database table
 # being modified. Parameter $sql contains the SQL statement to test.
 #
 proc do_write_test {name tbl sql} {
   if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }

   # Figure out an statement to get a checksum for table $tbl.
   db eval "SELECT * FROM $tbl" V break
   set cksumsql "SELECT md5sum([join [concat rowid $V(*)] ,]) FROM $tbl"

   # Calculate the initial table checksum.
   set cksum1 [db one $cksumsql]


   if {$::DO_MALLOC_TEST } {
     set answers [list {1 {out of memory}} {0 {}}]
     set modes [list 100000 transient 1 persistent]
   } else {
     set answers [list {0 {}}]
     set modes [list 0 nofail]
   }
   set str [join $answers " OR "]

   foreach {nRepeat zName} $modes {
     for {set iFail 1} 1 {incr iFail} {
       if {$::DO_MALLOC_TEST} {sqlite3_memdebug_fail $iFail -repeat $nRepeat}

       set res [catchsql $sql]
       set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
       if {$nFail==0} {
         do_test $name.$zName.$iFail [list set {} $res] {0 {}}
         return
       } else {
         if {[lsearch $answers $res]>=0} {
           set res $str
         }
         do_test $name.$zName.$iFail [list set {} $res] $str
         set cksum2 [db one $cksumsql]
         if {$cksum1 != $cksum2} return
       }
     }
   }
 }

 proc normal_list {l} {
   set ret [list]
   foreach elem $l {lappend ret $elem}
   set ret
 }


 do_write_test fts3_malloc-1.1 sqlite_master {
   CREATE VIRTUAL TABLE ft1 USING fts3(a, b)
 }
 do_write_test fts3_malloc-1.2 sqlite_master {
   CREATE VIRTUAL TABLE ft2 USING fts3([a], [b]);
 }
 do_write_test fts3_malloc-1.3 sqlite_master {
   CREATE VIRTUAL TABLE ft3 USING fts3('a', "b");
 }
 do_write_test fts3_malloc-1.4 sqlite_master {
   CREATE VIRTUAL TABLE ft4 USING fts3(`a`, 'fred''s column');
 }
 do_error_test fts3_malloc-1.5 {
   CREATE VIRTUAL TABLE ft5 USING fts3(a, b, tokenize unknown)
 } {unknown tokenizer: unknown}
 do_write_test fts3_malloc-1.6 sqlite_master {
   CREATE VIRTUAL TABLE ft6 USING fts3(a, b, tokenize porter)
 }

 # Test the xConnect/xDisconnect methods:
 #db eval { ATTACH 'test2.db' AS aux }
 #do_write_test fts3_malloc-1.6 aux.sqlite_master {
 #  CREATE VIRTUAL TABLE aux.ft7 USING fts3(a, b, c);
 #}
 #do_write_test fts3_malloc-1.6 aux.sqlite_master {
 #  CREATE VIRTUAL TABLE aux.ft7 USING fts3(a, b, c);
 #}


 do_test fts3_malloc-2.0 {
   execsql {
     DROP TABLE ft1;
     DROP TABLE ft2;
     DROP TABLE ft3;
     DROP TABLE ft4;
     DROP TABLE ft6;
   }
   execsql { CREATE VIRTUAL TABLE ft USING fts3(a, b) }
   for {set ii 1} {$ii < 32} {incr ii} {
     set a [list]
     set b [list]
     if {$ii & 0x01} {lappend a one   ; lappend b neung}
     if {$ii & 0x02} {lappend a two   ; lappend b song }
     if {$ii & 0x04} {lappend a three ; lappend b sahm }
     if {$ii & 0x08} {lappend a four  ; lappend b see  }
     if {$ii & 0x10} {lappend a five  ; lappend b hah  }
     execsql { INSERT INTO ft VALUES($a, $b) }
   }
 } {}

 foreach {tn sql result} {
   1 "SELECT count(*) FROM sqlite_master" {5}
   2 "SELECT * FROM ft WHERE docid = 1"   {one neung}
   3 "SELECT * FROM ft WHERE docid = 2"   {two song}
   4 "SELECT * FROM ft WHERE docid = 3"   {{one two} {neung song}}

   5 "SELECT a FROM ft" {
     {one}                     {two}                 {one two}
     {three}                   {one three}           {two three}
     {one two three}           {four}                {one four}
     {two four}                {one two four}        {three four}
     {one three four}          {two three four}      {one two three four}
     {five}                    {one five}            {two five}
     {one two five}            {three five}          {one three five}
     {two three five}          {one two three five}  {four five}
     {one four five}           {two four five}       {one two four five}
     {three four five}         {one three four five} {two three four five}
     {one two three four five}
   }

   6 "SELECT a FROM ft WHERE a MATCH 'one'" {
     {one} {one two} {one three} {one two three}
     {one four} {one two four} {one three four} {one two three four}
     {one five} {one two five} {one three five} {one two three five}
     {one four five} {one two four five}
     {one three four five} {one two three four five}
   }

   7 "SELECT a FROM ft WHERE a MATCH 'o*'" {
     {one} {one two} {one three} {one two three}
     {one four} {one two four} {one three four} {one two three four}
     {one five} {one two five} {one three five} {one two three five}
     {one four five} {one two four five}
     {one three four five} {one two three four five}
   }

   8 "SELECT a FROM ft WHERE a MATCH 'o* t*'" {
     {one two}             {one three}           {one two three}
     {one two four}        {one three four}      {one two three four}
     {one two five}        {one three five}      {one two three five}
     {one two four five}   {one three four five} {one two three four five}
   }

   9 "SELECT a FROM ft WHERE a MATCH '\"o* t*\"'" {
     {one two}             {one three}           {one two three}
     {one two four}        {one three four}      {one two three four}
     {one two five}        {one three five}      {one two three five}
     {one two four five}   {one three four five} {one two three four five}
   }

   10 {SELECT a FROM ft WHERE a MATCH '"o* f*"'} {
     {one four}            {one five}            {one four five}
   }

   11 {SELECT a FROM ft WHERE a MATCH '"one two three"'} {
     {one two three}
     {one two three four}
     {one two three five}
     {one two three four five}
   }

   12 {SELECT a FROM ft WHERE a MATCH '"two three four"'} {
     {two three four}
     {one two three four}
     {two three four five}
     {one two three four five}
   }

   12 {SELECT a FROM ft WHERE a MATCH '"two three" five'} {
     {two three five}         {one two three five}
     {two three four five}    {one two three four five}
   }

   13 {SELECT a FROM ft WHERE ft MATCH '"song sahm" hah'} {
     {two three five}         {one two three five}
     {two three four five}    {one two three four five}
   }

   14 {SELECT a FROM ft WHERE b MATCH 'neung'} {
     {one}                    {one two}
     {one three}              {one two three}
     {one four}               {one two four}
     {one three four}         {one two three four}
     {one five}               {one two five}
     {one three five}         {one two three five}
     {one four five}          {one two four five}
     {one three four five}    {one two three four five}
   }

   15 {SELECT a FROM ft WHERE b MATCH '"neung song sahm"'} {
     {one two three}          {one two three four}
     {one two three five}     {one two three four five}
   }

   16 {SELECT a FROM ft WHERE b MATCH 'hah "song sahm"'} {
     {two three five}         {one two three five}
     {two three four five}    {one two three four five}
   }

   17 {SELECT a FROM ft WHERE b MATCH 'song OR sahm'} {
     {two}                     {one two}             {three}
     {one three}               {two three}           {one two three}
     {two four}                {one two four}        {three four}
     {one three four}          {two three four}      {one two three four}
     {two five}                {one two five}        {three five}
     {one three five}          {two three five}      {one two three five}
     {two four five}           {one two four five}   {three four five}
     {one three four five}     {two three four five} {one two three four five}
   }

   18 {SELECT a FROM ft WHERE a MATCH 'three NOT two'} {
     {three}                   {one three}           {three four}
     {one three four}          {three five}          {one three five}
     {three four five}         {one three four five}
   }

   19 {SELECT a FROM ft WHERE b MATCH 'sahm NOT song'} {
     {three}                   {one three}           {three four}
     {one three four}          {three five}          {one three five}
     {three four five}         {one three four five}
   }

   20 {SELECT a FROM ft WHERE ft MATCH 'sahm NOT song'} {
     {three}                   {one three}           {three four}
     {one three four}          {three five}          {one three five}
     {three four five}         {one three four five}
   }

   21 {SELECT a FROM ft WHERE b MATCH 'neung NEAR song NEAR sahm'} {
     {one two three}           {one two three four}
     {one two three five}      {one two three four five}
   }

 } {
   set result [normal_list $result]
   do_select_test fts3_malloc-2.$tn $sql $result
 }

 do_test fts3_malloc-3.0 {
   execsql BEGIN
   for {set ii 32} {$ii < 1024} {incr ii} {
     set a [list]
     set b [list]
     if {$ii & 0x0001} {lappend a one   ; lappend b neung }
     if {$ii & 0x0002} {lappend a two   ; lappend b song  }
     if {$ii & 0x0004} {lappend a three ; lappend b sahm  }
     if {$ii & 0x0008} {lappend a four  ; lappend b see   }
     if {$ii & 0x0010} {lappend a five  ; lappend b hah   }
     if {$ii & 0x0020} {lappend a six   ; lappend b hok   }
     if {$ii & 0x0040} {lappend a seven ; lappend b jet   }
     if {$ii & 0x0080} {lappend a eight ; lappend b bairt }
     if {$ii & 0x0100} {lappend a nine  ; lappend b gow   }
     if {$ii & 0x0200} {lappend a ten   ; lappend b sip   }
     execsql { INSERT INTO ft VALUES($a, $b) }
   }
   execsql COMMIT
 } {}
 foreach {tn sql result} {
   1 "SELECT count(*) FROM ft" {1023}

   2 "SELECT a FROM ft WHERE a MATCH 'one two three four five six seven eight'" {
      {one two three four five six seven eight}
      {one two three four five six seven eight nine}
      {one two three four five six seven eight ten}
      {one two three four five six seven eight nine ten}
   }

   3 {SELECT count(*), sum(docid) FROM ft WHERE a MATCH 'o*'} {
     512 262144
   }

   4 {SELECT count(*), sum(docid) FROM ft WHERE a MATCH '"two three four"'} {
     128 66368
   }
 } {
   set result [normal_list $result]
   do_select_test fts3_malloc-3.$tn $sql $result
 }

 do_test fts3_malloc-4.0 {
   execsql { DELETE FROM ft WHERE docid>=32 }
 } {}
 foreach {tn sql} {
   1 "DELETE FROM ft WHERE ft MATCH 'one'"
   2 "DELETE FROM ft WHERE ft MATCH 'three'"
   3 "DELETE FROM ft WHERE ft MATCH 'five'"
 } {
   do_write_test fts3_malloc-4.1.$tn ft_content $sql
 }
 do_test fts3_malloc-4.2 {
   execsql { SELECT a FROM ft }
 } {two four {two four}}


 finish_test
	# 2009 October 22
	#
	# 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 contains tests to verify that malloc() errors that occur
	# within the FTS3 module code are handled correctly.
	#

	set testdir [file dirname $argv0]
	source $testdir/tester.tcl
	ifcapable !fts3 { finish_test ; return }
	source $testdir/malloc_common.tcl
	source $testdir/fts3_common.tcl

	# Ensure the lookaside buffer is disabled for these tests.
	#
	sqlite3 db test.db
	sqlite3_db_config_lookaside db 0 0 0

	set sqlite_fts3_enable_parentheses 1
	set DO_MALLOC_TEST 1

	# Test organization:
	#
	# fts3_malloc-1.*: Test OOM during CREATE and DROP table statements.
	# fts3_malloc-2.*: Test OOM during SELECT operations.
	# fts3_malloc-3.*: Test OOM during SELECT operations with a larger database.
	# fts3_malloc-4.*: Test OOM during database write operations.
	#
	#

	#-------------------------------------------------------------------------
	# This proc is used to test a single SELECT statement. Parameter $name is
	# passed a name for the test case (i.e. "fts3_malloc-1.4.1") and parameter
	# $sql is passed the text of the SELECT statement. Parameter $result is
	# set to the expected output if the SELECT statement is successfully
	# executed using [db eval].
	#
	# Example:
	#
	# do_select_test testcase-1.1 "SELECT 1+1, 1+2" {1 2}
	#
	# If global variable DO_MALLOC_TEST is set to a non-zero value, or if
	# it is not defined at all, then OOM testing is performed on the SELECT
	# statement. Each OOM test case is said to pass if either (a) executing
	# the SELECT statement succeeds and the results match those specified
	# by parameter $result, or (b) TCL throws an "out of memory" error.
	#
	# If DO_MALLOC_TEST is defined and set to zero, then the SELECT statement
	# is executed just once. In this case the test case passes if the results
	# match the expected results passed via parameter $result.
	#
	proc do_select_test {name sql result} {
	doPassiveTest $name $sql [list 0 $result]
	}

	proc do_error_test {name sql error} {
	doPassiveTest $name $sql [list 1 $error]
	}

	proc doPassiveTest {name sql catchres} {
	if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }

	if {$::DO_MALLOC_TEST} {
	set answers [list {1 {out of memory}} $catchres]
	set modes [list 100000 transient 1 persistent]
	} else {
	set answers [list $catchres]
	set modes [list 0 nofail]
	}
	set str [join $answers " OR "]

	foreach {nRepeat zName} $modes {
	for {set iFail 1} 1 {incr iFail} {
	if {$::DO_MALLOC_TEST} {sqlite3_memdebug_fail $iFail -repeat $nRepeat}

	set res [catchsql $sql]
	if {[lsearch $answers $res]>=0} {
	set res $str
	}
	do_test $name.$zName.$iFail [list set {} $res] $str
	set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
	if {$nFail==0} break
	}
	}
	}


	#-------------------------------------------------------------------------
	# Test a single write to the database. In this case a "write" is a
	# DELETE, UPDATE or INSERT statement.
	#
	# If OOM testing is performed, there are several acceptable outcomes:
	#
	# 1) The write succeeds. No error is returned.
	#
	# 2) An "out of memory" exception is thrown and:
	#
	# a) The statement has no effect, OR
	# b) The current transaction is rolled back, OR
	# c) The statement succeeds. This can only happen if the connection
	# is in auto-commit mode (after the statement is executed, so this
	# includes COMMIT statements).
	#
	# If the write operation eventually succeeds, zero is returned. If a
	# transaction is rolled back, non-zero is returned.
	#
	# Parameter $name is the name to use for the test case (or test cases).
	# The second parameter, $tbl, should be the name of the database table
	# being modified. Parameter $sql contains the SQL statement to test.
	#
	proc do_write_test {name tbl sql} {
	if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }

	# Figure out an statement to get a checksum for table $tbl.
	db eval "SELECT * FROM $tbl" V break
	set cksumsql "SELECT md5sum([join [concat rowid $V(*)] ,]) FROM $tbl"

	# Calculate the initial table checksum.
	set cksum1 [db one $cksumsql]


	if {$::DO_MALLOC_TEST } {
	set answers [list {1 {out of memory}} {0 {}}]
	set modes [list 100000 transient 1 persistent]
	} else {
	set answers [list {0 {}}]
	set modes [list 0 nofail]
	}
	set str [join $answers " OR "]

	foreach {nRepeat zName} $modes {
	for {set iFail 1} 1 {incr iFail} {
	if {$::DO_MALLOC_TEST} {sqlite3_memdebug_fail $iFail -repeat $nRepeat}

	set res [catchsql $sql]
	set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
	if {$nFail==0} {
	do_test $name.$zName.$iFail [list set {} $res] {0 {}}
	return
	} else {
	if {[lsearch $answers $res]>=0} {
	set res $str
	}
	do_test $name.$zName.$iFail [list set {} $res] $str
	set cksum2 [db one $cksumsql]
	if {$cksum1 != $cksum2} return
	}
	}
	}
	}

	proc normal_list {l} {
	set ret [list]
	foreach elem $l {lappend ret $elem}
	set ret
	}


	do_write_test fts3_malloc-1.1 sqlite_master {
	CREATE VIRTUAL TABLE ft1 USING fts3(a, b)
	}
	do_write_test fts3_malloc-1.2 sqlite_master {
	CREATE VIRTUAL TABLE ft2 USING fts3([a], [b]);
	}
	do_write_test fts3_malloc-1.3 sqlite_master {
	CREATE VIRTUAL TABLE ft3 USING fts3('a', "b");
	}
	do_write_test fts3_malloc-1.4 sqlite_master {
	CREATE VIRTUAL TABLE ft4 USING fts3(`a`, 'fred''s column');
	}
	do_error_test fts3_malloc-1.5 {
	CREATE VIRTUAL TABLE ft5 USING fts3(a, b, tokenize unknown)
	} {unknown tokenizer: unknown}
	do_write_test fts3_malloc-1.6 sqlite_master {
	CREATE VIRTUAL TABLE ft6 USING fts3(a, b, tokenize porter)
	}

	# Test the xConnect/xDisconnect methods:
	#db eval { ATTACH 'test2.db' AS aux }
	#do_write_test fts3_malloc-1.6 aux.sqlite_master {
	# CREATE VIRTUAL TABLE aux.ft7 USING fts3(a, b, c);
	#}
	#do_write_test fts3_malloc-1.6 aux.sqlite_master {
	# CREATE VIRTUAL TABLE aux.ft7 USING fts3(a, b, c);
	#}



	do_test fts3_malloc-2.0 {
	execsql {
	DROP TABLE ft1;
	DROP TABLE ft2;
	DROP TABLE ft3;
	DROP TABLE ft4;
	DROP TABLE ft6;
	}
	execsql { CREATE VIRTUAL TABLE ft USING fts3(a, b) }
	for {set ii 1} {$ii < 32} {incr ii} {
	set a [list]
	set b [list]
	if {$ii & 0x01} {lappend a one ; lappend b neung}
	if {$ii & 0x02} {lappend a two ; lappend b song }
	if {$ii & 0x04} {lappend a three ; lappend b sahm }
	if {$ii & 0x08} {lappend a four ; lappend b see }
	if {$ii & 0x10} {lappend a five ; lappend b hah }
	execsql { INSERT INTO ft VALUES($a, $b) }
	}
	} {}

	foreach {tn sql result} {
	1 "SELECT count(*) FROM sqlite_master" {5}
	2 "SELECT * FROM ft WHERE docid = 1" {one neung}
	3 "SELECT * FROM ft WHERE docid = 2" {two song}
	4 "SELECT * FROM ft WHERE docid = 3" {{one two} {neung song}}

	5 "SELECT a FROM ft" {
	{one} {two} {one two}
	{three} {one three} {two three}
	{one two three} {four} {one four}
	{two four} {one two four} {three four}
	{one three four} {two three four} {one two three four}
	{five} {one five} {two five}
	{one two five} {three five} {one three five}
	{two three five} {one two three five} {four five}
	{one four five} {two four five} {one two four five}
	{three four five} {one three four five} {two three four five}
	{one two three four five}
	}

	6 "SELECT a FROM ft WHERE a MATCH 'one'" {
	{one} {one two} {one three} {one two three}
	{one four} {one two four} {one three four} {one two three four}
	{one five} {one two five} {one three five} {one two three five}
	{one four five} {one two four five}
	{one three four five} {one two three four five}
	}

	7 "SELECT a FROM ft WHERE a MATCH 'o*'" {
	{one} {one two} {one three} {one two three}
	{one four} {one two four} {one three four} {one two three four}
	{one five} {one two five} {one three five} {one two three five}
	{one four five} {one two four five}
	{one three four five} {one two three four five}
	}

	8 "SELECT a FROM ft WHERE a MATCH 'o* t*'" {
	{one two} {one three} {one two three}
	{one two four} {one three four} {one two three four}
	{one two five} {one three five} {one two three five}
	{one two four five} {one three four five} {one two three four five}
	}

	9 "SELECT a FROM ft WHERE a MATCH '\"o* t*\"'" {
	{one two} {one three} {one two three}
	{one two four} {one three four} {one two three four}
	{one two five} {one three five} {one two three five}
	{one two four five} {one three four five} {one two three four five}
	}

	10 {SELECT a FROM ft WHERE a MATCH '"o* f*"'} {
	{one four} {one five} {one four five}
	}

	11 {SELECT a FROM ft WHERE a MATCH '"one two three"'} {
	{one two three}
	{one two three four}
	{one two three five}
	{one two three four five}
	}

	12 {SELECT a FROM ft WHERE a MATCH '"two three four"'} {
	{two three four}
	{one two three four}
	{two three four five}
	{one two three four five}
	}

	12 {SELECT a FROM ft WHERE a MATCH '"two three" five'} {
	{two three five} {one two three five}
	{two three four five} {one two three four five}
	}

	13 {SELECT a FROM ft WHERE ft MATCH '"song sahm" hah'} {
	{two three five} {one two three five}
	{two three four five} {one two three four five}
	}

	14 {SELECT a FROM ft WHERE b MATCH 'neung'} {
	{one} {one two}
	{one three} {one two three}
	{one four} {one two four}
	{one three four} {one two three four}
	{one five} {one two five}
	{one three five} {one two three five}
	{one four five} {one two four five}
	{one three four five} {one two three four five}
	}

	15 {SELECT a FROM ft WHERE b MATCH '"neung song sahm"'} {
	{one two three} {one two three four}
	{one two three five} {one two three four five}
	}

	16 {SELECT a FROM ft WHERE b MATCH 'hah "song sahm"'} {
	{two three five} {one two three five}
	{two three four five} {one two three four five}
	}

	17 {SELECT a FROM ft WHERE b MATCH 'song OR sahm'} {
	{two} {one two} {three}
	{one three} {two three} {one two three}
	{two four} {one two four} {three four}
	{one three four} {two three four} {one two three four}
	{two five} {one two five} {three five}
	{one three five} {two three five} {one two three five}
	{two four five} {one two four five} {three four five}
	{one three four five} {two three four five} {one two three four five}
	}

	18 {SELECT a FROM ft WHERE a MATCH 'three NOT two'} {
	{three} {one three} {three four}
	{one three four} {three five} {one three five}
	{three four five} {one three four five}
	}

	19 {SELECT a FROM ft WHERE b MATCH 'sahm NOT song'} {
	{three} {one three} {three four}
	{one three four} {three five} {one three five}
	{three four five} {one three four five}
	}

	20 {SELECT a FROM ft WHERE ft MATCH 'sahm NOT song'} {
	{three} {one three} {three four}
	{one three four} {three five} {one three five}
	{three four five} {one three four five}
	}

	21 {SELECT a FROM ft WHERE b MATCH 'neung NEAR song NEAR sahm'} {
	{one two three} {one two three four}
	{one two three five} {one two three four five}
	}

	} {
	set result [normal_list $result]
	do_select_test fts3_malloc-2.$tn $sql $result
	}

	do_test fts3_malloc-3.0 {
	execsql BEGIN
	for {set ii 32} {$ii < 1024} {incr ii} {
	set a [list]
	set b [list]
	if {$ii & 0x0001} {lappend a one ; lappend b neung }
	if {$ii & 0x0002} {lappend a two ; lappend b song }
	if {$ii & 0x0004} {lappend a three ; lappend b sahm }
	if {$ii & 0x0008} {lappend a four ; lappend b see }
	if {$ii & 0x0010} {lappend a five ; lappend b hah }
	if {$ii & 0x0020} {lappend a six ; lappend b hok }
	if {$ii & 0x0040} {lappend a seven ; lappend b jet }
	if {$ii & 0x0080} {lappend a eight ; lappend b bairt }
	if {$ii & 0x0100} {lappend a nine ; lappend b gow }
	if {$ii & 0x0200} {lappend a ten ; lappend b sip }
	execsql { INSERT INTO ft VALUES($a, $b) }
	}
	execsql COMMIT
	} {}
	foreach {tn sql result} {
	1 "SELECT count(*) FROM ft" {1023}

	2 "SELECT a FROM ft WHERE a MATCH 'one two three four five six seven eight'" {
	{one two three four five six seven eight}
	{one two three four five six seven eight nine}
	{one two three four five six seven eight ten}
	{one two three four five six seven eight nine ten}
	}

	3 {SELECT count(), sum(docid) FROM ft WHERE a MATCH 'o'} {
	512 262144
	}

	4 {SELECT count(*), sum(docid) FROM ft WHERE a MATCH '"two three four"'} {
	128 66368
	}
	} {
	set result [normal_list $result]
	do_select_test fts3_malloc-3.$tn $sql $result
	}

	do_test fts3_malloc-4.0 {
	execsql { DELETE FROM ft WHERE docid>=32 }
	} {}
	foreach {tn sql} {
	1 "DELETE FROM ft WHERE ft MATCH 'one'"
	2 "DELETE FROM ft WHERE ft MATCH 'three'"
	3 "DELETE FROM ft WHERE ft MATCH 'five'"
	} {
	do_write_test fts3_malloc-4.1.$tn ft_content $sql
	}
	do_test fts3_malloc-4.2 {
	execsql { SELECT a FROM ft }
	} {two four {two four}}


	finish_test