# 2001 September 15

#

# Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved.

#

# 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 attempts to check the behavior of the SQLite library in 

# an out-of-memory situation. When compiled with -DSQLITE_DEBUG=1, 

# the SQLite library accepts a special command (sqlite3_memdebug_fail N C)

# which causes the N-th malloc to fail.  This special feature is used

# to see what happens in the library if a malloc were to really fail

# due to an out-of-memory situation.

#

# $Id: malloc.test,v 1.67 2008/09/23 16:41:30 danielk1977 Exp $

set testdir [file dirname $argv0]

source $testdir/tester.tcl

# Only run these tests if memory debugging is turned on.

#

source $testdir/malloc_common.tcl

if {!$MEMDEBUG} {

   puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."

   finish_test

   return

}

if {$tcl_platform(platform)!="symbian"} {

  # Do a couple of memory dumps just to exercise the memory dump logic

  # that that we can say that we have.

  #

  puts stderr "This is a test.  Ignore the error that follows:"

  sqlite3_memdebug_dump $testdir

  puts "Memory dump to file memdump.txt..."

  sqlite3_memdebug_dump memdump.txt

}  

ifcapable bloblit&&subquery {

  do_malloc_test 1 -tclprep {

    db close

  } -tclbody {

    if {[catch {sqlite3 db test.db}]} {

      error "out of memory"

    }

    sqlite3_extended_result_codes db 1

  } -sqlbody {

    DROP TABLE IF EXISTS t1;

    CREATE TABLE t1(

       a int, b float, c double, d text, e varchar(20),

       primary key(a,b,c)

    );

    CREATE INDEX i1 ON t1(a,b);

    INSERT INTO t1 VALUES(1,2.3,4.5,'hi',x'746865726500');

    INSERT INTO t1 VALUES(6,7.0,0.8,'hello','out yonder');

    SELECT * FROM t1;

    SELECT avg(b) FROM t1 GROUP BY a HAVING b>20.0;

    DELETE FROM t1 WHERE a IN (SELECT min(a) FROM t1);

    SELECT count(*), group_concat(e) FROM t1;

    SELECT b FROM t1 ORDER BY 1 COLLATE nocase;

  } 

}

# Ensure that no file descriptors were leaked.

do_test malloc-1.X {

  catch {db close}

  set sqlite_open_file_count

} {0}

ifcapable subquery {

  do_malloc_test 2 -sqlbody {

    CREATE TABLE t1(a int, b int default 'abc', c int default 1);

    CREATE INDEX i1 ON t1(a,b);

    INSERT INTO t1 VALUES(1,1,'99 abcdefghijklmnopqrstuvwxyz');

    INSERT INTO t1 VALUES(2,4,'98 abcdefghijklmnopqrstuvwxyz');

    INSERT INTO t1 VALUES(3,9,'97 abcdefghijklmnopqrstuvwxyz');

    INSERT INTO t1 VALUES(4,16,'96 abcdefghijklmnopqrstuvwxyz');

    INSERT INTO t1 VALUES(5,25,'95 abcdefghijklmnopqrstuvwxyz');

    INSERT INTO t1 VALUES(6,36,'94 abcdefghijklmnopqrstuvwxyz');

    SELECT 'stuff', count(*) as 'other stuff', max(a+10) FROM t1;

    UPDATE t1 SET b=b||b||b||b;

    UPDATE t1 SET b=a WHERE a in (10,12,22);

    INSERT INTO t1(c,b,a) VALUES(20,10,5);

    INSERT INTO t1 SELECT * FROM t1

        WHERE a IN (SELECT a FROM t1 WHERE a<10);

    DELETE FROM t1 WHERE a>=10;

    DROP INDEX i1;

    DELETE FROM t1;

  } 

}

# Ensure that no file descriptors were leaked.

do_test malloc-2.X {

  catch {db close}

  set sqlite_open_file_count

} {0}

