1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/TEST/SRC/test_func.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,464 @@
1.4 +/*
1.5 +** 2008 March 19
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** Code for testing all sorts of SQLite interfaces. This code
1.16 +** implements new SQL functions used by the test scripts.
1.17 +**
1.18 +** $Id: test_func.c,v 1.13 2008/08/28 02:26:07 drh Exp $
1.19 +*/
1.20 +#include "sqlite3.h"
1.21 +#include "tcl.h"
1.22 +#include <stdlib.h>
1.23 +#include <string.h>
1.24 +#include <assert.h>
1.25 +
1.26 +
1.27 +/*
1.28 +** Allocate nByte bytes of space using sqlite3_malloc(). If the
1.29 +** allocation fails, call sqlite3_result_error_nomem() to notify
1.30 +** the database handle that malloc() has failed.
1.31 +*/
1.32 +static void *testContextMalloc(sqlite3_context *context, int nByte){
1.33 + char *z = sqlite3_malloc(nByte);
1.34 + if( !z && nByte>0 ){
1.35 + sqlite3_result_error_nomem(context);
1.36 + }
1.37 + return z;
1.38 +}
1.39 +
1.40 +/*
1.41 +** This function generates a string of random characters. Used for
1.42 +** generating test data.
1.43 +*/
1.44 +static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){
1.45 + static const unsigned char zSrc[] =
1.46 + "abcdefghijklmnopqrstuvwxyz"
1.47 + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1.48 + "0123456789"
1.49 + ".-!,:*^+=_|?/<> ";
1.50 + int iMin, iMax, n, r, i;
1.51 + unsigned char zBuf[1000];
1.52 +
1.53 + /* It used to be possible to call randstr() with any number of arguments,
1.54 + ** but now it is registered with SQLite as requiring exactly 2.
1.55 + */
1.56 + assert(argc==2);
1.57 +
1.58 + iMin = sqlite3_value_int(argv[0]);
1.59 + if( iMin<0 ) iMin = 0;
1.60 + if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1;
1.61 + iMax = sqlite3_value_int(argv[1]);
1.62 + if( iMax<iMin ) iMax = iMin;
1.63 + if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1;
1.64 + n = iMin;
1.65 + if( iMax>iMin ){
1.66 + sqlite3_randomness(sizeof(r), &r);
1.67 + r &= 0x7fffffff;
1.68 + n += r%(iMax + 1 - iMin);
1.69 + }
1.70 + assert( n<sizeof(zBuf) );
1.71 + sqlite3_randomness(n, zBuf);
1.72 + for(i=0; i<n; i++){
1.73 + zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
1.74 + }
1.75 + zBuf[n] = 0;
1.76 + sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT);
1.77 +}
1.78 +
1.79 +/*
1.80 +** The following two SQL functions are used to test returning a text
1.81 +** result with a destructor. Function 'test_destructor' takes one argument
1.82 +** and returns the same argument interpreted as TEXT. A destructor is
1.83 +** passed with the sqlite3_result_text() call.
1.84 +**
1.85 +** SQL function 'test_destructor_count' returns the number of outstanding
1.86 +** allocations made by 'test_destructor';
1.87 +**
1.88 +** WARNING: Not threadsafe.
1.89 +*/
1.90 +static int test_destructor_count_var = 0;
1.91 +static void destructor(void *p){
1.92 + char *zVal = (char *)p;
1.93 + assert(zVal);
1.94 + zVal--;
1.95 + sqlite3_free(zVal);
1.96 + test_destructor_count_var--;
1.97 +}
1.98 +static void test_destructor(
1.99 + sqlite3_context *pCtx,
1.100 + int nArg,
1.101 + sqlite3_value **argv
1.102 +){
1.103 + char *zVal;
1.104 + int len;
1.105 +
1.106 + test_destructor_count_var++;
1.107 + assert( nArg==1 );
1.108 + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1.109 + len = sqlite3_value_bytes(argv[0]);
1.110 + zVal = testContextMalloc(pCtx, len+3);
1.111 + if( !zVal ){
1.112 + return;
1.113 + }
1.114 + zVal[len+1] = 0;
1.115 + zVal[len+2] = 0;
1.116 + zVal++;
1.117 + memcpy(zVal, sqlite3_value_text(argv[0]), len);
1.118 + sqlite3_result_text(pCtx, zVal, -1, destructor);
1.119 +}
1.120 +#ifndef SQLITE_OMIT_UTF16
1.121 +static void test_destructor16(
1.122 + sqlite3_context *pCtx,
1.123 + int nArg,
1.124 + sqlite3_value **argv
1.125 +){
1.126 + char *zVal;
1.127 + int len;
1.128 +
1.129 + test_destructor_count_var++;
1.130 + assert( nArg==1 );
1.131 + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1.132 + len = sqlite3_value_bytes16(argv[0]);
1.133 + zVal = testContextMalloc(pCtx, len+3);
1.134 + if( !zVal ){
1.135 + return;
1.136 + }
1.137 + zVal[len+1] = 0;
1.138 + zVal[len+2] = 0;
1.139 + zVal++;
1.140 + memcpy(zVal, sqlite3_value_text16(argv[0]), len);
1.141 + sqlite3_result_text16(pCtx, zVal, -1, destructor);
1.142 +}
1.143 +#endif
1.144 +static void test_destructor_count(
1.145 + sqlite3_context *pCtx,
1.146 + int nArg,
1.147 + sqlite3_value **argv
1.148 +){
1.149 + sqlite3_result_int(pCtx, test_destructor_count_var);
1.150 +}
1.151 +
1.152 +/*
1.153 +** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata()
1.154 +** interface.
1.155 +**
1.156 +** The test_auxdata() SQL function attempts to register each of its arguments
1.157 +** as auxiliary data. If there are no prior registrations of aux data for
1.158 +** that argument (meaning the argument is not a constant or this is its first
1.159 +** call) then the result for that argument is 0. If there is a prior
1.160 +** registration, the result for that argument is 1. The overall result
1.161 +** is the individual argument results separated by spaces.
1.162 +*/
1.163 +static void free_test_auxdata(void *p) {sqlite3_free(p);}
1.164 +static void test_auxdata(
1.165 + sqlite3_context *pCtx,
1.166 + int nArg,
1.167 + sqlite3_value **argv
1.168 +){
1.169 + int i;
1.170 + char *zRet = testContextMalloc(pCtx, nArg*2);
1.171 + if( !zRet ) return;
1.172 + memset(zRet, 0, nArg*2);
1.173 + for(i=0; i<nArg; i++){
1.174 + char const *z = (char*)sqlite3_value_text(argv[i]);
1.175 + if( z ){
1.176 + int n;
1.177 + char *zAux = sqlite3_get_auxdata(pCtx, i);
1.178 + if( zAux ){
1.179 + zRet[i*2] = '1';
1.180 + assert( strcmp(zAux,z)==0 );
1.181 + }else {
1.182 + zRet[i*2] = '0';
1.183 + }
1.184 + n = strlen(z) + 1;
1.185 + zAux = testContextMalloc(pCtx, n);
1.186 + if( zAux ){
1.187 + memcpy(zAux, z, n);
1.188 + sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata);
1.189 + }
1.190 + zRet[i*2+1] = ' ';
1.191 + }
1.192 + }
1.193 + sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata);
1.194 +}
1.195 +
1.196 +/*
1.197 +** A function to test error reporting from user functions. This function
1.198 +** returns a copy of its first argument as the error message. If the
1.199 +** second argument exists, it becomes the error code.
1.200 +*/
1.201 +static void test_error(
1.202 + sqlite3_context *pCtx,
1.203 + int nArg,
1.204 + sqlite3_value **argv
1.205 +){
1.206 + sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), -1);
1.207 + if( nArg==2 ){
1.208 + sqlite3_result_error_code(pCtx, sqlite3_value_int(argv[1]));
1.209 + }
1.210 +}
1.211 +
1.212 +/*
1.213 +** Implementation of the counter(X) function. If X is an integer
1.214 +** constant, then the first invocation will return X. The second X+1.
1.215 +** and so forth. Can be used (for example) to provide a sequence number
1.216 +** in a result set.
1.217 +*/
1.218 +static void counterFunc(
1.219 + sqlite3_context *pCtx, /* Function context */
1.220 + int nArg, /* Number of function arguments */
1.221 + sqlite3_value **argv /* Values for all function arguments */
1.222 +){
1.223 + int *pCounter = (int*)sqlite3_get_auxdata(pCtx, 0);
1.224 + if( pCounter==0 ){
1.225 + pCounter = sqlite3_malloc( sizeof(*pCounter) );
1.226 + if( pCounter==0 ){
1.227 + sqlite3_result_error_nomem(pCtx);
1.228 + return;
1.229 + }
1.230 + *pCounter = sqlite3_value_int(argv[0]);
1.231 + sqlite3_set_auxdata(pCtx, 0, pCounter, sqlite3_free);
1.232 + }else{
1.233 + ++*pCounter;
1.234 + }
1.235 + sqlite3_result_int(pCtx, *pCounter);
1.236 +}
1.237 +
1.238 +
1.239 +/*
1.240 +** This function takes two arguments. It performance UTF-8/16 type
1.241 +** conversions on the first argument then returns a copy of the second
1.242 +** argument.
1.243 +**
1.244 +** This function is used in cases such as the following:
1.245 +**
1.246 +** SELECT test_isolation(x,x) FROM t1;
1.247 +**
1.248 +** We want to verify that the type conversions that occur on the
1.249 +** first argument do not invalidate the second argument.
1.250 +*/
1.251 +static void test_isolation(
1.252 + sqlite3_context *pCtx,
1.253 + int nArg,
1.254 + sqlite3_value **argv
1.255 +){
1.256 +#ifndef SQLITE_OMIT_UTF16
1.257 + sqlite3_value_text16(argv[0]);
1.258 + sqlite3_value_text(argv[0]);
1.259 + sqlite3_value_text16(argv[0]);
1.260 + sqlite3_value_text(argv[0]);
1.261 +#endif
1.262 + sqlite3_result_value(pCtx, argv[1]);
1.263 +}
1.264 +
1.265 +/*
1.266 +** Invoke an SQL statement recursively. The function result is the
1.267 +** first column of the first row of the result set.
1.268 +*/
1.269 +static void test_eval(
1.270 + sqlite3_context *pCtx,
1.271 + int nArg,
1.272 + sqlite3_value **argv
1.273 +){
1.274 + sqlite3_stmt *pStmt;
1.275 + int rc;
1.276 + sqlite3 *db = sqlite3_context_db_handle(pCtx);
1.277 + const char *zSql;
1.278 +
1.279 + zSql = (char*)sqlite3_value_text(argv[0]);
1.280 + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
1.281 + if( rc==SQLITE_OK ){
1.282 + rc = sqlite3_step(pStmt);
1.283 + if( rc==SQLITE_ROW ){
1.284 + sqlite3_result_value(pCtx, sqlite3_column_value(pStmt, 0));
1.285 + }
1.286 + rc = sqlite3_finalize(pStmt);
1.287 + }
1.288 + if( rc ){
1.289 + char *zErr;
1.290 + assert( pStmt==0 );
1.291 + zErr = sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db));
1.292 + sqlite3_result_text(pCtx, zErr, -1, sqlite3_free);
1.293 + sqlite3_result_error_code(pCtx, rc);
1.294 + }
1.295 +}
1.296 +
1.297 +
1.298 +static int registerTestFunctions(sqlite3 *db){
1.299 + static const struct {
1.300 + char *zName;
1.301 + signed char nArg;
1.302 + unsigned char eTextRep; /* 1: UTF-16. 0: UTF-8 */
1.303 + void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
1.304 + } aFuncs[] = {
1.305 + { "randstr", 2, SQLITE_UTF8, randStr },
1.306 + { "test_destructor", 1, SQLITE_UTF8, test_destructor},
1.307 +#ifndef SQLITE_OMIT_UTF16
1.308 + { "test_destructor16", 1, SQLITE_UTF8, test_destructor16},
1.309 +#endif
1.310 + { "test_destructor_count", 0, SQLITE_UTF8, test_destructor_count},
1.311 + { "test_auxdata", -1, SQLITE_UTF8, test_auxdata},
1.312 + { "test_error", 1, SQLITE_UTF8, test_error},
1.313 + { "test_error", 2, SQLITE_UTF8, test_error},
1.314 + { "test_eval", 1, SQLITE_UTF8, test_eval},
1.315 + { "test_isolation", 2, SQLITE_UTF8, test_isolation},
1.316 + { "test_counter", 1, SQLITE_UTF8, counterFunc},
1.317 + };
1.318 + int i;
1.319 +
1.320 + for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
1.321 + sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg,
1.322 + aFuncs[i].eTextRep, 0, aFuncs[i].xFunc, 0, 0);
1.323 + }
1.324 + return SQLITE_OK;
1.325 +}
1.326 +
1.327 +/*
1.328 +** TCLCMD: autoinstall_test_functions
1.329 +**
1.330 +** Invoke this TCL command to use sqlite3_auto_extension() to cause
1.331 +** the standard set of test functions to be loaded into each new
1.332 +** database connection.
1.333 +*/
1.334 +static int autoinstall_test_funcs(
1.335 + void * clientData,
1.336 + Tcl_Interp *interp,
1.337 + int objc,
1.338 + Tcl_Obj *CONST objv[]
1.339 +){
1.340 + extern int Md5_Register(sqlite3*);
1.341 + int rc = sqlite3_auto_extension((void*)registerTestFunctions);
1.342 + if( rc==SQLITE_OK ){
1.343 + rc = sqlite3_auto_extension((void*)Md5_Register);
1.344 + }
1.345 + Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
1.346 + return TCL_OK;
1.347 +}
1.348 +
1.349 +/*
1.350 +** A bogus step function and finalizer function.
1.351 +*/
1.352 +static void tStep(sqlite3_context *a, int b, sqlite3_value **c){}
1.353 +static void tFinal(sqlite3_context *a){}
1.354 +
1.355 +
1.356 +/*
1.357 +** tclcmd: abuse_create_function
1.358 +**
1.359 +** Make various calls to sqlite3_create_function that do not have valid
1.360 +** parameters. Verify that the error condition is detected and reported.
1.361 +*/
1.362 +static int abuse_create_function(
1.363 + void * clientData,
1.364 + Tcl_Interp *interp,
1.365 + int objc,
1.366 + Tcl_Obj *CONST objv[]
1.367 +){
1.368 + extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
1.369 + sqlite3 *db;
1.370 + int rc;
1.371 + int mxArg;
1.372 +
1.373 + if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
1.374 +
1.375 + rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep,tStep,tFinal);
1.376 + if( rc!=SQLITE_ERROR ) goto abuse_err;
1.377 + if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
1.378 + if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
1.379 +
1.380 + rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, 0);
1.381 + if( rc!=SQLITE_ERROR ) goto abuse_err;
1.382 + if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
1.383 + if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
1.384 +
1.385 + rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, 0, tFinal);
1.386 + if( rc!=SQLITE_ERROR ) goto abuse_err;
1.387 + if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
1.388 + if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
1.389 +
1.390 + rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, 0, tFinal);
1.391 + if( rc!=SQLITE_ERROR ) goto abuse_err;
1.392 + if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
1.393 + if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
1.394 +
1.395 + rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, tStep, 0);
1.396 + if( rc!=SQLITE_ERROR ) goto abuse_err;
1.397 + if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
1.398 + if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
1.399 +
1.400 + rc = sqlite3_create_function(db, "tx", -2, SQLITE_UTF8, 0, tStep, 0, 0);
1.401 + if( rc!=SQLITE_ERROR ) goto abuse_err;
1.402 + if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
1.403 + if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
1.404 +
1.405 + rc = sqlite3_create_function(db, "tx", 128, SQLITE_UTF8, 0, tStep, 0, 0);
1.406 + if( rc!=SQLITE_ERROR ) goto abuse_err;
1.407 + if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
1.408 + if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
1.409 +
1.410 + rc = sqlite3_create_function(db, "funcxx"
1.411 + "_123456789_123456789_123456789_123456789_123456789"
1.412 + "_123456789_123456789_123456789_123456789_123456789"
1.413 + "_123456789_123456789_123456789_123456789_123456789"
1.414 + "_123456789_123456789_123456789_123456789_123456789"
1.415 + "_123456789_123456789_123456789_123456789_123456789",
1.416 + 1, SQLITE_UTF8, 0, tStep, 0, 0);
1.417 + if( rc!=SQLITE_ERROR ) goto abuse_err;
1.418 + if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
1.419 + if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
1.420 +
1.421 + /* This last function registration should actually work. Generate
1.422 + ** a no-op function (that always returns NULL) and which has the
1.423 + ** maximum-length function name and the maximum number of parameters.
1.424 + */
1.425 + sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, 10000);
1.426 + mxArg = sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, -1);
1.427 + rc = sqlite3_create_function(db, "nullx"
1.428 + "_123456789_123456789_123456789_123456789_123456789"
1.429 + "_123456789_123456789_123456789_123456789_123456789"
1.430 + "_123456789_123456789_123456789_123456789_123456789"
1.431 + "_123456789_123456789_123456789_123456789_123456789"
1.432 + "_123456789_123456789_123456789_123456789_123456789",
1.433 + mxArg, SQLITE_UTF8, 0, tStep, 0, 0);
1.434 + if( rc!=SQLITE_OK ) goto abuse_err;
1.435 +
1.436 + return TCL_OK;
1.437 +
1.438 +abuse_err:
1.439 + Tcl_AppendResult(interp, "sqlite3_create_function abused test failed",
1.440 + (char*)0);
1.441 + return TCL_ERROR;
1.442 +}
1.443 +
1.444 +
1.445 +
1.446 +/*
1.447 +** Register commands with the TCL interpreter.
1.448 +*/
1.449 +int Sqlitetest_func_Init(Tcl_Interp *interp){
1.450 + static struct {
1.451 + char *zName;
1.452 + Tcl_ObjCmdProc *xProc;
1.453 + } aObjCmd[] = {
1.454 + { "autoinstall_test_functions", autoinstall_test_funcs },
1.455 + { "abuse_create_function", abuse_create_function },
1.456 + };
1.457 + int i;
1.458 + extern int Md5_Register(sqlite3*);
1.459 +
1.460 + for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
1.461 + Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
1.462 + }
1.463 + sqlite3_initialize();
1.464 + sqlite3_auto_extension((void*)registerTestFunctions);
1.465 + sqlite3_auto_extension((void*)Md5_Register);
1.466 + return TCL_OK;
1.467 +}