# 2007 May 05

#

# 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 common code used by many different malloc tests

# within the test suite.

#

# $Id: malloc_common.tcl,v 1.22 2008/09/23 16:41:30 danielk1977 Exp $

# If we did not compile with malloc testing enabled, then do nothing.

#

ifcapable builtin_test {

  set MEMDEBUG 1

} else {

  set MEMDEBUG 0

  return 0

}

# Usage: do_malloc_test <test number> <options...>

#

# The first argument, <test number>, is an integer used to name the

# tests executed by this proc. Options are as follows:

#

#     -tclprep          TCL script to run to prepare test.

#     -sqlprep          SQL script to run to prepare test.

#     -tclbody          TCL script to run with malloc failure simulation.

#     -sqlbody          TCL script to run with malloc failure simulation.

#     -cleanup          TCL script to run after the test.

#

# This command runs a series of tests to verify SQLite's ability

# to handle an out-of-memory condition gracefully. It is assumed

# that if this condition occurs a malloc() call will return a

# NULL pointer. Linux, for example, doesn't do that by default. See

# the "BUGS" section of malloc(3).

#

# Each iteration of a loop, the TCL commands in any argument passed

# to the -tclbody switch, followed by the SQL commands in any argument

# passed to the -sqlbody switch are executed. Each iteration the

# Nth call to sqliteMalloc() is made to fail, where N is increased

# each time the loop runs starting from 1. When all commands execute

# successfully, the loop ends.

#

proc do_malloc_test {tn args} {

  array unset ::mallocopts 

  array set ::mallocopts $args

  if {[string is integer $tn]} {

    set tn malloc-$tn

  }

  if {[info exists ::mallocopts(-start)]} {

    set start $::mallocopts(-start)

  } else {

    set start 0

  }

  if {[info exists ::mallocopts(-end)]} {

    set end $::mallocopts(-end)

  } else {

    set end 50000

  }

  save_prng_state

  foreach ::iRepeat {0 10000000} {

    set ::go 1

    for {set ::n $start} {$::go && $::n <= $end} {incr ::n} {

      # If $::iRepeat is 0, then the malloc() failure is transient - it

      # fails and then subsequent calls succeed. If $::iRepeat is 1, 

      # then the failure is persistent - once malloc() fails it keeps

      # failing.

      #

      set zRepeat "transient"

      if {$::iRepeat} {set zRepeat "persistent"}

      restore_prng_state

      foreach file [glob -nocomplain test.db-mj*] {file delete -force $file}

      do_test ${tn}.${zRepeat}.${::n} {

        # Remove all traces of database files test.db and test2.db 

        # from the file-system. Then open (empty database) "test.db" 

        # with the handle [db].

        # 

        catch {db close} 

        catch {file delete -force test.db}

        catch {file delete -force test.db-journal}

        catch {file delete -force test2.db}

        catch {file delete -force test2.db-journal}

        if {[info exists ::mallocopts(-testdb)]} {

          file copy $::mallocopts(-testdb) test.db

        }

        catch { sqlite3 db test.db }

        if {[info commands db] ne ""} {

          sqlite3_extended_result_codes db 1

        }

        sqlite3_db_config_lookaside db 0 0 0

        # Execute any -tclprep and -sqlprep scripts.

        #

        if {[info exists ::mallocopts(-tclprep)]} {

          eval $::mallocopts(-tclprep)

        }

        if {[info exists ::mallocopts(-sqlprep)]} {

          execsql $::mallocopts(-sqlprep)

        }

        # Now set the ${::n}th malloc() to fail and execute the -tclbody 

        # and -sqlbody scripts.

        #

        sqlite3_memdebug_fail $::n -repeat $::iRepeat

        set ::mallocbody {}

        if {[info exists ::mallocopts(-tclbody)]} {

          append ::mallocbody "$::mallocopts(-tclbody)\n"

        }

        if {[info exists ::mallocopts(-sqlbody)]} {

          append ::mallocbody "db eval {$::mallocopts(-sqlbody)}"

        }

        # The following block sets local variables as follows:

        #

        #     isFail  - True if an error (any error) was reported by sqlite.

        #     nFail   - The total number of simulated malloc() failures.

        #     nBenign - The number of benign simulated malloc() failures.

        #

        set isFail [catch $::mallocbody msg]

        set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]

        # puts -nonewline " (isFail=$isFail nFail=$nFail nBenign=$nBenign) "

        # If one or more mallocs failed, run this loop body again.

        #

        set go [expr {$nFail>0}]

        if {($nFail-$nBenign)==0} {

          if {$isFail} {

            set v2 $msg

          } else {

            set isFail 1

            set v2 1

          }

        } elseif {!$isFail} {

          set v2 $msg

        } elseif {

          [info command db]=="" || 

          [db errorcode]==7 ||

          $msg=="out of memory"

        } {

          set v2 1

        } else {

          set v2 $msg

          puts [db errorcode]

        }

        lappend isFail $v2

      } {1 1}

      if {[info exists ::mallocopts(-cleanup)]} {

        catch [list uplevel #0 $::mallocopts(-cleanup)] msg

      }

    }

  }

  unset ::mallocopts

  sqlite3_memdebug_fail -1

}