do_malloc_test 3 -sqlbody {

  BEGIN TRANSACTION;

  CREATE TABLE t1(a int, b int, c int);

  CREATE INDEX i1 ON t1(a,b);

  INSERT INTO t1 VALUES(1,1,99);

  INSERT INTO t1 VALUES(2,4,98);

  INSERT INTO t1 VALUES(3,9,97);

  INSERT INTO t1 VALUES(4,16,96);

  INSERT INTO t1 VALUES(5,25,95);

  INSERT INTO t1 VALUES(6,36,94);

  INSERT INTO t1(c,b,a) VALUES(20,10,5);

  DELETE FROM t1 WHERE a>=10;

  DROP INDEX i1;

  DELETE FROM t1;

  ROLLBACK;

} 

# Ensure that no file descriptors were leaked.

do_test malloc-3.X {

  catch {db close}

  set sqlite_open_file_count

} {0}

ifcapable subquery {

  do_malloc_test 4 -sqlbody {

    BEGIN TRANSACTION;

    CREATE TABLE t1(a int, b int, c int);

    CREATE INDEX i1 ON t1(a,b);

    INSERT INTO t1 VALUES(1,1,99);

    INSERT INTO t1 VALUES(2,4,98);

    INSERT INTO t1 VALUES(3,9,97);

    INSERT INTO t1 VALUES(4,16,96);

    INSERT INTO t1 VALUES(5,25,95);

    INSERT INTO t1 VALUES(6,36,94);

    UPDATE t1 SET b=a WHERE a in (10,12,22);

    INSERT INTO t1 SELECT * FROM t1

       WHERE a IN (SELECT a FROM t1 WHERE a<10);

    DROP INDEX i1;

    DELETE FROM t1;

    COMMIT;

  } 

}

# Ensure that no file descriptors were leaked.

do_test malloc-4.X {

  catch {db close}

  set sqlite_open_file_count

} {0}

ifcapable trigger {

  do_malloc_test 5 -sqlbody {

    BEGIN TRANSACTION;

    CREATE TABLE t1(a,b);

    CREATE TABLE t2(x,y);

    CREATE TRIGGER r1 AFTER INSERT ON t1 WHEN new.a = 2 BEGIN

      INSERT INTO t2(x,y) VALUES(new.rowid,1);

      INSERT INTO t2(x,y) SELECT * FROM t2;

      INSERT INTO t2 SELECT * FROM t2;

      UPDATE t2 SET y=y+1 WHERE x=new.rowid;

      SELECT 123;

      DELETE FROM t2 WHERE x=new.rowid;

    END;

    INSERT INTO t1(a,b) VALUES(2,3);

    COMMIT;

  } 

}

# Ensure that no file descriptors were leaked.

do_test malloc-5.X {

  catch {db close}

  set sqlite_open_file_count

} {0}

ifcapable vacuum {

  do_malloc_test 6 -sqlprep {

    BEGIN TRANSACTION;

    CREATE TABLE t1(a);

    INSERT INTO t1 VALUES(1);

    INSERT INTO t1 SELECT a*2 FROM t1;

    INSERT INTO t1 SELECT a*2 FROM t1;

    INSERT INTO t1 SELECT a*2 FROM t1;

    INSERT INTO t1 SELECT a*2 FROM t1;

    INSERT INTO t1 SELECT a*2 FROM t1;

    INSERT INTO t1 SELECT a*2 FROM t1;

    INSERT INTO t1 SELECT a*2 FROM t1;

    INSERT INTO t1 SELECT a*2 FROM t1;

    INSERT INTO t1 SELECT a*2 FROM t1;

    INSERT INTO t1 SELECT a*2 FROM t1;

    DELETE FROM t1 where rowid%5 = 0;

    COMMIT;

  } -sqlbody {

    VACUUM;

  } 

}

do_malloc_test 7 -sqlprep {

  CREATE TABLE t1(a, b);

  INSERT INTO t1 VALUES(1, 2);

  INSERT INTO t1 VALUES(3, 4);

  INSERT INTO t1 VALUES(5, 6);

  INSERT INTO t1 VALUES(7, randstr(1200,1200));

} -sqlbody {

  SELECT min(a) FROM t1 WHERE a<6 GROUP BY b;

  SELECT a FROM t1 WHERE a<6 ORDER BY a;

  SELECT b FROM t1 WHERE a>6;

}

