Annotation of embedaddon/sqlite3/src/test_init.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2009 August 17
! 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: **
! 13: ** The code in this file is used for testing SQLite. It is not part of
! 14: ** the source code used in production systems.
! 15: **
! 16: ** Specifically, this file tests the effect of errors while initializing
! 17: ** the various pluggable sub-systems from within sqlite3_initialize().
! 18: ** If an error occurs in sqlite3_initialize() the following should be
! 19: ** true:
! 20: **
! 21: ** 1) An error code is returned to the user, and
! 22: ** 2) A subsequent call to sqlite3_shutdown() calls the shutdown method
! 23: ** of those subsystems that were initialized, and
! 24: ** 3) A subsequent call to sqlite3_initialize() attempts to initialize
! 25: ** the remaining, uninitialized, subsystems.
! 26: */
! 27:
! 28: #include "sqliteInt.h"
! 29: #include <string.h>
! 30: #include <tcl.h>
! 31:
! 32: static struct Wrapped {
! 33: sqlite3_pcache_methods2 pcache;
! 34: sqlite3_mem_methods mem;
! 35: sqlite3_mutex_methods mutex;
! 36:
! 37: int mem_init; /* True if mem subsystem is initalized */
! 38: int mem_fail; /* True to fail mem subsystem inialization */
! 39: int mutex_init; /* True if mutex subsystem is initalized */
! 40: int mutex_fail; /* True to fail mutex subsystem inialization */
! 41: int pcache_init; /* True if pcache subsystem is initalized */
! 42: int pcache_fail; /* True to fail pcache subsystem inialization */
! 43: } wrapped;
! 44:
! 45: static int wrMemInit(void *pAppData){
! 46: int rc;
! 47: if( wrapped.mem_fail ){
! 48: rc = SQLITE_ERROR;
! 49: }else{
! 50: rc = wrapped.mem.xInit(wrapped.mem.pAppData);
! 51: }
! 52: if( rc==SQLITE_OK ){
! 53: wrapped.mem_init = 1;
! 54: }
! 55: return rc;
! 56: }
! 57: static void wrMemShutdown(void *pAppData){
! 58: wrapped.mem.xShutdown(wrapped.mem.pAppData);
! 59: wrapped.mem_init = 0;
! 60: }
! 61: static void *wrMemMalloc(int n) {return wrapped.mem.xMalloc(n);}
! 62: static void wrMemFree(void *p) {wrapped.mem.xFree(p);}
! 63: static void *wrMemRealloc(void *p, int n) {return wrapped.mem.xRealloc(p, n);}
! 64: static int wrMemSize(void *p) {return wrapped.mem.xSize(p);}
! 65: static int wrMemRoundup(int n) {return wrapped.mem.xRoundup(n);}
! 66:
! 67:
! 68: static int wrMutexInit(void){
! 69: int rc;
! 70: if( wrapped.mutex_fail ){
! 71: rc = SQLITE_ERROR;
! 72: }else{
! 73: rc = wrapped.mutex.xMutexInit();
! 74: }
! 75: if( rc==SQLITE_OK ){
! 76: wrapped.mutex_init = 1;
! 77: }
! 78: return rc;
! 79: }
! 80: static int wrMutexEnd(void){
! 81: wrapped.mutex.xMutexEnd();
! 82: wrapped.mutex_init = 0;
! 83: return SQLITE_OK;
! 84: }
! 85: static sqlite3_mutex *wrMutexAlloc(int e){
! 86: return wrapped.mutex.xMutexAlloc(e);
! 87: }
! 88: static void wrMutexFree(sqlite3_mutex *p){
! 89: wrapped.mutex.xMutexFree(p);
! 90: }
! 91: static void wrMutexEnter(sqlite3_mutex *p){
! 92: wrapped.mutex.xMutexEnter(p);
! 93: }
! 94: static int wrMutexTry(sqlite3_mutex *p){
! 95: return wrapped.mutex.xMutexTry(p);
! 96: }
! 97: static void wrMutexLeave(sqlite3_mutex *p){
! 98: wrapped.mutex.xMutexLeave(p);
! 99: }
! 100: static int wrMutexHeld(sqlite3_mutex *p){
! 101: return wrapped.mutex.xMutexHeld(p);
! 102: }
! 103: static int wrMutexNotheld(sqlite3_mutex *p){
! 104: return wrapped.mutex.xMutexNotheld(p);
! 105: }
! 106:
! 107:
! 108:
! 109: static int wrPCacheInit(void *pArg){
! 110: int rc;
! 111: if( wrapped.pcache_fail ){
! 112: rc = SQLITE_ERROR;
! 113: }else{
! 114: rc = wrapped.pcache.xInit(wrapped.pcache.pArg);
! 115: }
! 116: if( rc==SQLITE_OK ){
! 117: wrapped.pcache_init = 1;
! 118: }
! 119: return rc;
! 120: }
! 121: static void wrPCacheShutdown(void *pArg){
! 122: wrapped.pcache.xShutdown(wrapped.pcache.pArg);
! 123: wrapped.pcache_init = 0;
! 124: }
! 125:
! 126: static sqlite3_pcache *wrPCacheCreate(int a, int b, int c){
! 127: return wrapped.pcache.xCreate(a, b, c);
! 128: }
! 129: static void wrPCacheCachesize(sqlite3_pcache *p, int n){
! 130: wrapped.pcache.xCachesize(p, n);
! 131: }
! 132: static int wrPCachePagecount(sqlite3_pcache *p){
! 133: return wrapped.pcache.xPagecount(p);
! 134: }
! 135: static sqlite3_pcache_page *wrPCacheFetch(sqlite3_pcache *p, unsigned a, int b){
! 136: return wrapped.pcache.xFetch(p, a, b);
! 137: }
! 138: static void wrPCacheUnpin(sqlite3_pcache *p, sqlite3_pcache_page *a, int b){
! 139: wrapped.pcache.xUnpin(p, a, b);
! 140: }
! 141: static void wrPCacheRekey(
! 142: sqlite3_pcache *p,
! 143: sqlite3_pcache_page *a,
! 144: unsigned b,
! 145: unsigned c
! 146: ){
! 147: wrapped.pcache.xRekey(p, a, b, c);
! 148: }
! 149: static void wrPCacheTruncate(sqlite3_pcache *p, unsigned a){
! 150: wrapped.pcache.xTruncate(p, a);
! 151: }
! 152: static void wrPCacheDestroy(sqlite3_pcache *p){
! 153: wrapped.pcache.xDestroy(p);
! 154: }
! 155:
! 156: static void installInitWrappers(void){
! 157: sqlite3_mutex_methods mutexmethods = {
! 158: wrMutexInit, wrMutexEnd, wrMutexAlloc,
! 159: wrMutexFree, wrMutexEnter, wrMutexTry,
! 160: wrMutexLeave, wrMutexHeld, wrMutexNotheld
! 161: };
! 162: sqlite3_pcache_methods2 pcachemethods = {
! 163: 1, 0,
! 164: wrPCacheInit, wrPCacheShutdown, wrPCacheCreate,
! 165: wrPCacheCachesize, wrPCachePagecount, wrPCacheFetch,
! 166: wrPCacheUnpin, wrPCacheRekey, wrPCacheTruncate,
! 167: wrPCacheDestroy
! 168: };
! 169: sqlite3_mem_methods memmethods = {
! 170: wrMemMalloc, wrMemFree, wrMemRealloc,
! 171: wrMemSize, wrMemRoundup, wrMemInit,
! 172: wrMemShutdown,
! 173: 0
! 174: };
! 175:
! 176: memset(&wrapped, 0, sizeof(wrapped));
! 177:
! 178: sqlite3_shutdown();
! 179: sqlite3_config(SQLITE_CONFIG_GETMUTEX, &wrapped.mutex);
! 180: sqlite3_config(SQLITE_CONFIG_GETMALLOC, &wrapped.mem);
! 181: sqlite3_config(SQLITE_CONFIG_GETPCACHE2, &wrapped.pcache);
! 182: sqlite3_config(SQLITE_CONFIG_MUTEX, &mutexmethods);
! 183: sqlite3_config(SQLITE_CONFIG_MALLOC, &memmethods);
! 184: sqlite3_config(SQLITE_CONFIG_PCACHE2, &pcachemethods);
! 185: }
! 186:
! 187: static int init_wrapper_install(
! 188: ClientData clientData, /* Unused */
! 189: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 190: int objc, /* Number of arguments */
! 191: Tcl_Obj *CONST objv[] /* Command arguments */
! 192: ){
! 193: int i;
! 194: installInitWrappers();
! 195: for(i=1; i<objc; i++){
! 196: char *z = Tcl_GetString(objv[i]);
! 197: if( strcmp(z, "mem")==0 ){
! 198: wrapped.mem_fail = 1;
! 199: }else if( strcmp(z, "mutex")==0 ){
! 200: wrapped.mutex_fail = 1;
! 201: }else if( strcmp(z, "pcache")==0 ){
! 202: wrapped.pcache_fail = 1;
! 203: }else{
! 204: Tcl_AppendResult(interp, "Unknown argument: \"", z, "\"");
! 205: return TCL_ERROR;
! 206: }
! 207: }
! 208: return TCL_OK;
! 209: }
! 210:
! 211: static int init_wrapper_uninstall(
! 212: ClientData clientData, /* Unused */
! 213: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 214: int objc, /* Number of arguments */
! 215: Tcl_Obj *CONST objv[] /* Command arguments */
! 216: ){
! 217: if( objc!=1 ){
! 218: Tcl_WrongNumArgs(interp, 1, objv, "");
! 219: return TCL_ERROR;
! 220: }
! 221:
! 222: memset(&wrapped, 0, sizeof(&wrapped));
! 223: sqlite3_shutdown();
! 224: sqlite3_config(SQLITE_CONFIG_MUTEX, &wrapped.mutex);
! 225: sqlite3_config(SQLITE_CONFIG_MALLOC, &wrapped.mem);
! 226: sqlite3_config(SQLITE_CONFIG_PCACHE2, &wrapped.pcache);
! 227: return TCL_OK;
! 228: }
! 229:
! 230: static int init_wrapper_clear(
! 231: ClientData clientData, /* Unused */
! 232: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 233: int objc, /* Number of arguments */
! 234: Tcl_Obj *CONST objv[] /* Command arguments */
! 235: ){
! 236: if( objc!=1 ){
! 237: Tcl_WrongNumArgs(interp, 1, objv, "");
! 238: return TCL_ERROR;
! 239: }
! 240:
! 241: wrapped.mem_fail = 0;
! 242: wrapped.mutex_fail = 0;
! 243: wrapped.pcache_fail = 0;
! 244: return TCL_OK;
! 245: }
! 246:
! 247: static int init_wrapper_query(
! 248: ClientData clientData, /* Unused */
! 249: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 250: int objc, /* Number of arguments */
! 251: Tcl_Obj *CONST objv[] /* Command arguments */
! 252: ){
! 253: Tcl_Obj *pRet;
! 254:
! 255: if( objc!=1 ){
! 256: Tcl_WrongNumArgs(interp, 1, objv, "");
! 257: return TCL_ERROR;
! 258: }
! 259:
! 260: pRet = Tcl_NewObj();
! 261: if( wrapped.mutex_init ){
! 262: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("mutex", -1));
! 263: }
! 264: if( wrapped.mem_init ){
! 265: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("mem", -1));
! 266: }
! 267: if( wrapped.pcache_init ){
! 268: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("pcache", -1));
! 269: }
! 270:
! 271: Tcl_SetObjResult(interp, pRet);
! 272: return TCL_OK;
! 273: }
! 274:
! 275: int Sqlitetest_init_Init(Tcl_Interp *interp){
! 276: static struct {
! 277: char *zName;
! 278: Tcl_ObjCmdProc *xProc;
! 279: } aObjCmd[] = {
! 280: {"init_wrapper_install", init_wrapper_install},
! 281: {"init_wrapper_query", init_wrapper_query },
! 282: {"init_wrapper_uninstall", init_wrapper_uninstall},
! 283: {"init_wrapper_clear", init_wrapper_clear}
! 284: };
! 285: int i;
! 286:
! 287: for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
! 288: Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
! 289: }
! 290:
! 291: return TCL_OK;
! 292: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_init.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