# 2006 July 14

#

# 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 implements regression tests for SQLite library.  The

# focus of this script is extension loading.

#

# $Id: loadext.test,v 1.15 2008/08/22 13:57:39 pweilbacher Exp $

set testdir [file dirname $argv0]

source $testdir/tester.tcl

ifcapable !load_ext {

  finish_test

  return

}

# The name of the test extension varies by operating system.

#

if {$::tcl_platform(platform) eq "windows" || $::tcl_platform(platform) eq "os2"} {

  set testextension ./testloadext.dll

} else {

  set testextension ./libtestloadext.so

}

set gcc_shared -shared

if {$::tcl_platform(os) eq "Darwin"} {

  set gcc_shared -dynamiclib

}

# The error messages tested by this file are operating system dependent

# (because they are returned by sqlite3OsDlError()). For now, they only

# work with UNIX (and probably only certain kinds of UNIX).

#

# When a shared-object cannot be opened because it does not exist, the

# format of the message returned is:

#

#      [format $dlerror_nosuchfile <shared-object-name>]

#

# When a shared-object cannot be opened because it consists of the 4

# characters "blah" only, we expect the error message to be:

#

#      [format $dlerror_notadll <shared-object-name>]

#

# When a symbol cannot be found within an open shared-object, the error

# message should be:

#

#      [format $dlerror_nosymbol <shared-object-name> <symbol-name>]

#

# The exact error messages are not important. The important bit is

# that SQLite is correctly copying the message from xDlError().

#

set dlerror_nosuchfile \

    {%s: cannot open shared object file: No such file or directory}

set dlerror_notadll    {%s: file too short}

set dlerror_nosymbol   {%s: undefined symbol: %s}

if {$::tcl_platform(os) eq "Darwin"} {

  set dlerror_nosuchfile {dlopen(%s, 10): image not found}

  set dlerror_notadll    {dlopen(%1$s, 10): no suitable image found.  Did find:

	%1$s: file to short}

  set dlerror_nosymbol   {dlsym(XXX, %2$s): symbol not found}

}

# Make sure the test extension actually exists.  If it does not

# exist, try to create it.  If unable to create it, then skip this

# test file.

#

if {![file exists $testextension]} {

  set srcdir [file dir $testdir]/src

  set testextsrc $srcdir/test_loadext.c

  if {[catch {

    exec gcc $gcc_shared -Wall -I$srcdir -I. -g $testextsrc -o $testextension

  } msg]} {

    puts "Skipping loadext tests: Test extension not built..."

    puts $msg

    finish_test

    return

  }

}

# Test that loading the extension produces the expected results - adding

# the half() function to the specified database handle.

#

do_test loadext-1.1 {

  catchsql {

    SELECT half(1.0);

  }

} {1 {no such function: half}}

do_test loadext-1.2 {

  db enable_load_extension 1

  sqlite3_load_extension db $testextension testloadext_init

  catchsql {

    SELECT half(1.0);

  }

} {0 0.5}

# Test that a second database connection (db2) can load the extension also.

#

do_test loadext-1.3 {

  sqlite3 db2 test.db

  sqlite3_enable_load_extension db2 1

  catchsql {

    SELECT half(1.0);

  } db2

} {1 {no such function: half}}

do_test loadext-1.4 {

  sqlite3_load_extension db2 $testextension testloadext_init

  catchsql {

    SELECT half(1.0);

  } db2

} {0 0.5}

# Close the first database connection. Then check that the second database

# can still use the half() function without a problem.

#

do_test loadext-1.5 {

  db close

  catchsql {

    SELECT half(1.0);

  } db2

} {0 0.5}

db2 close

sqlite3 db test.db

sqlite3_enable_load_extension db 1

# Try to load an extension for which the file does not exist.

#

do_test loadext-2.1 {

  file delete -force ${testextension}xx

  set rc [catch {

    sqlite3_load_extension db "${testextension}xx"

  } msg]

  list $rc $msg

} [list 1 [format $dlerror_nosuchfile ${testextension}xx]]

