Annotation of embedaddon/sqlite3/src/test_func.c, revision 1.1.1.1
1.1 misho 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:
22: /*
23: ** Allocate nByte bytes of space using sqlite3_malloc(). If the
24: ** allocation fails, call sqlite3_result_error_nomem() to notify
25: ** the database handle that malloc() has failed.
26: */
27: static void *testContextMalloc(sqlite3_context *context, int nByte){
28: char *z = sqlite3_malloc(nByte);
29: if( !z && nByte>0 ){
30: sqlite3_result_error_nomem(context);
31: }
32: return z;
33: }
34:
35: /*
36: ** This function generates a string of random characters. Used for
37: ** generating test data.
38: */
39: static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){
40: static const unsigned char zSrc[] =
41: "abcdefghijklmnopqrstuvwxyz"
42: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
43: "0123456789"
44: ".-!,:*^+=_|?/<> ";
45: int iMin, iMax, n, r, i;
46: unsigned char zBuf[1000];
47:
48: /* It used to be possible to call randstr() with any number of arguments,
49: ** but now it is registered with SQLite as requiring exactly 2.
50: */
51: assert(argc==2);
52:
53: iMin = sqlite3_value_int(argv[0]);
54: if( iMin<0 ) iMin = 0;
55: if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1;
56: iMax = sqlite3_value_int(argv[1]);
57: if( iMax<iMin ) iMax = iMin;
58: if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1;
59: n = iMin;
60: if( iMax>iMin ){
61: sqlite3_randomness(sizeof(r), &r);
62: r &= 0x7fffffff;
63: n += r%(iMax + 1 - iMin);
64: }
65: assert( n<sizeof(zBuf) );
66: sqlite3_randomness(n, zBuf);
67: for(i=0; i<n; i++){
68: zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
69: }
70: zBuf[n] = 0;
71: sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT);
72: }
73:
74: /*
75: ** The following two SQL functions are used to test returning a text
76: ** result with a destructor. Function 'test_destructor' takes one argument
77: ** and returns the same argument interpreted as TEXT. A destructor is
78: ** passed with the sqlite3_result_text() call.
79: **
80: ** SQL function 'test_destructor_count' returns the number of outstanding
81: ** allocations made by 'test_destructor';
82: **
83: ** WARNING: Not threadsafe.
84: */
85: static int test_destructor_count_var = 0;
86: static void destructor(void *p){
87: char *zVal = (char *)p;
88: assert(zVal);
89: zVal--;
90: sqlite3_free(zVal);
91: test_destructor_count_var--;
92: }
93: static void test_destructor(
94: sqlite3_context *pCtx,
95: int nArg,
96: sqlite3_value **argv
97: ){
98: char *zVal;
99: int len;
100:
101: test_destructor_count_var++;
102: assert( nArg==1 );
103: if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
104: len = sqlite3_value_bytes(argv[0]);
105: zVal = testContextMalloc(pCtx, len+3);
106: if( !zVal ){
107: return;
108: }
109: zVal[len+1] = 0;
110: zVal[len+2] = 0;
111: zVal++;
112: memcpy(zVal, sqlite3_value_text(argv[0]), len);
113: sqlite3_result_text(pCtx, zVal, -1, destructor);
114: }
115: #ifndef SQLITE_OMIT_UTF16
116: static void test_destructor16(
117: sqlite3_context *pCtx,
118: int nArg,
119: sqlite3_value **argv
120: ){
121: char *zVal;
122: int len;
123:
124: test_destructor_count_var++;
125: assert( nArg==1 );
126: if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
127: len = sqlite3_value_bytes16(argv[0]);
128: zVal = testContextMalloc(pCtx, len+3);
129: if( !zVal ){
130: return;
131: }
132: zVal[len+1] = 0;
133: zVal[len+2] = 0;
134: zVal++;
135: memcpy(zVal, sqlite3_value_text16(argv[0]), len);
136: sqlite3_result_text16(pCtx, zVal, -1, destructor);
137: }
138: #endif
139: static void test_destructor_count(
140: sqlite3_context *pCtx,
141: int nArg,
142: sqlite3_value **argv
143: ){
144: sqlite3_result_int(pCtx, test_destructor_count_var);
145: }
146:
147: /*
148: ** The following aggregate function, test_agg_errmsg16(), takes zero
149: ** arguments. It returns the text value returned by the sqlite3_errmsg16()
150: ** API function.
151: */
152: #ifndef SQLITE_OMIT_BUILTIN_TEST
153: void sqlite3BeginBenignMalloc(void);
154: void sqlite3EndBenignMalloc(void);
155: #else
156: #define sqlite3BeginBenignMalloc()
157: #define sqlite3EndBenignMalloc()
158: #endif
159: static void test_agg_errmsg16_step(sqlite3_context *a, int b,sqlite3_value **c){
160: }
161: static void test_agg_errmsg16_final(sqlite3_context *ctx){
162: #ifndef SQLITE_OMIT_UTF16
163: const void *z;
164: sqlite3 * db = sqlite3_context_db_handle(ctx);
165: sqlite3_aggregate_context(ctx, 2048);
166: sqlite3BeginBenignMalloc();
167: z = sqlite3_errmsg16(db);
168: sqlite3EndBenignMalloc();
169: sqlite3_result_text16(ctx, z, -1, SQLITE_TRANSIENT);
170: #endif
171: }
172:
173: /*
174: ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata()
175: ** interface.
176: **
177: ** The test_auxdata() SQL function attempts to register each of its arguments
178: ** as auxiliary data. If there are no prior registrations of aux data for
179: ** that argument (meaning the argument is not a constant or this is its first
180: ** call) then the result for that argument is 0. If there is a prior
181: ** registration, the result for that argument is 1. The overall result
182: ** is the individual argument results separated by spaces.
183: */
184: static void free_test_auxdata(void *p) {sqlite3_free(p);}
185: static void test_auxdata(
186: sqlite3_context *pCtx,
187: int nArg,
188: sqlite3_value **argv
189: ){
190: int i;
191: char *zRet = testContextMalloc(pCtx, nArg*2);
192: if( !zRet ) return;
193: memset(zRet, 0, nArg*2);
194: for(i=0; i<nArg; i++){
195: char const *z = (char*)sqlite3_value_text(argv[i]);
196: if( z ){
197: int n;
198: char *zAux = sqlite3_get_auxdata(pCtx, i);
199: if( zAux ){
200: zRet[i*2] = '1';
201: assert( strcmp(zAux,z)==0 );
202: }else {
203: zRet[i*2] = '0';
204: }
205: n = strlen(z) + 1;
206: zAux = testContextMalloc(pCtx, n);
207: if( zAux ){
208: memcpy(zAux, z, n);
209: sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata);
210: }
211: zRet[i*2+1] = ' ';
212: }
213: }
214: sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata);
215: }
216:
217: /*
218: ** A function to test error reporting from user functions. This function
219: ** returns a copy of its first argument as the error message. If the
220: ** second argument exists, it becomes the error code.
221: */
222: static void test_error(
223: sqlite3_context *pCtx,
224: int nArg,
225: sqlite3_value **argv
226: ){
227: sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), -1);
228: if( nArg==2 ){
229: sqlite3_result_error_code(pCtx, sqlite3_value_int(argv[1]));
230: }
231: }
232:
233: /*
234: ** Implementation of the counter(X) function. If X is an integer
235: ** constant, then the first invocation will return X. The second X+1.
236: ** and so forth. Can be used (for example) to provide a sequence number
237: ** in a result set.
238: */
239: static void counterFunc(
240: sqlite3_context *pCtx, /* Function context */
241: int nArg, /* Number of function arguments */
242: sqlite3_value **argv /* Values for all function arguments */
243: ){
244: int *pCounter = (int*)sqlite3_get_auxdata(pCtx, 0);
245: if( pCounter==0 ){
246: pCounter = sqlite3_malloc( sizeof(*pCounter) );
247: if( pCounter==0 ){
248: sqlite3_result_error_nomem(pCtx);
249: return;
250: }
251: *pCounter = sqlite3_value_int(argv[0]);
252: sqlite3_set_auxdata(pCtx, 0, pCounter, sqlite3_free);
253: }else{
254: ++*pCounter;
255: }
256: sqlite3_result_int(pCtx, *pCounter);
257: }
258:
259:
260: /*
261: ** This function takes two arguments. It performance UTF-8/16 type
262: ** conversions on the first argument then returns a copy of the second
263: ** argument.
264: **
265: ** This function is used in cases such as the following:
266: **
267: ** SELECT test_isolation(x,x) FROM t1;
268: **
269: ** We want to verify that the type conversions that occur on the
270: ** first argument do not invalidate the second argument.
271: */
272: static void test_isolation(
273: sqlite3_context *pCtx,
274: int nArg,
275: sqlite3_value **argv
276: ){
277: #ifndef SQLITE_OMIT_UTF16
278: sqlite3_value_text16(argv[0]);
279: sqlite3_value_text(argv[0]);
280: sqlite3_value_text16(argv[0]);
281: sqlite3_value_text(argv[0]);
282: #endif
283: sqlite3_result_value(pCtx, argv[1]);
284: }
285:
286: /*
287: ** Invoke an SQL statement recursively. The function result is the
288: ** first column of the first row of the result set.
289: */
290: static void test_eval(
291: sqlite3_context *pCtx,
292: int nArg,
293: sqlite3_value **argv
294: ){
295: sqlite3_stmt *pStmt;
296: int rc;
297: sqlite3 *db = sqlite3_context_db_handle(pCtx);
298: const char *zSql;
299:
300: zSql = (char*)sqlite3_value_text(argv[0]);
301: rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
302: if( rc==SQLITE_OK ){
303: rc = sqlite3_step(pStmt);
304: if( rc==SQLITE_ROW ){
305: sqlite3_result_value(pCtx, sqlite3_column_value(pStmt, 0));
306: }
307: rc = sqlite3_finalize(pStmt);
308: }
309: if( rc ){
310: char *zErr;
311: assert( pStmt==0 );
312: zErr = sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db));
313: sqlite3_result_text(pCtx, zErr, -1, sqlite3_free);
314: sqlite3_result_error_code(pCtx, rc);
315: }
316: }
317:
318:
319: /*
320: ** convert one character from hex to binary
321: */
322: static int testHexChar(char c){
323: if( c>='0' && c<='9' ){
324: return c - '0';
325: }else if( c>='a' && c<='f' ){
326: return c - 'a' + 10;
327: }else if( c>='A' && c<='F' ){
328: return c - 'A' + 10;
329: }
330: return 0;
331: }
332:
333: /*
334: ** Convert hex to binary.
335: */
336: static void testHexToBin(const char *zIn, char *zOut){
337: while( zIn[0] && zIn[1] ){
338: *(zOut++) = (testHexChar(zIn[0])<<4) + testHexChar(zIn[1]);
339: zIn += 2;
340: }
341: }
342:
343: /*
344: ** hex_to_utf16be(HEX)
345: **
346: ** Convert the input string from HEX into binary. Then return the
347: ** result using sqlite3_result_text16le().
348: */
349: #ifndef SQLITE_OMIT_UTF16
350: static void testHexToUtf16be(
351: sqlite3_context *pCtx,
352: int nArg,
353: sqlite3_value **argv
354: ){
355: int n;
356: const char *zIn;
357: char *zOut;
358: assert( nArg==1 );
359: n = sqlite3_value_bytes(argv[0]);
360: zIn = (const char*)sqlite3_value_text(argv[0]);
361: zOut = sqlite3_malloc( n/2 );
362: if( zOut==0 ){
363: sqlite3_result_error_nomem(pCtx);
364: }else{
365: testHexToBin(zIn, zOut);
366: sqlite3_result_text16be(pCtx, zOut, n/2, sqlite3_free);
367: }
368: }
369: #endif
370:
371: /*
372: ** hex_to_utf8(HEX)
373: **
374: ** Convert the input string from HEX into binary. Then return the
375: ** result using sqlite3_result_text16le().
376: */
377: static void testHexToUtf8(
378: sqlite3_context *pCtx,
379: int nArg,
380: sqlite3_value **argv
381: ){
382: int n;
383: const char *zIn;
384: char *zOut;
385: assert( nArg==1 );
386: n = sqlite3_value_bytes(argv[0]);
387: zIn = (const char*)sqlite3_value_text(argv[0]);
388: zOut = sqlite3_malloc( n/2 );
389: if( zOut==0 ){
390: sqlite3_result_error_nomem(pCtx);
391: }else{
392: testHexToBin(zIn, zOut);
393: sqlite3_result_text(pCtx, zOut, n/2, sqlite3_free);
394: }
395: }
396:
397: /*
398: ** hex_to_utf16le(HEX)
399: **
400: ** Convert the input string from HEX into binary. Then return the
401: ** result using sqlite3_result_text16le().
402: */
403: #ifndef SQLITE_OMIT_UTF16
404: static void testHexToUtf16le(
405: sqlite3_context *pCtx,
406: int nArg,
407: sqlite3_value **argv
408: ){
409: int n;
410: const char *zIn;
411: char *zOut;
412: assert( nArg==1 );
413: n = sqlite3_value_bytes(argv[0]);
414: zIn = (const char*)sqlite3_value_text(argv[0]);
415: zOut = sqlite3_malloc( n/2 );
416: if( zOut==0 ){
417: sqlite3_result_error_nomem(pCtx);
418: }else{
419: testHexToBin(zIn, zOut);
420: sqlite3_result_text16le(pCtx, zOut, n/2, sqlite3_free);
421: }
422: }
423: #endif
424:
425: static int registerTestFunctions(sqlite3 *db){
426: static const struct {
427: char *zName;
428: signed char nArg;
429: unsigned char eTextRep; /* 1: UTF-16. 0: UTF-8 */
430: void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
431: } aFuncs[] = {
432: { "randstr", 2, SQLITE_UTF8, randStr },
433: { "test_destructor", 1, SQLITE_UTF8, test_destructor},
434: #ifndef SQLITE_OMIT_UTF16
435: { "test_destructor16", 1, SQLITE_UTF8, test_destructor16},
436: { "hex_to_utf16be", 1, SQLITE_UTF8, testHexToUtf16be},
437: { "hex_to_utf16le", 1, SQLITE_UTF8, testHexToUtf16le},
438: #endif
439: { "hex_to_utf8", 1, SQLITE_UTF8, testHexToUtf8},
440: { "test_destructor_count", 0, SQLITE_UTF8, test_destructor_count},
441: { "test_auxdata", -1, SQLITE_UTF8, test_auxdata},
442: { "test_error", 1, SQLITE_UTF8, test_error},
443: { "test_error", 2, SQLITE_UTF8, test_error},
444: { "test_eval", 1, SQLITE_UTF8, test_eval},
445: { "test_isolation", 2, SQLITE_UTF8, test_isolation},
446: { "test_counter", 1, SQLITE_UTF8, counterFunc},
447: };
448: int i;
449:
450: for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
451: sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg,
452: aFuncs[i].eTextRep, 0, aFuncs[i].xFunc, 0, 0);
453: }
454:
455: sqlite3_create_function(db, "test_agg_errmsg16", 0, SQLITE_ANY, 0, 0,
456: test_agg_errmsg16_step, test_agg_errmsg16_final);
457:
458: return SQLITE_OK;
459: }
460:
461: /*
462: ** TCLCMD: autoinstall_test_functions
463: **
464: ** Invoke this TCL command to use sqlite3_auto_extension() to cause
465: ** the standard set of test functions to be loaded into each new
466: ** database connection.
467: */
468: static int autoinstall_test_funcs(
469: void * clientData,
470: Tcl_Interp *interp,
471: int objc,
472: Tcl_Obj *CONST objv[]
473: ){
474: extern int Md5_Register(sqlite3*);
475: int rc = sqlite3_auto_extension((void*)registerTestFunctions);
476: if( rc==SQLITE_OK ){
477: rc = sqlite3_auto_extension((void*)Md5_Register);
478: }
479: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
480: return TCL_OK;
481: }
482:
483: /*
484: ** A bogus step function and finalizer function.
485: */
486: static void tStep(sqlite3_context *a, int b, sqlite3_value **c){}
487: static void tFinal(sqlite3_context *a){}
488:
489:
490: /*
491: ** tclcmd: abuse_create_function
492: **
493: ** Make various calls to sqlite3_create_function that do not have valid
494: ** parameters. Verify that the error condition is detected and reported.
495: */
496: static int abuse_create_function(
497: void * clientData,
498: Tcl_Interp *interp,
499: int objc,
500: Tcl_Obj *CONST objv[]
501: ){
502: extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
503: sqlite3 *db;
504: int rc;
505: int mxArg;
506:
507: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
508:
509: rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep,tStep,tFinal);
510: if( rc!=SQLITE_MISUSE ) goto abuse_err;
511:
512: rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, 0);
513: if( rc!=SQLITE_MISUSE ) goto abuse_err;
514:
515: rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, 0, tFinal);
516: if( rc!=SQLITE_MISUSE) goto abuse_err;
517:
518: rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, 0, tFinal);
519: if( rc!=SQLITE_MISUSE ) goto abuse_err;
520:
521: rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, tStep, 0);
522: if( rc!=SQLITE_MISUSE ) goto abuse_err;
523:
524: rc = sqlite3_create_function(db, "tx", -2, SQLITE_UTF8, 0, tStep, 0, 0);
525: if( rc!=SQLITE_MISUSE ) goto abuse_err;
526:
527: rc = sqlite3_create_function(db, "tx", 128, SQLITE_UTF8, 0, tStep, 0, 0);
528: if( rc!=SQLITE_MISUSE ) goto abuse_err;
529:
530: rc = sqlite3_create_function(db, "funcxx"
531: "_123456789_123456789_123456789_123456789_123456789"
532: "_123456789_123456789_123456789_123456789_123456789"
533: "_123456789_123456789_123456789_123456789_123456789"
534: "_123456789_123456789_123456789_123456789_123456789"
535: "_123456789_123456789_123456789_123456789_123456789",
536: 1, SQLITE_UTF8, 0, tStep, 0, 0);
537: if( rc!=SQLITE_MISUSE ) goto abuse_err;
538:
539: /* This last function registration should actually work. Generate
540: ** a no-op function (that always returns NULL) and which has the
541: ** maximum-length function name and the maximum number of parameters.
542: */
543: sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, 10000);
544: mxArg = sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, -1);
545: rc = sqlite3_create_function(db, "nullx"
546: "_123456789_123456789_123456789_123456789_123456789"
547: "_123456789_123456789_123456789_123456789_123456789"
548: "_123456789_123456789_123456789_123456789_123456789"
549: "_123456789_123456789_123456789_123456789_123456789"
550: "_123456789_123456789_123456789_123456789_123456789",
551: mxArg, SQLITE_UTF8, 0, tStep, 0, 0);
552: if( rc!=SQLITE_OK ) goto abuse_err;
553:
554: return TCL_OK;
555:
556: abuse_err:
557: Tcl_AppendResult(interp, "sqlite3_create_function abused test failed",
558: (char*)0);
559: return TCL_ERROR;
560: }
561:
562: /*
563: ** Register commands with the TCL interpreter.
564: */
565: int Sqlitetest_func_Init(Tcl_Interp *interp){
566: static struct {
567: char *zName;
568: Tcl_ObjCmdProc *xProc;
569: } aObjCmd[] = {
570: { "autoinstall_test_functions", autoinstall_test_funcs },
571: { "abuse_create_function", abuse_create_function },
572: };
573: int i;
574: extern int Md5_Register(sqlite3*);
575:
576: for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
577: Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
578: }
579: sqlite3_initialize();
580: sqlite3_auto_extension((void*)registerTestFunctions);
581: sqlite3_auto_extension((void*)Md5_Register);
582: return TCL_OK;
583: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_func.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src