[External] Remove external from RT-Thread

1 files changed, 0 insertions, 194 deletions

diff --git a/components/external/SQLite-3.8.1/test/malloc4.test b/components/external/SQLite-3.8.1/test/malloc4.test
deleted file mode 100644
index e2a616a589..0000000000
--- a/components/external/SQLite-3.8.1/test/malloc4.test
+++ /dev/null
@@ -1,194 +0,0 @@
-# 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 sqlite3_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 sqlite3_column_name(),
-#       sqlite3_column_name16(), sqlite3_column_decltype(), or
-#       sqlite3_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 -DSQLITE_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 [sqlite3_prepare $::DB $sql -1 TAIL]
-      expr [string length $::STMT] > 0
-    } {1}
-
-    # Set the Nth malloc() to fail.
-    sqlite3_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 [sqlite3_memdebug_pending] < 0]
-      set ::name8  [sqlite3_column_name $::STMT 0]
-      set mf2 [expr [sqlite3_memdebug_pending] < 0]
-      expr {$mf1 == $mf2 || $::name8 == ""}
-    } {1}
-    do_test ${testid}.2.2 {
-      set mf1 [expr [sqlite3_memdebug_pending] < 0]
-      set ::name16 [sqlite3_column_name16 $::STMT 0]
-      set ::name16 [encoding convertfrom unicode $::name16]
-      set ::name16 [string range $::name16 0 end-1]
-      set mf2 [expr [sqlite3_memdebug_pending] < 0]
-      expr {$mf1 == $mf2 || $::name16 == ""}
-    } {1}
-    do_test ${testid}.2.3 {
-      set mf1 [expr [sqlite3_memdebug_pending] < 0]
-      set ::name8_2 [sqlite3_column_name $::STMT 0]
-      set mf2 [expr [sqlite3_memdebug_pending] < 0]
-      expr {$mf1 == $mf2 || $::name8_2 == ""}
-    } {1}
-    set ::mallocFailed [expr [sqlite3_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 sqlite3_step(), make sure that malloc() is not about to fail.
-    # Memory allocation failures that occur within sqlite3_step() are tested
-    # elsewhere.
-    set mf [sqlite3_memdebug_pending]
-    sqlite3_memdebug_fail -1
-    do_test ${testid}.3 {
-      sqlite3_step $::STMT
-    } {SQLITE_ROW}
-    sqlite3_memdebug_fail $mf
-
-    # Test for malloc() failures within _text() and _text16().
-    #
-    do_test ${testid}.4.1 {
-      set ::text8 [sqlite3_column_text $::STMT 0]
-      set mf [expr [sqlite3_memdebug_pending] < 0 && !$::mallocFailed]
-      expr {$mf==0 || $::text8 == ""}
-    } {1}
-    do_test ${testid}.4.2 {
-      set ::text16 [sqlite3_column_text16 $::STMT 0]
-      set ::text16 [encoding convertfrom unicode $::text16]
-      set ::text16 [string range $::text16 0 end-1]
-      set mf [expr [sqlite3_memdebug_pending] < 0 && !$::mallocFailed]
-      expr {$mf==0 || $::text16 == ""}
-    } {1}
-    do_test ${testid}.4.3 {
-      set ::text8_2 [sqlite3_column_text $::STMT 0]
-      set mf [expr [sqlite3_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 [sqlite3_memdebug_pending]
-      sqlite3_memdebug_fail -1
-      sqlite3_column_text16 $::STMT 0
-      sqlite3_memdebug_fail $mf
-      sqlite3_column_int $::STMT 0
-    } {0}
-    do_test ${testid}.4.5 {
-      set mf [sqlite3_memdebug_pending]
-      sqlite3_memdebug_fail -1
-      sqlite3_column_text16 $::STMT 0
-      sqlite3_memdebug_fail $mf
-      sqlite3_column_int64 $::STMT 0
-    } {0}
-
-    do_test ${testid}.4.6 {
-      set mf [sqlite3_memdebug_pending]
-      sqlite3_memdebug_fail -1
-      sqlite3_column_text16 $::STMT 0
-      sqlite3_memdebug_fail $mf
-      sqlite3_column_double $::STMT 0
-    } {0.0}
-
-    set mallocFailedAfterStep [expr \
-      [sqlite3_memdebug_pending] < 0 && !$::mallocFailed
-    ]
-
-    sqlite3_memdebug_fail -1
-    # Test that if a malloc() failed the next call to sqlite3_step() returns
-    # SQLITE_ERROR. If malloc() did not fail, it should return SQLITE_DONE.
-    #
-    do_test ${testid}.5 {
-      sqlite3_step $::STMT
-    } [expr {$mallocFailedAfterStep ? "SQLITE_ERROR" : "SQLITE_DONE"}]
-
-    do_test ${testid}.6 {
-      sqlite3_finalize $::STMT
-    } [expr {$mallocFailedAfterStep ? "SQLITE_NOMEM" : "SQLITE_OK"}]
-
-    if {$::mallocFailed == 0 && $mallocFailedAfterStep == 0} {
-      sqlite3_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"
-
-sqlite3_memdebug_fail -1
-finish_test