# This block is designed to test that some malloc failures that may

# occur in vdbeapi.c. Specifically, if a malloc failure that occurs

# when converting UTF-16 text to integers and real numbers is handled

# correctly. 

#

# This is done by retrieving a string from the database engine and

# manipulating it using the sqlite3_column_*** APIs. This doesn't 

# actually return an error to the user when a malloc() fails.. That 

# could be viewed as a bug.

#

# These tests only run if UTF-16 support is compiled in.

#

ifcapable utf16 {

  set ::STMT {}

  do_malloc_test 8 -tclprep {

    set sql "SELECT '[string repeat abc 20]', '[string repeat def 20]', ?"

    set ::STMT [sqlite3_prepare db $sql -1 X]

    sqlite3_step $::STMT

    if { $::tcl_platform(byteOrder)=="littleEndian" } {

      set ::bomstr "\xFF\xFE"

    } else {

      set ::bomstr "\xFE\xFF"

    }

    append ::bomstr [encoding convertto unicode "123456789_123456789_12345678"]

  } -tclbody {

    sqlite3_column_text16 $::STMT 0

    sqlite3_column_int $::STMT 0

    sqlite3_column_text16 $::STMT 1

    sqlite3_column_double $::STMT 1

    set rc [sqlite3_reset $::STMT]

    if {$rc eq "SQLITE_NOMEM"} {error "out of memory"}

    sqlite3_bind_text16 $::STMT 1 $::bomstr 60

    #catch {sqlite3_finalize $::STMT}

    #if {[lindex [sqlite_malloc_stat] 2]<=0} {

    #  error "out of memory"

    #}

  } -cleanup {

    if {$::STMT!=""} {

      sqlite3_finalize $::STMT

      set ::STMT {}

    }

  }

}

# This block tests that malloc() failures that occur whilst commiting

# a multi-file transaction are handled correctly.

#

do_malloc_test 9 -sqlprep {

  ATTACH 'test2.db' as test2;

  CREATE TABLE abc1(a, b, c);

  CREATE TABLE test2.abc2(a, b, c);

} -sqlbody {

  BEGIN;

  INSERT INTO abc1 VALUES(1, 2, 3);

  INSERT INTO abc2 VALUES(1, 2, 3);

  COMMIT;

}

# This block tests malloc() failures that occur while opening a 

# connection to a database.

do_malloc_test 10 -tclprep {

  catch {db2 close}

  db close

  file delete -force test.db test.db-journal

  sqlite3 db test.db

  sqlite3_extended_result_codes db 1

  db eval {CREATE TABLE abc(a, b, c)}

} -tclbody {

  db close

  sqlite3 db2 test.db

  sqlite3_extended_result_codes db2 1

  db2 eval {SELECT * FROM sqlite_master}

  db2 close

}

# This block tests malloc() failures that occur within calls to

# sqlite3_create_function().

do_malloc_test 11 -tclbody {

  set rc [sqlite3_create_function db]

  if {[string match $rc SQLITE_OK]} {

    set rc [sqlite3_create_aggregate db]

  }

  if {[string match $rc SQLITE_NOMEM]} {

    error "out of memory"

  }

}

do_malloc_test 12 -tclbody {

  set sql16 [encoding convertto unicode "SELECT * FROM sqlite_master"]

  append sql16 "\00\00"

  set ::STMT [sqlite3_prepare16 db $sql16 -1 DUMMY]

  sqlite3_finalize $::STMT

}

# Test malloc errors when replaying two hot journals from a 2-file 

# transaction.

