From f46188911d103c4a1f0e9f182783c5f1ec39294b Mon Sep 17 00:00:00 2001 From: danielk1977 Date: Mon, 28 Jun 2004 13:09:11 +0000 Subject: [PATCH] More coverage testing. (CVS 1754) FossilOrigin-Name: 332921041040b343b6b568685ff55d21a624f502 --- manifest | 29 +++++++------ manifest.uuid | 2 +- src/func.c | 84 ++++++++++++++++++++--------------- src/sqliteInt.h | 3 +- src/utf.c | 82 ++++++++++++++++++++++++++++++++++- src/vdbe.c | 10 +++-- src/vdbeapi.c | 6 +-- src/vdbemem.c | 8 +++- test/bind.test | 26 ++++++++++- test/capi3.test | 113 ++++++++++++++++++++++++++++++++++++------------ test/utf16.test | 57 ++++++++++++++++++++++++ 11 files changed, 329 insertions(+), 91 deletions(-) create mode 100644 test/utf16.test diff --git a/manifest b/manifest index e965357462..9efc7f1ab1 100644 --- a/manifest +++ b/manifest @@ -1,5 +1,5 @@ -C Get\sall\stests\sworking\sunder\swin2k.\s(CVS\s1753) -D 2004-06-28T11:52:46 +C More\scoverage\stesting.\s(CVS\s1754) +D 2004-06-28T13:09:11 F Makefile.in cb7a9889c38723f72b2506c4236ff30a05ff172b F Makefile.linux-gcc a9e5a0d309fa7c38e7c14d3ecf7690879d3a5457 F README f1de682fbbd94899d50aca13d387d1b3fd3be2dd @@ -33,7 +33,7 @@ F src/date.c b3e8b2bef1e3f2ce24e5b057203036defb18c3f1 F src/delete.c e81545e546f6bc87d7508a93a09ca70695265af3 F src/encode.c a876af473d1d636faa3dca51c7571f2e007eea37 F src/expr.c d8ee92a9c11113a013f7853acb55453a8e0b2e92 -F src/func.c c38c8bcaf118204baf343711b9e7f5bf804ed9c3 +F src/func.c 5a15cfb0f1d9e5abbd42407205d5d6e2b0c09fb2 F src/hash.c 440c2f8cb373ee1b4e13a0988489c7cd95d55b6f F src/hash.h 762d95f1e567664d1eafc1687de755626be962fb F src/insert.c d99ffe87e1e1397f4233afcd06841d52d6b17b18 @@ -59,7 +59,7 @@ F src/random.c eff68e3f257e05e81eae6c4d50a51eb88beb4ff3 F src/select.c f02a65af34231031896e8442161cb5251e191e75 F src/shell.c 24b641700c9d90f361fcfa4f432c5b4aff704e6d F src/sqlite.h.in b70fded2bdfeaddfb06adea3888118b722975136 -F src/sqliteInt.h d1911e120fb20ff9ba4cf0115065ac6569268cec +F src/sqliteInt.h fedb84ed45a0019ca6ea77c815942f6397cb46a0 F src/table.c af14284fa36c8d41f6829e3f2819dce07d3e2de2 F src/tclsqlite.c 8d093146332b2f0cbf2a8ebe8597d481619308a3 F src/test1.c 0eca68f6e70069aad7ad0fd91fda886926646786 @@ -70,15 +70,15 @@ F src/test5.c b001fa7f1b9e2dc5c2331de62fc641b5ab2bd7a1 F src/tokenize.c 900374b6b37f04748bcd48c2d29a41c251542935 F src/trigger.c 296e888ae931e9774e1761996b2b66db40f7d216 F src/update.c b66b1896c9da54678ba3eff2bf0b4d291a95986a -F src/utf.c a8fb39c94ae4ef6606d5216b6f05d9b86f6901b2 +F src/utf.c f03535db72bfa09e24202ccdd245f21d2fc65f0a F src/util.c 43d0289d49f43c66847ebbeddfb85a2a0d1ddd2d F src/vacuum.c 353c7f69dbeb6738434d81798465cc0698844640 -F src/vdbe.c 5a381d4a4cd1c5b7325a3f6756bb3d051f81c6e6 +F src/vdbe.c dc9d25cb8dcfe23b8fa963af543b9c65eb99c4a5 F src/vdbe.h 75b241c02431b9c0f16eaa9cdbb34146c6287f52 F src/vdbeInt.h d83fd7389838453d8392915c21f432014afc99cf -F src/vdbeapi.c e92bda928f2fe93a9a77a62bd95642563bbcdea1 +F src/vdbeapi.c ba3722f45db3d3c3509bf5d24f4f868f4c64449d F src/vdbeaux.c f9b1b3d4d2f1c31f6db1ae1536e17e4eb5454205 -F src/vdbemem.c e8ae1f56ad16d5b01119e8dc1d25e913e06c3128 +F src/vdbemem.c 053f8adcb644bca1c1e4ad08f4016cb7ee6bf1b8 F src/where.c 6507074d8ce3f78e7a4cd33f667f11e62020553e F test/all.test d591e074013248176402a16a0fb6fc82d241bad5 F test/attach.test 3acdffccbf5f78b07746771b9490758718e28856 @@ -87,7 +87,7 @@ F test/attach3.test c4cc0b806783ce3d860af6b80c947f93ffb14270 F test/auth.test a211eab0542ec024b578d771b09242dd9bb1aba3 F test/bigfile.test a1101b46528ad7282fb9b323d25da18672a3bd0a F test/bigrow.test 8ab252dba108f12ad64e337b0f2ff31a807ac578 -F test/bind.test 028f65c44d5addfedaf81eb4c0b69a63d2439241 +F test/bind.test ca031e902f63fb7d69545b4a47b0c7aea8747ffe F test/blob.test 8727a7b46b2073a369cfc9bcb6f54dd366b9d884 F test/btree.test f1dc208d59b1c28f853ba09dd2553fc3382d22b6 F test/btree2.test aa4a6d05b1ea90b1acaf83ba89039dd302a88635 @@ -96,7 +96,7 @@ F test/btree5.test 8e5ff32c02e685d36516c6499add9375fe1377f2 F test/btree6.test a5ede6bfbbb2ec8b27e62813612c0f28e8f3e027 F test/btree7.test 429b96cfef5b51a7d512cfb4b5b3e453384af293 F test/capi2.test fe61f341e953f73c29bacfcbdaf688cd7b0e0d38 -F test/capi3.test ac53507f69b14fe026634afa09e6512f678f161d +F test/capi3.test b05be389b8106c83b78db7a3ca3f7cb1e96d163e F test/collate1.test 2ee4fa3a47a652ccf56c5ddf65dcc44d9bad82ef F test/collate2.test c1a3b41f761b28853c5696037f92de928f93233b F test/collate3.test e60b428e07ec945492ba90ff1c895902ee3a8a50 @@ -173,6 +173,7 @@ F test/types.test 6c49e574970866558365a025b44c9fd8a162ef0d F test/types2.test 5d725fcb68dbd032c6d4950d568d75fa33872687 F test/unique.test 0e38d4cc7affeef2527720d1dafd1f6870f02f2b F test/update.test b29bd9061a1150426dab6959806fcc73a41b1217 +F test/utf16.test 86650f5fe40dcd7ada4b305cb54d6753d9ab7319 F test/vacuum.test 3922b97f958986a9ab198c30480f54361087a06f F test/varint.test ab7b110089a08b9926ed7390e7e97bdefeb74102 F test/view.test b42c98499ae9fbf578cd7a4b020d23057c8825fb @@ -230,7 +231,7 @@ F www/tclsqlite.tcl 19191cf2a1010eaeff74c51d83fd5f5a4d899075 F www/vdbe.tcl 59288db1ac5c0616296b26dce071c36cb611dfe9 F www/version3.tcl 563ba3ac02f64da27ab17f3edbe8e56bfd0293fb F www/whentouse.tcl a8335bce47cc2fddb07f19052cb0cb4d9129a8e4 -P b0fcc99d227c061203fb1e0f4583b66723033159 -R ef365fb61dcd45108ed65368cfbc0124 -U drh -Z 91da1422b7cc4d27c359e506557fc669 +P 168112c8b76af132c675a6508d3ee7764ef7a845 +R 00c6e5e0864fee373c498713d6bf3097 +U danielk1977 +Z c7d1e1ed337b1cd26cb4eaf2ffbfdf15 diff --git a/manifest.uuid b/manifest.uuid index 72b8943510..a0ef54f1f9 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -168112c8b76af132c675a6508d3ee7764ef7a845 \ No newline at end of file +332921041040b343b6b568685ff55d21a624f502 \ No newline at end of file diff --git a/src/func.c b/src/func.c index e8cea2bbde..023a42f92d 100644 --- a/src/func.c +++ b/src/func.c @@ -16,7 +16,7 @@ ** sqliteRegisterBuildinFunctions() found at the bottom of the file. ** All other code has file scope. ** -** $Id: func.c,v 1.76 2004/06/24 00:20:05 danielk1977 Exp $ +** $Id: func.c,v 1.77 2004/06/28 13:09:11 danielk1977 Exp $ */ #include #include @@ -794,14 +794,26 @@ static void test_destructor( sqlite3_value **argv ){ char *zVal; + int len; + sqlite *db = sqlite3_user_data(pCtx); + test_destructor_count_var++; assert( nArg==1 ); if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; - zVal = sqliteMalloc(sqlite3_value_bytes(argv[0]) + 2); + len = sqlite3ValueBytes(argv[0], db->enc); + zVal = sqliteMalloc(len+3); + zVal[len] = 0; + zVal[len-1] = 0; assert( zVal ); zVal++; - strcpy(zVal, sqlite3_value_text(argv[0])); - sqlite3_result_text(pCtx, zVal, -1, destructor); + memcpy(zVal, sqlite3ValueText(argv[0], db->enc), len); + if( db->enc==SQLITE_UTF8 ){ + sqlite3_result_text(pCtx, zVal, -1, destructor); + }else if( db->enc==SQLITE_UTF16LE ){ + sqlite3_result_text16le(pCtx, zVal, -1, destructor); + }else{ + sqlite3_result_text16be(pCtx, zVal, -1, destructor); + } } static void test_destructor_count( sqlite3_context *pCtx, @@ -1010,45 +1022,45 @@ void sqlite3RegisterBuiltinFunctions(sqlite *db){ static struct { char *zName; signed char nArg; - u8 argType; /* 0: none. 1: db 2: (-1) */ - u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */ + u8 argType; /* 0: none. 1: db 2: (-1) */ + u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */ u8 needCollSeq; void (*xFunc)(sqlite3_context*,int,sqlite3_value **); } aFuncs[] = { - { "min", -1, 0, SQLITE_UTF8, 1, minmaxFunc }, - { "min", 0, 0, SQLITE_UTF8, 1, 0 }, - { "max", -1, 2, SQLITE_UTF8, 1, minmaxFunc }, - { "max", 0, 2, SQLITE_UTF8, 1, 0 }, - { "typeof", 1, 0, SQLITE_UTF8, 0, typeofFunc }, - { "length", 1, 0, SQLITE_UTF8, 0, lengthFunc }, - { "substr", 3, 0, SQLITE_UTF8, 0, substrFunc }, - { "abs", 1, 0, SQLITE_UTF8, 0, absFunc }, - { "round", 1, 0, SQLITE_UTF8, 0, roundFunc }, - { "round", 2, 0, SQLITE_UTF8, 0, roundFunc }, - { "upper", 1, 0, SQLITE_UTF8, 0, upperFunc }, - { "lower", 1, 0, SQLITE_UTF8, 0, lowerFunc }, - { "coalesce", -1, 0, SQLITE_UTF8, 0, ifnullFunc }, - { "coalesce", 0, 0, SQLITE_UTF8, 0, 0 }, - { "coalesce", 1, 0, SQLITE_UTF8, 0, 0 }, - { "ifnull", 2, 0, SQLITE_UTF8, 1, ifnullFunc }, - { "random", -1, 0, SQLITE_UTF8, 0, randomFunc }, - { "like", 2, 0, SQLITE_UTF8, 0, likeFunc }, -/* { "like", 2, 2, SQLITE_UTF16,0, likeFunc }, */ - { "glob", 2, 0, SQLITE_UTF8, 0, globFunc }, - { "nullif", 2, 0, SQLITE_UTF8, 0, nullifFunc }, - { "sqlite_version", 0, 0, SQLITE_UTF8, 0, versionFunc}, - { "quote", 1, 0, SQLITE_UTF8, 0, quoteFunc }, - { "last_insert_rowid", 0, 1, SQLITE_UTF8, 0, last_insert_rowid }, - { "changes", 0, 1, SQLITE_UTF8, 0, changes }, - { "total_changes", 0, 1, SQLITE_UTF8, 0, total_changes }, + { "min", -1, 0, SQLITE_UTF8, 1, minmaxFunc }, + { "min", 0, 0, SQLITE_UTF8, 1, 0 }, + { "max", -1, 2, SQLITE_UTF8, 1, minmaxFunc }, + { "max", 0, 2, SQLITE_UTF8, 1, 0 }, + { "typeof", 1, 0, SQLITE_UTF8, 0, typeofFunc }, + { "length", 1, 0, SQLITE_UTF8, 0, lengthFunc }, + { "substr", 3, 0, SQLITE_UTF8, 0, substrFunc }, + { "substr", 3, 0, SQLITE_UTF16LE, 0, sqlite3utf16Substr }, + { "abs", 1, 0, SQLITE_UTF8, 0, absFunc }, + { "round", 1, 0, SQLITE_UTF8, 0, roundFunc }, + { "round", 2, 0, SQLITE_UTF8, 0, roundFunc }, + { "upper", 1, 0, SQLITE_UTF8, 0, upperFunc }, + { "lower", 1, 0, SQLITE_UTF8, 0, lowerFunc }, + { "coalesce", -1, 0, SQLITE_UTF8, 0, ifnullFunc }, + { "coalesce", 0, 0, SQLITE_UTF8, 0, 0 }, + { "coalesce", 1, 0, SQLITE_UTF8, 0, 0 }, + { "ifnull", 2, 0, SQLITE_UTF8, 1, ifnullFunc }, + { "random", -1, 0, SQLITE_UTF8, 0, randomFunc }, + { "like", 2, 0, SQLITE_UTF8, 0, likeFunc }, + { "glob", 2, 0, SQLITE_UTF8, 0, globFunc }, + { "nullif", 2, 0, SQLITE_UTF8, 0, nullifFunc }, + { "sqlite_version", 0, 0, SQLITE_UTF8, 0, versionFunc}, + { "quote", 1, 0, SQLITE_UTF8, 0, quoteFunc }, + { "last_insert_rowid", 0, 1, SQLITE_UTF8, 0, last_insert_rowid }, + { "changes", 0, 1, SQLITE_UTF8, 0, changes }, + { "total_changes", 0, 1, SQLITE_UTF8, 0, total_changes }, #ifdef SQLITE_SOUNDEX - { "soundex", 1, 0, SQLITE_UTF8, 0, soundexFunc}, + { "soundex", 1, 0, SQLITE_UTF8, 0, soundexFunc}, #endif #ifdef SQLITE_TEST - { "randstr", 2, 0, SQLITE_UTF8, 0, randStr }, - { "test_destructor", 1, 0, SQLITE_UTF8, 0, test_destructor}, + { "randstr", 2, 0, SQLITE_UTF8, 0, randStr }, + { "test_destructor", 1, 1, SQLITE_UTF8, 0, test_destructor}, { "test_destructor_count", 0, 0, SQLITE_UTF8, 0, test_destructor_count}, - { "test_auxdata", -1, 0, SQLITE_UTF8, 0, test_auxdata}, + { "test_auxdata", -1, 0, SQLITE_UTF8, 0, test_auxdata}, #endif }; static struct { diff --git a/src/sqliteInt.h b/src/sqliteInt.h index 60fccc7878..fde5bac5bc 100644 --- a/src/sqliteInt.h +++ b/src/sqliteInt.h @@ -11,7 +11,7 @@ ************************************************************************* ** Internal interface definitions for SQLite. ** -** @(#) $Id: sqliteInt.h,v 1.301 2004/06/26 08:38:25 danielk1977 Exp $ +** @(#) $Id: sqliteInt.h,v 1.302 2004/06/28 13:09:11 danielk1977 Exp $ */ #ifndef _SQLITEINT_H_ #define _SQLITEINT_H_ @@ -1368,6 +1368,7 @@ int sqlite3CheckCollSeq(Parse *, CollSeq *); int sqlite3CheckIndexCollSeq(Parse *, Index *); int sqlite3CheckObjectName(Parse *, const char *); void sqlite3VdbeSetChanges(sqlite3 *, int); +void sqlite3utf16Substr(sqlite3_context *,int,sqlite3_value **); const void *sqlite3ValueText(sqlite3_value*, u8); int sqlite3ValueBytes(sqlite3_value*, u8); diff --git a/src/utf.c b/src/utf.c index 326e9bde96..5fc37b5b58 100644 --- a/src/utf.c +++ b/src/utf.c @@ -12,7 +12,7 @@ ** This file contains routines used to translate between UTF-8, ** UTF-16, UTF-16BE, and UTF-16LE. ** -** $Id: utf.c,v 1.25 2004/06/23 13:46:32 danielk1977 Exp $ +** $Id: utf.c,v 1.26 2004/06/28 13:09:11 danielk1977 Exp $ ** ** Notes on UTF-8: ** @@ -210,6 +210,38 @@ static const int xtra_utf8_bits[4] = { } \ } +#define SKIP_UTF16BE(zIn){ \ + if( *zIn>=0xD8 && (*zIn<0xE0 || (*zIn==0xE0 && *(zIn+1)==0x00)) ){ \ + zIn += 4; \ + }else{ \ + zIn += 2; \ + } \ +} +#define SKIP_UTF16LE(zIn){ \ + zIn++; \ + if( *zIn>=0xD8 && (*zIn<0xE0 || (*zIn==0xE0 && *(zIn-1)==0x00)) ){ \ + zIn += 3; \ + }else{ \ + zIn += 1; \ + } \ +} + +#define RSKIP_UTF16LE(zIn){ \ + if( *zIn>=0xD8 && (*zIn<0xE0 || (*zIn==0xE0 && *(zIn-1)==0x00)) ){ \ + zIn -= 4; \ + }else{ \ + zIn -= 2; \ + } \ +} +#define RSKIP_UTF16BE(zIn){ \ + zIn--; \ + if( *zIn>=0xD8 && (*zIn<0xE0 || (*zIn==0xE0 && *(zIn+1)==0x00)) ){ \ + zIn -= 3; \ + }else{ \ + zIn -= 1; \ + } \ +} + /* ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is ** printed on stderr on the way into and out of sqlite3VdbeMemTranslate(). @@ -507,6 +539,54 @@ int sqlite3utf8LikeCompare( return *zString==0; } +/* +** UTF-16 implementation of the substr() +*/ +void sqlite3utf16Substr( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int y, z; + unsigned char const *zStr; + unsigned char const *zStrEnd; + unsigned char const *zStart; + unsigned char const *zEnd; + int i; + + zStr = (unsigned char const *)sqlite3_value_text16(argv[0]); + zStrEnd = &zStr[sqlite3_value_bytes16(argv[0])]; + y = sqlite3_value_int(argv[1]); + z = sqlite3_value_int(argv[2]); + + if( y>0 ){ + y = y-1; + zStart = zStr; + if( SQLITE_UTF16BE==SQLITE_UTF16NATIVE ){ + for(i=0; izStr; i++) RSKIP_UTF16BE(zStart); + }else{ + for(i=y; i<0 && zStart>zStr; i++) RSKIP_UTF16LE(zStart); + } + for(; i<0; i++) z -= 1; + } + + zEnd = zStart; + if( SQLITE_UTF16BE==SQLITE_UTF16NATIVE ){ + for(i=0; izErrMsg, - (pTos->flags & MEM_Str)!=0 ? pTos->z : "user function error", (char*)0); + if( !(pTos->flags&MEM_Str) ){ + sqlite3SetString(&p->zErrMsg, "user function error", (char*)0); + }else{ + sqlite3SetString(&p->zErrMsg, sqlite3_value_text(pTos), (char*)0); + sqlite3VdbeChangeEncoding(pTos, db->enc); + } rc = SQLITE_ERROR; } break; diff --git a/src/vdbeapi.c b/src/vdbeapi.c index 57b1b87766..6935ca7d1a 100644 --- a/src/vdbeapi.c +++ b/src/vdbeapi.c @@ -341,7 +341,6 @@ const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){ Mem *pColName; if( N>=sqlite3_column_count(pStmt) || N<0 ){ - sqlite3Error(p->db, SQLITE_RANGE, 0); return 0; } @@ -358,7 +357,6 @@ const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){ Mem *pColName; if( N>=sqlite3_column_count(pStmt) || N<0 ){ - sqlite3Error(p->db, SQLITE_RANGE, 0); return 0; } @@ -375,7 +373,6 @@ const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){ Mem *pColName; if( N>=sqlite3_column_count(pStmt) || N<0 ){ - sqlite3Error(p->db, SQLITE_RANGE, 0); return 0; } @@ -392,7 +389,6 @@ const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){ Mem *pColName; if( N>=sqlite3_column_count(pStmt) || N<0 ){ - sqlite3Error(p->db, SQLITE_RANGE, 0); return 0; } @@ -459,7 +455,7 @@ int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){ if( rc==SQLITE_OK ){ sqlite3VdbeMemSetDouble(&p->apVar[i-1], rValue); } - return SQLITE_OK; + return rc; } int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){ return sqlite3_bind_int64(p, i, (i64)iValue); diff --git a/src/vdbemem.c b/src/vdbemem.c index 55b0fbb9ff..7f26c7dd69 100644 --- a/src/vdbemem.c +++ b/src/vdbemem.c @@ -497,13 +497,19 @@ int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){ if( pMem1->enc==pColl->enc ){ return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z); }else{ - return pColl->xCmp( + u8 origEnc = pMem1->enc; + rc = pColl->xCmp( pColl->pUser, sqlite3ValueBytes((sqlite3_value*)pMem1, pColl->enc), sqlite3ValueText((sqlite3_value*)pMem1, pColl->enc), sqlite3ValueBytes((sqlite3_value*)pMem2, pColl->enc), sqlite3ValueText((sqlite3_value*)pMem2, pColl->enc) ); + sqlite3ValueBytes((sqlite3_value*)pMem1, origEnc); + sqlite3ValueText((sqlite3_value*)pMem1, origEnc); + sqlite3ValueBytes((sqlite3_value*)pMem2, origEnc); + sqlite3ValueText((sqlite3_value*)pMem2, origEnc); + return rc; } } /* If a NULL pointer was passed as the collate function, fall through diff --git a/test/bind.test b/test/bind.test index 3d668a7f4e..3ddb208db9 100644 --- a/test/bind.test +++ b/test/bind.test @@ -11,7 +11,7 @@ # This file implements regression tests for SQLite library. The # focus of this script testing the sqlite_bind API. # -# $Id: bind.test,v 1.13 2004/06/22 12:46:54 drh Exp $ +# $Id: bind.test,v 1.14 2004/06/28 13:09:11 danielk1977 Exp $ # set testdir [file dirname $argv0] @@ -231,6 +231,30 @@ do_test bind-8.7 { encoding convertfrom unicode [sqlite3_errmsg16 $DB] } {bind index out of range} +do_test bind-8.8 { + catch { sqlite3_bind_blob $VM 0 "abc" 3 } +} {1} +do_test bind-8.9 { + catch { sqlite3_bind_blob $VM 4 "abc" 3 } +} {1} +do_test bind-8.10 { + catch { sqlite3_bind_text $VM 0 "abc" 3 } +} {1} +do_test bind-8.11 { + catch { sqlite3_bind_text16 $VM 4 "abc" 2 } +} {1} +do_test bind-8.12 { + catch { sqlite3_bind_int $VM 0 5 } +} {1} +do_test bind-8.13 { + catch { sqlite3_bind_int $VM 4 5 } +} {1} +do_test bind-8.14 { + catch { sqlite3_bind_double $VM 0 5.0 } +} {1} +do_test bind-8.15 { + catch { sqlite3_bind_double $VM 4 6.0 } +} {1} do_test bind-9.99 { sqlite3_finalize $VM diff --git a/test/capi3.test b/test/capi3.test index 87d2df8911..46a37c29dd 100644 --- a/test/capi3.test +++ b/test/capi3.test @@ -11,7 +11,7 @@ # This file implements regression tests for SQLite library. The # focus of this script testing the callback-free C/C++ API. # -# $Id: capi3.test,v 1.13 2004/06/27 01:56:33 drh Exp $ +# $Id: capi3.test,v 1.14 2004/06/28 13:09:11 danielk1977 Exp $ # set testdir [file dirname $argv0] @@ -181,8 +181,8 @@ proc check_header {STMT test names decltypes} { # a list of column indexes. i.e. If sqlite3_column_count # is 3, build the list {0 1 2}. set ::idxlist [list] - set numcols [sqlite3_column_count $STMT] - for {set i 0} {$i < $numcols} {incr i} {lappend ::idxlist $i} + set ::numcols [sqlite3_column_count $STMT] + for {set i 0} {$i < $::numcols} {incr i} {lappend ::idxlist $i} # Column names in UTF-8 do_test $test.1 { @@ -232,6 +232,20 @@ proc check_header {STMT test names decltypes} { set cnamelist } $decltypes + + # Test some out of range conditions: + do_test $test.7 { + list \ + [sqlite3_column_name $STMT -1] \ + [sqlite3_column_name16 $STMT -1] \ + [sqlite3_column_decltype $STMT -1] \ + [sqlite3_column_decltype16 $STMT -1] \ + [sqlite3_column_name $STMT $numcols] \ + [sqlite3_column_name16 $STMT $numcols] \ + [sqlite3_column_decltype $STMT $numcols] \ + [sqlite3_column_decltype16 $STMT $numcols] + } {{} {} {} {} {} {} {} {}} + } # This proc is used to test the following APIs: @@ -275,38 +289,52 @@ do_test $test.1 { # Integers do_test $test.2 { set ints [list] - foreach i $idxlist {lappend ints [sqlite3_column_int $STMT $i]} + foreach i $idxlist {lappend ints [sqlite3_column_int64 $STMT $i]} set ints } $ints -# UTF-8 +# bytes +set lens [list] +foreach i $::idxlist { + lappend lens [string length [lindex $strings $i]] +} do_test $test.3 { + set bytes [list] + set lens [list] + foreach i $idxlist { + lappend bytes [sqlite3_column_bytes $STMT $i] + } + set bytes +} $lens + +# bytes16 +set lens [list] +foreach i $::idxlist { + lappend lens [expr 2 * [string length [lindex $strings $i]]] +} +do_test $test.4 { + set bytes [list] + set lens [list] + foreach i $idxlist { + lappend bytes [sqlite3_column_bytes16 $STMT $i] + } + set bytes +} $lens + +# Blob +do_test $test.5 { + set utf8 [list] + foreach i $idxlist {lappend utf8 [sqlite3_column_blob $STMT $i]} + set utf8 +} $strings + +# UTF-8 +do_test $test.6 { set utf8 [list] foreach i $idxlist {lappend utf8 [sqlite3_column_text $STMT $i]} set utf8 } $strings -# Floats -do_test $test.4 { - set utf8 [list] - foreach i $idxlist {lappend utf8 [sqlite3_column_double $STMT $i]} - set utf8 -} $doubles - -# UTF-16 -do_test $test.5 { - set utf8 [list] - foreach i $idxlist {lappend utf8 [utf8 [sqlite3_column_text16 $STMT $i]]} - set utf8 -} $strings - -# Integers -do_test $test.6 { - set ints [list] - foreach i $idxlist {lappend ints [sqlite3_column_int $STMT $i]} - set ints -} $ints - # Floats do_test $test.7 { set utf8 [list] @@ -314,20 +342,49 @@ do_test $test.7 { set utf8 } $doubles -# UTF-8 +# UTF-16 do_test $test.8 { + set utf8 [list] + foreach i $idxlist {lappend utf8 [utf8 [sqlite3_column_text16 $STMT $i]]} + set utf8 +} $strings + +# Integers +do_test $test.9 { + set ints [list] + foreach i $idxlist {lappend ints [sqlite3_column_int $STMT $i]} + set ints +} $ints + +# Floats +do_test $test.10 { + set utf8 [list] + foreach i $idxlist {lappend utf8 [sqlite3_column_double $STMT $i]} + set utf8 +} $doubles + +# UTF-8 +do_test $test.11 { set utf8 [list] foreach i $idxlist {lappend utf8 [sqlite3_column_text $STMT $i]} set utf8 } $strings # Types -do_test $test.9 { +do_test $test.12 { set types [list] foreach i $idxlist {lappend types [sqlite3_column_type $STMT $i]} set types } $types +# Test that an out of range request returns the equivalent of NULL +do_test $test.13 { + sqlite3_column_int $STMT -1 +} {0} +do_test $test.13 { + sqlite3_column_text $STMT -1 +} {} + } do_test capi3-5.0 { diff --git a/test/utf16.test b/test/utf16.test new file mode 100644 index 0000000000..00ae9014da --- /dev/null +++ b/test/utf16.test @@ -0,0 +1,57 @@ +# 2001 September 15 +# +# 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 runs all tests. +# +# $Id: utf16.test,v 1.1 2004/06/28 13:09:11 danielk1977 Exp $ + +set testdir [file dirname $argv0] +source $testdir/tester.tcl +rename finish_test really_finish_test2 +proc finish_test {} {} +set ISQUICK 1 + +set FILES { + func.test +} + +rename sqlite3 real_sqlite3 +proc sqlite3 {args} { + set r [eval "real_sqlite3 $args"] + if { [llength $args] == 2 } { + [lindex $args 0] eval {pragma encoding = 'UTF-16'} + } + set r +} + +rename do_test really_do_test +proc do_test {args} { + set sc [concat really_do_test "utf16-[lindex $args 0]" [lrange $args 1 end]] + eval $sc +} + +foreach f $FILES { + set testfile $testdir/$f + source $testfile + catch {db close} + if {$sqlite_open_file_count>0} { + puts "$tail did not close all files: $sqlite_open_file_count" + incr nErr + lappend ::failList $tail + } +} + +rename sqlite3 "" +rename real_sqlite3 sqlite3 +rename finish_test "" +rename really_finish_test2 finish_test +rename do_test "" +rename really_do_test do_test +