SQLite4
Artifact Content
Not logged in

Artifact 19895f211a3c060c4ea03eb4110d59b80a7564fe:


# 2005 November 30
#
# 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 ensure that the library handles malloc() failures
# correctly. The emphasis in this file is on sqlite4_column_XXX() APIs.
#
# $Id: malloc4.test,v 1.10 2008/02/18 22:24:58 drh Exp $

#---------------------------------------------------------------------------
# NOTES ON EXPECTED BEHAVIOUR
#
# [193] When a memory allocation failure occurs during sqlite4_column_name(),
#       sqlite4_column_name16(), sqlite4_column_decltype(), or
#       sqlite4_column_decltype16() the function shall return NULL.
#
#---------------------------------------------------------------------------

set testdir [file dirname $argv0]
source $testdir/tester.tcl
source $testdir/malloc_common.tcl

# Only run these tests if memory debugging is turned on.
if {!$MEMDEBUG} {
   puts "Skipping malloc4 tests: not compiled with -DSQLITE4_MEMDEBUG..."
   finish_test
   return
}

ifcapable !utf16 {
  finish_test
  return
}

proc do_stmt_test {id sql} {
  set ::sql $sql
  set go 1
  for {set n 0} {$go} {incr n} {
    set testid "malloc4-$id.$n"

    # Prepare the statement
    do_test ${testid}.1 {
      set ::STMT [sqlite4_prepare $::DB $sql -1 TAIL]
      expr [string length $::STMT] > 0
    } {1}

    # Set the Nth malloc() to fail.
    sqlite4_memdebug_fail $n -repeat 0

    # Test malloc failure in the _name(), _name16(), decltype() and
    # decltype16() APIs. Calls that occur after the malloc() failure should
    # return NULL. No error is raised though.
    #
    # ${testid}.2.1 - Call _name()
    # ${testid}.2.2 - Call _name16()
    # ${testid}.2.3 - Call _name()
    # ${testid}.2.4 - Check that the return values of the above three calls are
    #                 consistent with each other and with the simulated
    #                 malloc() failures.
    #
    # Because the code that implements the _decltype() and _decltype16() APIs
    # is the same as the _name() and _name16() implementations, we don't worry
    # about explicitly testing them.
    #
    do_test ${testid}.2.1 {
      set mf1 [expr [sqlite4_memdebug_pending] < 0]
      set ::name8  [sqlite4_column_name $::STMT 0]
      set mf2 [expr [sqlite4_memdebug_pending] < 0]
      expr {$mf1 == $mf2 || $::name8 == ""}
    } {1}
    do_test ${testid}.2.2 {
      set mf1 [expr [sqlite4_memdebug_pending] < 0]
      set ::name16 [sqlite4_column_name16 $::STMT 0]
      set ::name16 [encoding convertfrom unicode $::name16]
      set ::name16 [string range $::name16 0 end-1]
      set mf2 [expr [sqlite4_memdebug_pending] < 0]
      expr {$mf1 == $mf2 || $::name16 == ""}
    } {1}
    do_test ${testid}.2.3 {
      set mf1 [expr [sqlite4_memdebug_pending] < 0]
      set ::name8_2 [sqlite4_column_name $::STMT 0]
      set mf2 [expr [sqlite4_memdebug_pending] < 0]
      expr {$mf1 == $mf2 || $::name8_2 == ""}
    } {1}
    set ::mallocFailed [expr [sqlite4_memdebug_pending] < 0]
    do_test ${testid}.2.4 {
      expr {
        $::name8 == $::name8_2 && $::name16 == $::name8 && !$::mallocFailed ||
        $::name8 == $::name8_2 && $::name16 == "" &&        $::mallocFailed ||
        $::name8 == $::name16 && $::name8_2 == "" &&        $::mallocFailed ||
        $::name8_2 == $::name16 && $::name8 == "" &&        $::mallocFailed
      }
    } {1}

    # Step the statement so that we can call _text() and _text16().  Before
    # running sqlite4_step(), make sure that malloc() is not about to fail.
    # Memory allocation failures that occur within sqlite4_step() are tested
    # elsewhere.
    set mf [sqlite4_memdebug_pending]
    sqlite4_memdebug_fail -1
    do_test ${testid}.3 {
      sqlite4_step $::STMT
    } {SQLITE4_ROW}
    sqlite4_memdebug_fail $mf

    # Test for malloc() failures within _text() and _text16().
    #
    do_test ${testid}.4.1 {
      set ::text8 [sqlite4_column_text $::STMT 0]
      set mf [expr [sqlite4_memdebug_pending] < 0 && !$::mallocFailed]
      expr {$mf==0 || $::text8 == ""}
    } {1}
    do_test ${testid}.4.2 {
      set ::text16 [sqlite4_column_text16 $::STMT 0]
      set ::text16 [encoding convertfrom unicode $::text16]
      set ::text16 [string range $::text16 0 end-1]
      set mf [expr [sqlite4_memdebug_pending] < 0 && !$::mallocFailed]
      expr {$mf==0 || $::text16 == ""}
    } {1}
    do_test ${testid}.4.3 {
      set ::text8_2 [sqlite4_column_text $::STMT 0]
      set mf [expr [sqlite4_memdebug_pending] < 0 && !$::mallocFailed]
      expr {$mf==0 || $::text8_2 == "" || ($::text16 == "" && $::text8 != "")}
    } {1}

    # Test for malloc() failures within _int(), _int64() and _real(). The only
    # way this can occur is if the string has to be translated from UTF-16 to
    # UTF-8 before being converted to a numeric value.
    do_test ${testid}.4.4.1 {
      set mf [sqlite4_memdebug_pending]
      sqlite4_memdebug_fail -1
      sqlite4_column_text16 $::STMT 0
      sqlite4_memdebug_fail $mf
      sqlite4_column_int $::STMT 0
    } {0}
    do_test ${testid}.4.5 {
      set mf [sqlite4_memdebug_pending]
      sqlite4_memdebug_fail -1
      sqlite4_column_text16 $::STMT 0
      sqlite4_memdebug_fail $mf
      sqlite4_column_int64 $::STMT 0
    } {0}

    do_test ${testid}.4.6 {
      set mf [sqlite4_memdebug_pending]
      sqlite4_memdebug_fail -1
      sqlite4_column_text16 $::STMT 0
      sqlite4_memdebug_fail $mf
      sqlite4_column_double $::STMT 0
    } {0.0}

    set mallocFailedAfterStep [expr \
      [sqlite4_memdebug_pending] < 0 && !$::mallocFailed
    ]

    sqlite4_memdebug_fail -1
    # Test that if a malloc() failed the next call to sqlite4_step() returns
    # SQLITE4_ERROR. If malloc() did not fail, it should return SQLITE4_DONE.
    #
    do_test ${testid}.5 {
      sqlite4_step $::STMT
    } [expr {$mallocFailedAfterStep ? "SQLITE4_ERROR" : "SQLITE4_DONE"}]

    do_test ${testid}.6 {
      sqlite4_finalize $::STMT
    } [expr {$mallocFailedAfterStep ? "SQLITE4_NOMEM" : "SQLITE4_OK"}]

    if {$::mallocFailed == 0 && $mallocFailedAfterStep == 0} {
      sqlite4_memdebug_fail -1
      set go 0
    }
  }
}

execsql {
  CREATE TABLE tbl(
    the_first_reasonably_long_column_name that_also_has_quite_a_lengthy_type
  );
  INSERT INTO tbl VALUES(
    'An extra long string. Far too long to be stored in NBFS bytes.'
  );
}

do_stmt_test 1 "SELECT * FROM tbl"

sqlite4_memdebug_fail -1
finish_test