ifcapable crashtest&&attach {

  do_malloc_test 13 -tclprep {

    set rc [crashsql -delay 1 -file test2.db {

      ATTACH 'test2.db' as aux;

      PRAGMA cache_size = 10;

      BEGIN;

      CREATE TABLE aux.t2(a, b, c);

      CREATE TABLE t1(a, b, c);

      COMMIT;

    }]

    if {$rc!="1 {child process exited abnormally}"} {

      error "Wrong error message: $rc"

    }

  } -tclbody {

    db eval {ATTACH 'test2.db' as aux;}

    set rc [catch {db eval {

      SELECT * FROM t1; 

      SELECT * FROM t2;

    }} err]

    if {$rc && $err!="no such table: t1"} {

      error $err

    }

  }

}

if {$tcl_platform(platform)!="windows" && $tcl_platform(platform)!="symbian"} {

  do_malloc_test 14 -tclprep {

    catch {db close}

    sqlite3 db2 test2.db

    sqlite3_extended_result_codes db2 1

    db2 eval {

      PRAGMA synchronous = 0;

      CREATE TABLE t1(a, b);

      INSERT INTO t1 VALUES(1, 2);

      BEGIN;

      INSERT INTO t1 VALUES(3, 4);

    }

    copy_file test2.db test.db

    copy_file test2.db-journal test.db-journal

    db2 close

  } -tclbody {

    sqlite3 db test.db

    sqlite3_extended_result_codes db 1

    # If an out-of-memory occurs within a call to a VFS layer function during

    # hot-journal rollback, sqlite will report SQLITE_CORRUPT. See commit

    # [5668] for details.

    set rc [catch {db eval { SELECT * FROM t1 }} msg]

    if {$msg eq "database disk image is malformed"} { set msg "out of memory" }

    if {$rc} { error $msg }

    set msg

  }

}

proc string_compare {a b} {

  return [string compare $a $b]

}

# Test for malloc() failures in sqlite3_create_collation() and 

# sqlite3_create_collation16().

#

ifcapable utf16 {

  do_malloc_test 15 -start 4 -tclbody {

    db collate string_compare string_compare

    if {[catch {add_test_collate db 1 1 1} msg]} {

      if {$msg=="SQLITE_NOMEM"} {set msg "out of memory"}

      error $msg

    }

    db complete {SELECT "hello """||'world"' [microsoft], * FROM anicetable;}

    db complete {-- Useful comment}

    execsql {

      CREATE TABLE t1(a, b COLLATE string_compare);

      INSERT INTO t1 VALUES(10, 'string');

      INSERT INTO t1 VALUES(10, 'string2');

    }

  }

}

# Also test sqlite3_complete(). There are (currently) no malloc()

# calls in this function, but test anyway against future changes.

#

do_malloc_test 16 -tclbody {

  db complete {SELECT "hello """||'world"' [microsoft], * FROM anicetable;}

  db complete {-- Useful comment}

  db eval {

    SELECT * FROM sqlite_master;

  }

}

# Test handling of malloc() failures in sqlite3_open16().

#

ifcapable utf16 {

  do_malloc_test 17 -tclbody {

    set DB2 0

    set STMT 0

    # open database using sqlite3_open16()

    set filename [encoding convertto unicode test.db]

    append filename "\x00\x00"

    set DB2 [sqlite3_open16 $filename -unused]

    if {0==$DB2} {

      error "out of memory"

    }

    sqlite3_extended_result_codes $DB2 1

    # Prepare statement

    set rc [catch {sqlite3_prepare $DB2 {SELECT * FROM sqlite_master} -1 X} msg]

    if {[sqlite3_errcode $DB2] eq "SQLITE_IOERR+12"} {

      error "out of memory"

    }

    if {[regexp ".*automatic extension loading.*" [sqlite3_errmsg $DB2]]} {

      error "out of memory"

    }

    if {$rc} {

      error [string range $msg 4 end]

    }

    set STMT $msg

    # Finalize statement

    set rc [sqlite3_finalize $STMT]

    if {$rc!="SQLITE_OK"} {

      error [sqlite3_errmsg $DB2]

    }

    set STMT 0

    # Close database

    set rc [sqlite3_close $DB2]

    if {$rc!="SQLITE_OK"} {

      error [sqlite3_errmsg $DB2]

    }

    set DB2 0

  } -cleanup {

    if {$STMT!="0"} {

      sqlite3_finalize $STMT

    }

    if {$DB2!="0"} {

      set rc [sqlite3_close $DB2]

    }

  }

}

