third_party/sqlite/sqlite-src-3080704/src/test_func.c

   1 /*
   2 ** 2008 March 19
   3 **
   4 ** The author disclaims copyright to this source code.  In place of
   5 ** a legal notice, here is a blessing:
   6 **
   7 **    May you do good and not evil.
   8 **    May you find forgiveness for yourself and forgive others.
   9 **    May you share freely, never taking more than you give.
  10 **
  11 *************************************************************************
  12 ** Code for testing all sorts of SQLite interfaces.  This code
  13 ** implements new SQL functions used by the test scripts.
  14 */
  15 #include "sqlite3.h"
  16 #include "tcl.h"
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <assert.h>
  20
  21 #include "sqliteInt.h"
  22 #include "vdbeInt.h"
  23
  24
  25 /*
  26 ** Allocate nByte bytes of space using sqlite3_malloc(). If the
  27 ** allocation fails, call sqlite3_result_error_nomem() to notify
  28 ** the database handle that malloc() has failed.
  29 */
  30 static void *testContextMalloc(sqlite3_context *context, int nByte){
  31   char *z = sqlite3_malloc(nByte);
  32   if( !z && nByte>0 ){
  33     sqlite3_result_error_nomem(context);
  34   }
  35   return z;
  36 }
  37
  38 /*
  39 ** This function generates a string of random characters.  Used for
  40 ** generating test data.
  41 */
  42 static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){
  43   static const unsigned char zSrc[] =
  44      "abcdefghijklmnopqrstuvwxyz"
  45      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  46      "0123456789"
  47      ".-!,:*^+=_|?/<> ";
  48   int iMin, iMax, n, r, i;
  49   unsigned char zBuf[1000];
  50
  51   /* It used to be possible to call randstr() with any number of arguments,
  52   ** but now it is registered with SQLite as requiring exactly 2.
  53   */
  54   assert(argc==2);
  55
  56   iMin = sqlite3_value_int(argv[0]);
  57   if( iMin<0 ) iMin = 0;
  58   if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1;
  59   iMax = sqlite3_value_int(argv[1]);
  60   if( iMax<iMin ) iMax = iMin;
  61   if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1;
  62   n = iMin;
  63   if( iMax>iMin ){
  64     sqlite3_randomness(sizeof(r), &r);
  65     r &= 0x7fffffff;
  66     n += r%(iMax + 1 - iMin);
  67   }
  68   assert( n<sizeof(zBuf) );
  69   sqlite3_randomness(n, zBuf);
  70   for(i=0; i<n; i++){
  71     zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
  72   }
  73   zBuf[n] = 0;
  74   sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT);
  75 }
  76
  77 /*
  78 ** The following two SQL functions are used to test returning a text
  79 ** result with a destructor. Function 'test_destructor' takes one argument
  80 ** and returns the same argument interpreted as TEXT. A destructor is
  81 ** passed with the sqlite3_result_text() call.
  82 **
  83 ** SQL function 'test_destructor_count' returns the number of outstanding
  84 ** allocations made by 'test_destructor';
  85 **
  86 ** WARNING: Not threadsafe.
  87 */
  88 static int test_destructor_count_var = 0;
  89 static void destructor(void *p){
  90   char *zVal = (char *)p;
  91   assert(zVal);
  92   zVal--;
  93   sqlite3_free(zVal);
  94   test_destructor_count_var--;
  95 }
  96 static void test_destructor(
  97   sqlite3_context *pCtx,
  98   int nArg,
  99   sqlite3_value **argv
 100 ){
 101   char *zVal;
 102   int len;
 103
 104   test_destructor_count_var++;
 105   assert( nArg==1 );
 106   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
 107   len = sqlite3_value_bytes(argv[0]);
 108   zVal = testContextMalloc(pCtx, len+3);
 109   if( !zVal ){
 110     return;
 111   }
 112   zVal[len+1] = 0;
 113   zVal[len+2] = 0;
 114   zVal++;
 115   memcpy(zVal, sqlite3_value_text(argv[0]), len);
 116   sqlite3_result_text(pCtx, zVal, -1, destructor);
 117 }
 118 #ifndef SQLITE_OMIT_UTF16
 119 static void test_destructor16(
 120   sqlite3_context *pCtx,
 121   int nArg,
 122   sqlite3_value **argv
 123 ){
 124   char *zVal;
 125   int len;
 126
 127   test_destructor_count_var++;
 128   assert( nArg==1 );
 129   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
 130   len = sqlite3_value_bytes16(argv[0]);
 131   zVal = testContextMalloc(pCtx, len+3);
 132   if( !zVal ){
 133     return;
 134   }
 135   zVal[len+1] = 0;
 136   zVal[len+2] = 0;
 137   zVal++;
 138   memcpy(zVal, sqlite3_value_text16(argv[0]), len);
 139   sqlite3_result_text16(pCtx, zVal, -1, destructor);
 140 }
 141 #endif
 142 static void test_destructor_count(
 143   sqlite3_context *pCtx,
 144   int nArg,
 145   sqlite3_value **argv
 146 ){
 147   sqlite3_result_int(pCtx, test_destructor_count_var);
 148 }
 149
 150 /*
 151 ** The following aggregate function, test_agg_errmsg16(), takes zero
 152 ** arguments. It returns the text value returned by the sqlite3_errmsg16()
 153 ** API function.
 154 */
 155 #ifndef SQLITE_OMIT_BUILTIN_TEST
 156 void sqlite3BeginBenignMalloc(void);
 157 void sqlite3EndBenignMalloc(void);
 158 #else
 159   #define sqlite3BeginBenignMalloc()
 160   #define sqlite3EndBenignMalloc()
 161 #endif
 162 static void test_agg_errmsg16_step(sqlite3_context *a, int b,sqlite3_value **c){
 163 }
 164 static void test_agg_errmsg16_final(sqlite3_context *ctx){
 165 #ifndef SQLITE_OMIT_UTF16
 166   const void *z;
 167   sqlite3 * db = sqlite3_context_db_handle(ctx);
 168   sqlite3_aggregate_context(ctx, 2048);
 169   sqlite3BeginBenignMalloc();
 170   z = sqlite3_errmsg16(db);
 171   sqlite3EndBenignMalloc();
 172   sqlite3_result_text16(ctx, z, -1, SQLITE_TRANSIENT);
 173 #endif
 174 }
 175
 176 /*
 177 ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata()
 178 ** interface.
 179 **
 180 ** The test_auxdata() SQL function attempts to register each of its arguments
 181 ** as auxiliary data.  If there are no prior registrations of aux data for
 182 ** that argument (meaning the argument is not a constant or this is its first
 183 ** call) then the result for that argument is 0.  If there is a prior
 184 ** registration, the result for that argument is 1.  The overall result
 185 ** is the individual argument results separated by spaces.
 186 */
 187 static void free_test_auxdata(void *p) {sqlite3_free(p);}
 188 static void test_auxdata(
 189   sqlite3_context *pCtx,
 190   int nArg,
 191   sqlite3_value **argv
 192 ){
 193   int i;
 194   char *zRet = testContextMalloc(pCtx, nArg*2);
 195   if( !zRet ) return;
 196   memset(zRet, 0, nArg*2);
 197   for(i=0; i<nArg; i++){
 198     char const *z = (char*)sqlite3_value_text(argv[i]);
 199     if( z ){
 200       int n;
 201       char *zAux = sqlite3_get_auxdata(pCtx, i);
 202       if( zAux ){
 203         zRet[i*2] = '1';
 204         assert( strcmp(zAux,z)==0 );
 205       }else {
 206         zRet[i*2] = '0';
 207       }
 208       n = (int)strlen(z) + 1;
 209       zAux = testContextMalloc(pCtx, n);
 210       if( zAux ){
 211         memcpy(zAux, z, n);
 212         sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata);
 213       }
 214       zRet[i*2+1] = ' ';
 215     }
 216   }
 217   sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata);
 218 }
 219
 220 /*
 221 ** A function to test error reporting from user functions. This function
 222 ** returns a copy of its first argument as the error message.  If the
 223 ** second argument exists, it becomes the error code.
 224 */
 225 static void test_error(
 226   sqlite3_context *pCtx,
 227   int nArg,
 228   sqlite3_value **argv
 229 ){
 230   sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), -1);
 231   if( nArg==2 ){
 232     sqlite3_result_error_code(pCtx, sqlite3_value_int(argv[1]));
 233   }
 234 }
 235
 236 /*
 237 ** Implementation of the counter(X) function.  If X is an integer
 238 ** constant, then the first invocation will return X.  The second X+1.
 239 ** and so forth.  Can be used (for example) to provide a sequence number
 240 ** in a result set.
 241 */
 242 static void counterFunc(
 243   sqlite3_context *pCtx,   /* Function context */
 244   int nArg,                /* Number of function arguments */
 245   sqlite3_value **argv     /* Values for all function arguments */
 246 ){
 247   int *pCounter = (int*)sqlite3_get_auxdata(pCtx, 0);
 248   if( pCounter==0 ){
 249     pCounter = sqlite3_malloc( sizeof(*pCounter) );
 250     if( pCounter==0 ){
 251       sqlite3_result_error_nomem(pCtx);
 252       return;
 253     }
 254     *pCounter = sqlite3_value_int(argv[0]);
 255     sqlite3_set_auxdata(pCtx, 0, pCounter, sqlite3_free);
 256   }else{
 257     ++*pCounter;
 258   }
 259   sqlite3_result_int(pCtx, *pCounter);
 260 }
 261
 262
 263 /*
 264 ** This function takes two arguments.  It performance UTF-8/16 type
 265 ** conversions on the first argument then returns a copy of the second
 266 ** argument.
 267 **
 268 ** This function is used in cases such as the following:
 269 **
 270 **      SELECT test_isolation(x,x) FROM t1;
 271 **
 272 ** We want to verify that the type conversions that occur on the
 273 ** first argument do not invalidate the second argument.
 274 */
 275 static void test_isolation(
 276   sqlite3_context *pCtx,
 277   int nArg,
 278   sqlite3_value **argv
 279 ){
 280 #ifndef SQLITE_OMIT_UTF16
 281   sqlite3_value_text16(argv[0]);
 282   sqlite3_value_text(argv[0]);
 283   sqlite3_value_text16(argv[0]);
 284   sqlite3_value_text(argv[0]);
 285 #endif
 286   sqlite3_result_value(pCtx, argv[1]);
 287 }
 288
 289 /*
 290 ** Invoke an SQL statement recursively.  The function result is the
 291 ** first column of the first row of the result set.
 292 */
 293 static void test_eval(
 294   sqlite3_context *pCtx,
 295   int nArg,
 296   sqlite3_value **argv
 297 ){
 298   sqlite3_stmt *pStmt;
 299   int rc;
 300   sqlite3 *db = sqlite3_context_db_handle(pCtx);
 301   const char *zSql;
 302
 303   zSql = (char*)sqlite3_value_text(argv[0]);
 304   rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
 305   if( rc==SQLITE_OK ){
 306     rc = sqlite3_step(pStmt);
 307     if( rc==SQLITE_ROW ){
 308       sqlite3_result_value(pCtx, sqlite3_column_value(pStmt, 0));
 309     }
 310     rc = sqlite3_finalize(pStmt);
 311   }
 312   if( rc ){
 313     char *zErr;
 314     assert( pStmt==0 );
 315     zErr = sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db));
 316     sqlite3_result_text(pCtx, zErr, -1, sqlite3_free);
 317     sqlite3_result_error_code(pCtx, rc);
 318   }
 319 }
 320
 321
 322 /*
 323 ** convert one character from hex to binary
 324 */
 325 static int testHexChar(char c){
 326   if( c>='0' && c<='9' ){
 327     return c - '0';
 328   }else if( c>='a' && c<='f' ){
 329     return c - 'a' + 10;
 330   }else if( c>='A' && c<='F' ){
 331     return c - 'A' + 10;
 332   }
 333   return 0;
 334 }
 335
 336 /*
 337 ** Convert hex to binary.
 338 */
 339 static void testHexToBin(const char *zIn, char *zOut){
 340   while( zIn[0] && zIn[1] ){
 341     *(zOut++) = (testHexChar(zIn[0])<<4) + testHexChar(zIn[1]);
 342     zIn += 2;
 343   }
 344 }
 345
 346 /*
 347 **      hex_to_utf16be(HEX)
 348 **
 349 ** Convert the input string from HEX into binary.  Then return the
 350 ** result using sqlite3_result_text16le().
 351 */
 352 #ifndef SQLITE_OMIT_UTF16
 353 static void testHexToUtf16be(
 354   sqlite3_context *pCtx,
 355   int nArg,
 356   sqlite3_value **argv
 357 ){
 358   int n;
 359   const char *zIn;
 360   char *zOut;
 361   assert( nArg==1 );
 362   n = sqlite3_value_bytes(argv[0]);
 363   zIn = (const char*)sqlite3_value_text(argv[0]);
 364   zOut = sqlite3_malloc( n/2 );
 365   if( zOut==0 ){
 366     sqlite3_result_error_nomem(pCtx);
 367   }else{
 368     testHexToBin(zIn, zOut);
 369     sqlite3_result_text16be(pCtx, zOut, n/2, sqlite3_free);
 370   }
 371 }
 372 #endif
 373
 374 /*
 375 **      hex_to_utf8(HEX)
 376 **
 377 ** Convert the input string from HEX into binary.  Then return the
 378 ** result using sqlite3_result_text16le().
 379 */
 380 static void testHexToUtf8(
 381   sqlite3_context *pCtx,
 382   int nArg,
 383   sqlite3_value **argv
 384 ){
 385   int n;
 386   const char *zIn;
 387   char *zOut;
 388   assert( nArg==1 );
 389   n = sqlite3_value_bytes(argv[0]);
 390   zIn = (const char*)sqlite3_value_text(argv[0]);
 391   zOut = sqlite3_malloc( n/2 );
 392   if( zOut==0 ){
 393     sqlite3_result_error_nomem(pCtx);
 394   }else{
 395     testHexToBin(zIn, zOut);
 396     sqlite3_result_text(pCtx, zOut, n/2, sqlite3_free);
 397   }
 398 }
 399
 400 /*
 401 **      hex_to_utf16le(HEX)
 402 **
 403 ** Convert the input string from HEX into binary.  Then return the
 404 ** result using sqlite3_result_text16le().
 405 */
 406 #ifndef SQLITE_OMIT_UTF16
 407 static void testHexToUtf16le(
 408   sqlite3_context *pCtx,
 409   int nArg,
 410   sqlite3_value **argv
 411 ){
 412   int n;
 413   const char *zIn;
 414   char *zOut;
 415   assert( nArg==1 );
 416   n = sqlite3_value_bytes(argv[0]);
 417   zIn = (const char*)sqlite3_value_text(argv[0]);
 418   zOut = sqlite3_malloc( n/2 );
 419   if( zOut==0 ){
 420     sqlite3_result_error_nomem(pCtx);
 421   }else{
 422     testHexToBin(zIn, zOut);
 423     sqlite3_result_text16le(pCtx, zOut, n/2, sqlite3_free);
 424   }
 425 }
 426 #endif
 427
 428 /*
 429 ** SQL function:   real2hex(X)
 430 **
 431 ** If argument X is a real number, then convert it into a string which is
 432 ** the big-endian hexadecimal representation of the ieee754 encoding of
 433 ** that number.  If X is not a real number, return NULL.
 434 */
 435 static void real2hex(
 436   sqlite3_context *context,
 437   int argc,
 438   sqlite3_value **argv
 439 ){
 440   union {
 441     sqlite3_uint64 i;
 442     double r;
 443     unsigned char x[8];
 444   } v;
 445   char zOut[20];
 446   int i;
 447   int bigEndian;
 448   v.i = 1;
 449   bigEndian = v.x[0]==0;
 450   v.r = sqlite3_value_double(argv[0]);
 451   for(i=0; i<8; i++){
 452     if( bigEndian ){
 453       zOut[i*2]   = "0123456789abcdef"[v.x[i]>>4];
 454       zOut[i*2+1] = "0123456789abcdef"[v.x[i]&0xf];
 455     }else{
 456       zOut[14-i*2]   = "0123456789abcdef"[v.x[i]>>4];
 457       zOut[14-i*2+1] = "0123456789abcdef"[v.x[i]&0xf];
 458     }
 459   }
 460   zOut[16] = 0;
 461   sqlite3_result_text(context, zOut, -1, SQLITE_TRANSIENT);
 462 }
 463
 464 /*
 465 ** tclcmd: test_extract(record, field)
 466 **
 467 ** This function implements an SQL user-function that accepts a blob
 468 ** containing a formatted database record as the first argument. The
 469 ** second argument is the index of the field within that record to
 470 ** extract and return.
 471 */
 472 static void test_extract(
 473   sqlite3_context *context,
 474   int argc,
 475   sqlite3_value **argv
 476 ){
 477   sqlite3 *db = sqlite3_context_db_handle(context);
 478   u8 *pRec;
 479   u8 *pEndHdr;                    /* Points to one byte past record header */
 480   u8 *pHdr;                       /* Current point in record header */
 481   u8 *pBody;                      /* Current point in record data */
 482   u64 nHdr;                       /* Bytes in record header */
 483   int iIdx;                       /* Required field */
 484   int iCurrent = 0;               /* Current field */
 485
 486   assert( argc==2 );
 487   pRec = (u8*)sqlite3_value_blob(argv[0]);
 488   iIdx = sqlite3_value_int(argv[1]);
 489
 490   pHdr = pRec + sqlite3GetVarint(pRec, &nHdr);
 491   pBody = pEndHdr = &pRec[nHdr];
 492
 493   for(iCurrent=0; pHdr<pEndHdr && iCurrent<=iIdx; iCurrent++){
 494     u64 iSerialType;
 495     Mem mem;
 496
 497     memset(&mem, 0, sizeof(mem));
 498     mem.db = db;
 499     mem.enc = ENC(db);
 500     pHdr += sqlite3GetVarint(pHdr, &iSerialType);
 501     pBody += sqlite3VdbeSerialGet(pBody, (u32)iSerialType, &mem);
 502
 503     if( iCurrent==iIdx ){
 504       sqlite3_result_value(context, &mem);
 505     }
 506
 507     if( mem.szMalloc ) sqlite3DbFree(db, mem.zMalloc);
 508   }
 509 }
 510
 511 /*
 512 ** tclcmd: test_decode(record)
 513 **
 514 ** This function implements an SQL user-function that accepts a blob
 515 ** containing a formatted database record as its only argument. It returns
 516 ** a tcl list (type SQLITE_TEXT) containing each of the values stored
 517 ** in the record.
 518 */
 519 static void test_decode(
 520   sqlite3_context *context,
 521   int argc,
 522   sqlite3_value **argv
 523 ){
 524   sqlite3 *db = sqlite3_context_db_handle(context);
 525   u8 *pRec;
 526   u8 *pEndHdr;                    /* Points to one byte past record header */
 527   u8 *pHdr;                       /* Current point in record header */
 528   u8 *pBody;                      /* Current point in record data */
 529   u64 nHdr;                       /* Bytes in record header */
 530   Tcl_Obj *pRet;                  /* Return value */
 531
 532   pRet = Tcl_NewObj();
 533   Tcl_IncrRefCount(pRet);
 534
 535   assert( argc==1 );
 536   pRec = (u8*)sqlite3_value_blob(argv[0]);
 537
 538   pHdr = pRec + sqlite3GetVarint(pRec, &nHdr);
 539   pBody = pEndHdr = &pRec[nHdr];
 540   while( pHdr<pEndHdr ){
 541     Tcl_Obj *pVal = 0;
 542     u64 iSerialType;
 543     Mem mem;
 544
 545     memset(&mem, 0, sizeof(mem));
 546     mem.db = db;
 547     mem.enc = ENC(db);
 548     pHdr += sqlite3GetVarint(pHdr, &iSerialType);
 549     pBody += sqlite3VdbeSerialGet(pBody, (u32)iSerialType, &mem);
 550
 551     switch( sqlite3_value_type(&mem) ){
 552       case SQLITE_TEXT:
 553         pVal = Tcl_NewStringObj((const char*)sqlite3_value_text(&mem), -1);
 554         break;
 555
 556       case SQLITE_BLOB: {
 557         char hexdigit[] = {
 558           '0', '1', '2', '3', '4', '5', '6', '7',
 559           '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
 560         };
 561         int n = sqlite3_value_bytes(&mem);
 562         u8 *z = (u8*)sqlite3_value_blob(&mem);
 563         int i;
 564         pVal = Tcl_NewStringObj("x'", -1);
 565         for(i=0; i<n; i++){
 566           char hex[3];
 567           hex[0] = hexdigit[((z[i] >> 4) & 0x0F)];
 568           hex[1] = hexdigit[(z[i] & 0x0F)];
 569           hex[2] = '\0';
 570           Tcl_AppendStringsToObj(pVal, hex, 0);
 571         }
 572         Tcl_AppendStringsToObj(pVal, "'", 0);
 573         break;
 574       }
 575
 576       case SQLITE_FLOAT:
 577         pVal = Tcl_NewDoubleObj(sqlite3_value_double(&mem));
 578         break;
 579
 580       case SQLITE_INTEGER:
 581         pVal = Tcl_NewWideIntObj(sqlite3_value_int64(&mem));
 582         break;
 583
 584       case SQLITE_NULL:
 585         pVal = Tcl_NewStringObj("NULL", -1);
 586         break;
 587
 588       default:
 589         assert( 0 );
 590     }
 591
 592     Tcl_ListObjAppendElement(0, pRet, pVal);
 593
 594     if( mem.szMalloc ){
 595       sqlite3DbFree(db, mem.zMalloc);
 596     }
 597   }
 598
 599   sqlite3_result_text(context, Tcl_GetString(pRet), -1, SQLITE_TRANSIENT);
 600   Tcl_DecrRefCount(pRet);
 601 }
 602
 603
 604 static int registerTestFunctions(sqlite3 *db){
 605   static const struct {
 606      char *zName;
 607      signed char nArg;
 608      unsigned char eTextRep; /* 1: UTF-16.  0: UTF-8 */
 609      void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
 610   } aFuncs[] = {
 611     { "randstr",               2, SQLITE_UTF8, randStr    },
 612     { "test_destructor",       1, SQLITE_UTF8, test_destructor},
 613 #ifndef SQLITE_OMIT_UTF16
 614     { "test_destructor16",     1, SQLITE_UTF8, test_destructor16},
 615     { "hex_to_utf16be",        1, SQLITE_UTF8, testHexToUtf16be},
 616     { "hex_to_utf16le",        1, SQLITE_UTF8, testHexToUtf16le},
 617 #endif
 618     { "hex_to_utf8",           1, SQLITE_UTF8, testHexToUtf8},
 619     { "test_destructor_count", 0, SQLITE_UTF8, test_destructor_count},
 620     { "test_auxdata",         -1, SQLITE_UTF8, test_auxdata},
 621     { "test_error",            1, SQLITE_UTF8, test_error},
 622     { "test_error",            2, SQLITE_UTF8, test_error},
 623     { "test_eval",             1, SQLITE_UTF8, test_eval},
 624     { "test_isolation",        2, SQLITE_UTF8, test_isolation},
 625     { "test_counter",          1, SQLITE_UTF8, counterFunc},
 626     { "real2hex",              1, SQLITE_UTF8, real2hex},
 627     { "test_decode",           1, SQLITE_UTF8, test_decode},
 628     { "test_extract",          2, SQLITE_UTF8, test_extract},
 629   };
 630   int i;
 631
 632   for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
 633     sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg,
 634         aFuncs[i].eTextRep, 0, aFuncs[i].xFunc, 0, 0);
 635   }
 636
 637   sqlite3_create_function(db, "test_agg_errmsg16", 0, SQLITE_ANY, 0, 0,
 638       test_agg_errmsg16_step, test_agg_errmsg16_final);
 639
 640   return SQLITE_OK;
 641 }
 642
 643 /*
 644 ** TCLCMD:  autoinstall_test_functions
 645 **
 646 ** Invoke this TCL command to use sqlite3_auto_extension() to cause
 647 ** the standard set of test functions to be loaded into each new
 648 ** database connection.
 649 */
 650 static int autoinstall_test_funcs(
 651   void * clientData,
 652   Tcl_Interp *interp,
 653   int objc,
 654   Tcl_Obj *CONST objv[]
 655 ){
 656   extern int Md5_Register(sqlite3*);
 657   int rc = sqlite3_auto_extension((void*)registerTestFunctions);
 658   if( rc==SQLITE_OK ){
 659     rc = sqlite3_auto_extension((void*)Md5_Register);
 660   }
 661   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
 662   return TCL_OK;
 663 }
 664
 665 /*
 666 ** A bogus step function and finalizer function.
 667 */
 668 static void tStep(sqlite3_context *a, int b, sqlite3_value **c){}
 669 static void tFinal(sqlite3_context *a){}
 670
 671
 672 /*
 673 ** tclcmd:  abuse_create_function
 674 **
 675 ** Make various calls to sqlite3_create_function that do not have valid
 676 ** parameters.  Verify that the error condition is detected and reported.
 677 */
 678 static int abuse_create_function(
 679   void * clientData,
 680   Tcl_Interp *interp,
 681   int objc,
 682   Tcl_Obj *CONST objv[]
 683 ){
 684   extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
 685   sqlite3 *db;
 686   int rc;
 687   int mxArg;
 688
 689   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
 690
 691   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep,tStep,tFinal);
 692   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 693
 694   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, 0);
 695   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 696
 697   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, 0, tFinal);
 698   if( rc!=SQLITE_MISUSE) goto abuse_err;
 699
 700   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, 0, tFinal);
 701   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 702
 703   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, tStep, 0);
 704   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 705
 706   rc = sqlite3_create_function(db, "tx", -2, SQLITE_UTF8, 0, tStep, 0, 0);
 707   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 708
 709   rc = sqlite3_create_function(db, "tx", 128, SQLITE_UTF8, 0, tStep, 0, 0);
 710   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 711
 712   rc = sqlite3_create_function(db, "funcxx"
 713        "_123456789_123456789_123456789_123456789_123456789"
 714        "_123456789_123456789_123456789_123456789_123456789"
 715        "_123456789_123456789_123456789_123456789_123456789"
 716        "_123456789_123456789_123456789_123456789_123456789"
 717        "_123456789_123456789_123456789_123456789_123456789",
 718        1, SQLITE_UTF8, 0, tStep, 0, 0);
 719   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 720
 721   /* This last function registration should actually work.  Generate
 722   ** a no-op function (that always returns NULL) and which has the
 723   ** maximum-length function name and the maximum number of parameters.
 724   */
 725   sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, 10000);
 726   mxArg = sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, -1);
 727   rc = sqlite3_create_function(db, "nullx"
 728        "_123456789_123456789_123456789_123456789_123456789"
 729        "_123456789_123456789_123456789_123456789_123456789"
 730        "_123456789_123456789_123456789_123456789_123456789"
 731        "_123456789_123456789_123456789_123456789_123456789"
 732        "_123456789_123456789_123456789_123456789_123456789",
 733        mxArg, SQLITE_UTF8, 0, tStep, 0, 0);
 734   if( rc!=SQLITE_OK ) goto abuse_err;
 735
 736   return TCL_OK;
 737
 738 abuse_err:
 739   Tcl_AppendResult(interp, "sqlite3_create_function abused test failed",
 740                    (char*)0);
 741   return TCL_ERROR;
 742 }
 743
 744 /*
 745 ** Register commands with the TCL interpreter.
 746 */
 747 int Sqlitetest_func_Init(Tcl_Interp *interp){
 748   static struct {
 749      char *zName;
 750      Tcl_ObjCmdProc *xProc;
 751   } aObjCmd[] = {
 752      { "autoinstall_test_functions",    autoinstall_test_funcs },
 753      { "abuse_create_function",         abuse_create_function  },
 754   };
 755   int i;
 756   extern int Md5_Register(sqlite3*);
 757
 758   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
 759     Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
 760   }
 761   sqlite3_initialize();
 762   sqlite3_auto_extension((void*)registerTestFunctions);
 763   sqlite3_auto_extension((void*)Md5_Register);
 764   return TCL_OK;
 765 }