# Try to load an extension for which the file is not a shared object

#

do_test loadext-2.2 {

  set fd [open "${testextension}xx" w]

  puts $fd blah

  close $fd

  set rc [catch {

    sqlite3_load_extension db "${testextension}xx"

  } msg]

  list $rc $msg

} [list 1 [format $dlerror_notadll ${testextension}xx]]

# Try to load an extension for which the file is present but the

# entry point is not.

#

do_test loadext-2.3 {

  set rc [catch {

    sqlite3_load_extension db $testextension icecream

  } msg]

  if {$::tcl_platform(os) eq "Darwin"} {

    regsub {0x[1234567890abcdefABCDEF]*} $msg XXX msg

  }

  list $rc $msg

} [list 1 [format $dlerror_nosymbol $testextension icecream]]

# Try to load an extension for which the entry point fails (returns non-zero) 

#

do_test loadext-2.4 {

  set rc [catch {

    sqlite3_load_extension db $testextension testbrokenext_init

  } msg]

  list $rc $msg

} {1 {error during initialization: broken!}}

############################################################################

# Tests for the load_extension() SQL function

#

db close

sqlite3 db test.db

sqlite3_enable_load_extension db 1

do_test loadext-3.1 {

  catchsql {

    SELECT half(5);

  }

} {1 {no such function: half}}

do_test loadext-3.2 {

  set res [catchsql {

    SELECT load_extension($::testextension)

  }]

  if {$::tcl_platform(os) eq "Darwin"} {

    regsub {0x[1234567890abcdefABCDEF]*} $res XXX res

  }

  set res

} [list 1 [format $dlerror_nosymbol $testextension sqlite3_extension_init]]

do_test loadext-3.3 {

  catchsql {

    SELECT load_extension($::testextension,'testloadext_init')

  }

} {0 {{}}}

do_test loadext-3.4 {

  catchsql {

    SELECT half(5);

  }

} {0 2.5}

do_test loadext-3.5 {

  db eval {

    SELECT sqlite3_status('MEMORY_USED') AS mused

  } break

  puts -nonewline " (memory_used=$mused) "

  expr {$mused>0}

} {1}

do_test loadext-3.6 {

  catchsql {

    SELECT sqlite3_status('MEMORY_USED_X') AS mused

  }

} {1 {unknown status property: MEMORY_USED_X}}

do_test loadext-3.7 {

  catchsql {

    SELECT sqlite3_status(4.53) AS mused

  }

} {1 {unknown status type}}

do_test loadext-3.8 {

  catchsql {

    SELECT sqlite3_status(23) AS mused

  }

} {1 {sqlite3_status(23,...) returns 21}}

# Ticket #1863

# Make sure the extension loading mechanism will not work unless it

# is explicitly enabled.

#

db close

sqlite3 db test.db

do_test loadext-4.1 {

  catchsql {

    SELECT load_extension($::testextension,'testloadext_init')

  }

} {1 {not authorized}}

do_test loadext-4.2 {

  sqlite3_enable_load_extension db 1

  catchsql {

    SELECT load_extension($::testextension,'testloadext_init')

  }

} {0 {{}}}

do_test loadext-4.3 {

  sqlite3_enable_load_extension db 0

  catchsql {

    SELECT load_extension($::testextension,'testloadext_init')

  }

} {1 {not authorized}}

source $testdir/malloc_common.tcl

# Malloc failure in sqlite3_auto_extension and sqlite3_load_extension

#

do_malloc_test loadext-5 -tclprep {

  sqlite3_reset_auto_extension

} -tclbody {

  if {[autoinstall_test_functions]==7} {error "out of memory"}

}

do_malloc_test loadext-6 -tclbody {

  db enable_load_extension 1

  sqlite3_load_extension db $::testextension testloadext_init

}

autoinstall_test_functions

finish_test