# Test handling of malloc() failures in sqlite3_errmsg16().

#

ifcapable utf16 {

  do_malloc_test 18 -tclprep {

    catch {

      db eval "SELECT [string repeat longcolumnname 10] FROM sqlite_master"

    }

  } -tclbody {

    set utf16 [sqlite3_errmsg16 [sqlite3_connection_pointer db]]

    binary scan $utf16 c* bytes

    if {[llength $bytes]==0} {

      error "out of memory"

    }

  }

}

# This test is aimed at coverage testing. Specificly, it is supposed to

# cause a malloc() only used when converting between the two utf-16 

# encodings to fail (i.e. little-endian->big-endian). It only actually 

# hits this malloc() on little-endian hosts.

#

set static_string "\x00h\x00e\x00l\x00l\x00o"

for {set l 0} {$l<10} {incr l} {

  append static_string $static_string

}

append static_string "\x00\x00"

do_malloc_test 19 -tclprep {

  execsql {

    PRAGMA encoding = "UTF16be";

    CREATE TABLE abc(a, b, c);

  }

} -tclbody {

  unset -nocomplain ::STMT

  set r [catch {

    set ::STMT [sqlite3_prepare db {SELECT ?} -1 DUMMY]

    sqlite3_bind_text16 -static $::STMT 1 $static_string 112

  } msg]

  if {$r} {error [string range $msg 4 end]}

  set msg

} -cleanup {

  if {[info exists ::STMT]} {

    sqlite3_finalize $::STMT

  }

}

unset static_string

# Make sure SQLITE_NOMEM is reported out on an ATTACH failure even

# when the malloc failure occurs within the nested parse.

#

ifcapable attach {

  do_malloc_test 20 -tclprep {

    db close

    file delete -force test2.db test2.db-journal

    sqlite3 db test2.db

    sqlite3_extended_result_codes db 1

    db eval {CREATE TABLE t1(x);}

    db close

  } -tclbody {

    if {[catch {sqlite3 db test.db}]} {

      error "out of memory"

    }

    sqlite3_extended_result_codes db 1

  } -sqlbody {

    ATTACH DATABASE 'test2.db' AS t2;

    SELECT * FROM t1;

    DETACH DATABASE t2;

  } 

}

# Test malloc failure whilst installing a foreign key.

#

ifcapable foreignkey {

  do_malloc_test 21 -sqlbody {

    CREATE TABLE abc(a, b, c, FOREIGN KEY(a) REFERENCES abc(b))

  } 

}

# Test malloc failure in an sqlite3_prepare_v2() call.

#

do_malloc_test 22 -tclbody {

  set ::STMT ""

  set r [catch {

    set ::STMT [

      sqlite3_prepare_v2 db "SELECT * FROM sqlite_master" -1 DUMMY

    ]

  } msg]

  if {$r} {error [string range $msg 4 end]}

} -cleanup {

  if {$::STMT ne ""} {

    sqlite3_finalize $::STMT

    set ::STMT ""

  }

}

ifcapable {pager_pragmas} {

  # This tests a special case - that an error that occurs while the pager

  # is trying to recover from error-state in exclusive-access mode works.

  #

  do_malloc_test 23 -tclprep {

    db eval {

      PRAGMA cache_size = 10;

      PRAGMA locking_mode = exclusive;

      BEGIN;

      CREATE TABLE abc(a, b, c);

      CREATE INDEX abc_i ON abc(a, b, c);

      INSERT INTO abc 

        VALUES(randstr(100,100), randstr(100,100), randstr(100,100));

      INSERT INTO abc 

        SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;

      INSERT INTO abc 

        SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;

      INSERT INTO abc 

        SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;

      INSERT INTO abc 

        SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;

      INSERT INTO abc 

        SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;

      COMMIT;

    }

    # This puts the pager into error state.

    #

    db eval BEGIN

    db eval {UPDATE abc SET a = 0 WHERE oid%2}

    set ::sqlite_io_error_pending 10

    catch {db eval {ROLLBACK}} msg

  } -tclbody {

    # If an out-of-memory occurs within a call to a VFS layer function during

    # hot-journal rollback, sqlite will report SQLITE_CORRUPT. See commit

    # [5668] for details.

    set rc [catch {db eval { SELECT * FROM abc LIMIT 10 }} msg]

    if {$msg eq "database disk image is malformed"} { set msg "out of memory" }

    if {$rc} { error $msg }

    set msg

  } -cleanup {

    set e [db eval {PRAGMA integrity_check}]

    if {$e ne "ok"} {error $e}

  }

}

ifcapable compound {

  do_malloc_test 24 -sqlprep {

    CREATE TABLE t1(a, b, c)

  } -sqlbody {

    SELECT 1 FROM t1 UNION SELECT 2 FROM t1 ORDER BY 1

  }

}

ifcapable view&&trigger {

  do_malloc_test 25 -sqlprep {

    CREATE TABLE t1(a, b, c);

    CREATE VIEW v1 AS SELECT * FROM t1;

    CREATE TRIGGER v1t1 INSTEAD OF DELETE ON v1 BEGIN SELECT 1; END;

    CREATE TRIGGER v1t2 INSTEAD OF INSERT ON v1 BEGIN SELECT 1; END;

    CREATE TRIGGER v1t3 INSTEAD OF UPDATE ON v1 BEGIN SELECT 1; END;

  } -sqlbody {

    DELETE FROM v1 WHERE a = 1;

    INSERT INTO v1 VALUES(1, 2, 3);

    UPDATE v1 SET a = 1 WHERE b = 2;

  }

}

do_malloc_test 25 -sqlprep {

  CREATE TABLE abc(a, b, c);

  CREATE INDEX i1 ON abc(a, b);

  INSERT INTO abc VALUES(1, 2, 3);

  INSERT INTO abc VALUES(4, 5, 6);

} -tclbody {

  # For each UPDATE executed, the cursor used for the SELECT statement

  # must be "saved". Because the cursor is open on an index, this requires

  # a malloc() to allocate space to save the index key. This test case is

  # aimed at testing the response of the library to a failure in that

  # particular malloc() call.

  db eval {SELECT a FROM abc ORDER BY a} {

    db eval {UPDATE abc SET b = b - 1 WHERE a = $a}

  }

}

# This test is designed to test a specific juncture in the sqlite code.

# The database set up by -sqlprep script contains a single table B-Tree

# of height 2. In the -tclbody script, the existing database connection

# is closed and a new one opened and used to insert a new row into the

# table B-Tree. By using a new connection, the outcome of a malloc() 

# failure while seeking to the right-hand side of the B-Tree to insert 

# a new record can be tested.

#

do_malloc_test 26 -sqlprep {

  BEGIN;

  CREATE TABLE t1(a, b);

  INSERT INTO t1 VALUES(1, randomblob(210));

  INSERT INTO t1 VALUES(1, randomblob(210));

  INSERT INTO t1 VALUES(1, randomblob(210));

  INSERT INTO t1 VALUES(1, randomblob(210));

  INSERT INTO t1 VALUES(1, randomblob(210));

  COMMIT;

} -tclbody {

  db close

  sqlite3 db test.db

  db eval { INSERT INTO t1 VALUES(1, randomblob(210)) }

}

# Test that no memory is leaked following a malloc() failure in

# sqlite3_initialize().

#

do_malloc_test 27 -tclprep {

  db close

  sqlite3_shutdown

} -tclbody {

  set rc [sqlite3_initialize]

  if {$rc == "SQLITE_NOMEM"} {

    error "out of memory"

  }

}

# Ensure that no file descriptors were leaked.

do_test malloc-99.X {

  catch {db close}

  set sqlite_open_file_count

} {0}

puts open-file-count=$sqlite_open_file_count

finish_test