src/test2.c

   1 /*
   2 ** 2001 September 15
   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 the pager.c module in SQLite.  This code
  13 ** is not included in the SQLite library.  It is used for automated
  14 ** testing of the SQLite library.
  15 */
  16 #include "sqliteInt.h"
  17 #if defined(INCLUDE_SQLITE_TCL_H)
  18 #  include "sqlite_tcl.h"
  19 #else
  20 #  include "tcl.h"
  21 #endif
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <ctype.h>
  25
  26 extern const char *sqlite3ErrName(int);
  27
  28 /*
  29 ** Page size and reserved size used for testing.
  30 */
  31 static int test_pagesize = 1024;
  32
  33 /*
  34 ** Dummy page reinitializer
  35 */
  36 static void pager_test_reiniter(DbPage *pNotUsed){
  37   return;
  38 }
  39
  40 /*
  41 ** Usage:   pager_open FILENAME N-PAGE
  42 **
  43 ** Open a new pager
  44 */
  45 static int SQLITE_TCLAPI pager_open(
  46   void *NotUsed,
  47   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
  48   int argc,              /* Number of arguments */
  49   const char **argv      /* Text of each argument */
  50 ){
  51   u32 pageSize;
  52   Pager *pPager;
  53   int nPage;
  54   int rc;
  55   char zBuf[100];
  56   if( argc!=3 ){
  57     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
  58        " FILENAME N-PAGE\"", 0);
  59     return TCL_ERROR;
  60   }
  61   if( Tcl_GetInt(interp, argv[2], &nPage) ) return TCL_ERROR;
  62   rc = sqlite3PagerOpen(sqlite3_vfs_find(0), &pPager, argv[1], 0, 0,
  63       SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB,
  64       pager_test_reiniter);
  65   if( rc!=SQLITE_OK ){
  66     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
  67     return TCL_ERROR;
  68   }
  69   sqlite3PagerSetCachesize(pPager, nPage);
  70   pageSize = test_pagesize;
  71   sqlite3PagerSetPagesize(pPager, &pageSize, -1);
  72   sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPager);
  73   Tcl_AppendResult(interp, zBuf, 0);
  74   return TCL_OK;
  75 }
  76
  77 /*
  78 ** Usage:   pager_close ID
  79 **
  80 ** Close the given pager.
  81 */
  82 static int SQLITE_TCLAPI pager_close(
  83   void *NotUsed,
  84   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
  85   int argc,              /* Number of arguments */
  86   const char **argv      /* Text of each argument */
  87 ){
  88   Pager *pPager;
  89   int rc;
  90   if( argc!=2 ){
  91     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
  92        " ID\"", 0);
  93     return TCL_ERROR;
  94   }
  95   pPager = sqlite3TestTextToPtr(argv[1]);
  96   rc = sqlite3PagerClose(pPager, 0);
  97   if( rc!=SQLITE_OK ){
  98     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
  99     return TCL_ERROR;
 100   }
 101   return TCL_OK;
 102 }
 103
 104 /*
 105 ** Usage:   pager_rollback ID
 106 **
 107 ** Rollback changes
 108 */
 109 static int SQLITE_TCLAPI pager_rollback(
 110   void *NotUsed,
 111   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 112   int argc,              /* Number of arguments */
 113   const char **argv      /* Text of each argument */
 114 ){
 115   Pager *pPager;
 116   int rc;
 117   if( argc!=2 ){
 118     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 119        " ID\"", 0);
 120     return TCL_ERROR;
 121   }
 122   pPager = sqlite3TestTextToPtr(argv[1]);
 123   rc = sqlite3PagerRollback(pPager);
 124   if( rc!=SQLITE_OK ){
 125     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
 126     return TCL_ERROR;
 127   }
 128   return TCL_OK;
 129 }
 130
 131 /*
 132 ** Usage:   pager_commit ID
 133 **
 134 ** Commit all changes
 135 */
 136 static int SQLITE_TCLAPI pager_commit(
 137   void *NotUsed,
 138   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 139   int argc,              /* Number of arguments */
 140   const char **argv      /* Text of each argument */
 141 ){
 142   Pager *pPager;
 143   int rc;
 144   if( argc!=2 ){
 145     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 146        " ID\"", 0);
 147     return TCL_ERROR;
 148   }
 149   pPager = sqlite3TestTextToPtr(argv[1]);
 150   rc = sqlite3PagerCommitPhaseOne(pPager, 0, 0);
 151   if( rc!=SQLITE_OK ){
 152     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
 153     return TCL_ERROR;
 154   }
 155   rc = sqlite3PagerCommitPhaseTwo(pPager);
 156   if( rc!=SQLITE_OK ){
 157     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
 158     return TCL_ERROR;
 159   }
 160   return TCL_OK;
 161 }
 162
 163 /*
 164 ** Usage:   pager_stmt_begin ID
 165 **
 166 ** Start a new checkpoint.
 167 */
 168 static int SQLITE_TCLAPI pager_stmt_begin(
 169   void *NotUsed,
 170   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 171   int argc,              /* Number of arguments */
 172   const char **argv      /* Text of each argument */
 173 ){
 174   Pager *pPager;
 175   int rc;
 176   if( argc!=2 ){
 177     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 178        " ID\"", 0);
 179     return TCL_ERROR;
 180   }
 181   pPager = sqlite3TestTextToPtr(argv[1]);
 182   rc = sqlite3PagerOpenSavepoint(pPager, 1);
 183   if( rc!=SQLITE_OK ){
 184     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
 185     return TCL_ERROR;
 186   }
 187   return TCL_OK;
 188 }
 189
 190 /*
 191 ** Usage:   pager_stmt_rollback ID
 192 **
 193 ** Rollback changes to a checkpoint
 194 */
 195 static int SQLITE_TCLAPI pager_stmt_rollback(
 196   void *NotUsed,
 197   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 198   int argc,              /* Number of arguments */
 199   const char **argv      /* Text of each argument */
 200 ){
 201   Pager *pPager;
 202   int rc;
 203   if( argc!=2 ){
 204     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 205        " ID\"", 0);
 206     return TCL_ERROR;
 207   }
 208   pPager = sqlite3TestTextToPtr(argv[1]);
 209   rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, 0);
 210   sqlite3PagerSavepoint(pPager, SAVEPOINT_RELEASE, 0);
 211   if( rc!=SQLITE_OK ){
 212     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
 213     return TCL_ERROR;
 214   }
 215   return TCL_OK;
 216 }
 217
 218 /*
 219 ** Usage:   pager_stmt_commit ID
 220 **
 221 ** Commit changes to a checkpoint
 222 */
 223 static int SQLITE_TCLAPI pager_stmt_commit(
 224   void *NotUsed,
 225   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 226   int argc,              /* Number of arguments */
 227   const char **argv      /* Text of each argument */
 228 ){
 229   Pager *pPager;
 230   int rc;
 231   if( argc!=2 ){
 232     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 233        " ID\"", 0);
 234     return TCL_ERROR;
 235   }
 236   pPager = sqlite3TestTextToPtr(argv[1]);
 237   rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_RELEASE, 0);
 238   if( rc!=SQLITE_OK ){
 239     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
 240     return TCL_ERROR;
 241   }
 242   return TCL_OK;
 243 }
 244
 245 /*
 246 ** Usage:   pager_stats ID
 247 **
 248 ** Return pager statistics.
 249 */
 250 static int SQLITE_TCLAPI pager_stats(
 251   void *NotUsed,
 252   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 253   int argc,              /* Number of arguments */
 254   const char **argv      /* Text of each argument */
 255 ){
 256   Pager *pPager;
 257   int i, *a;
 258   if( argc!=2 ){
 259     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 260        " ID\"", 0);
 261     return TCL_ERROR;
 262   }
 263   pPager = sqlite3TestTextToPtr(argv[1]);
 264   a = sqlite3PagerStats(pPager);
 265   for(i=0; i<9; i++){
 266     static char *zName[] = {
 267       "ref", "page", "max", "size", "state", "err",
 268       "hit", "miss", "ovfl",
 269     };
 270     char zBuf[100];
 271     Tcl_AppendElement(interp, zName[i]);
 272     sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",a[i]);
 273     Tcl_AppendElement(interp, zBuf);
 274   }
 275   return TCL_OK;
 276 }
 277
 278 /*
 279 ** Usage:   pager_pagecount ID
 280 **
 281 ** Return the size of the database file.
 282 */
 283 static int SQLITE_TCLAPI pager_pagecount(
 284   void *NotUsed,
 285   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 286   int argc,              /* Number of arguments */
 287   const char **argv      /* Text of each argument */
 288 ){
 289   Pager *pPager;
 290   char zBuf[100];
 291   int nPage;
 292   if( argc!=2 ){
 293     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 294        " ID\"", 0);
 295     return TCL_ERROR;
 296   }
 297   pPager = sqlite3TestTextToPtr(argv[1]);
 298   sqlite3PagerPagecount(pPager, &nPage);
 299   sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", nPage);
 300   Tcl_AppendResult(interp, zBuf, 0);
 301   return TCL_OK;
 302 }
 303
 304 /*
 305 ** Usage:   page_get ID PGNO
 306 **
 307 ** Return a pointer to a page from the database.
 308 */
 309 static int SQLITE_TCLAPI page_get(
 310   void *NotUsed,
 311   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 312   int argc,              /* Number of arguments */
 313   const char **argv      /* Text of each argument */
 314 ){
 315   Pager *pPager;
 316   char zBuf[100];
 317   DbPage *pPage = 0;
 318   int pgno;
 319   int rc;
 320   if( argc!=3 ){
 321     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 322        " ID PGNO\"", 0);
 323     return TCL_ERROR;
 324   }
 325   pPager = sqlite3TestTextToPtr(argv[1]);
 326   if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
 327   rc = sqlite3PagerSharedLock(pPager);
 328   if( rc==SQLITE_OK ){
 329     rc = sqlite3PagerGet(pPager, pgno, &pPage, 0);
 330   }
 331   if( rc!=SQLITE_OK ){
 332     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
 333     return TCL_ERROR;
 334   }
 335   sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
 336   Tcl_AppendResult(interp, zBuf, 0);
 337   return TCL_OK;
 338 }
 339
 340 /*
 341 ** Usage:   page_lookup ID PGNO
 342 **
 343 ** Return a pointer to a page if the page is already in cache.
 344 ** If not in cache, return an empty string.
 345 */
 346 static int SQLITE_TCLAPI page_lookup(
 347   void *NotUsed,
 348   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 349   int argc,              /* Number of arguments */
 350   const char **argv      /* Text of each argument */
 351 ){
 352   Pager *pPager;
 353   char zBuf[100];
 354   DbPage *pPage;
 355   int pgno;
 356   if( argc!=3 ){
 357     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 358        " ID PGNO\"", 0);
 359     return TCL_ERROR;
 360   }
 361   pPager = sqlite3TestTextToPtr(argv[1]);
 362   if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
 363   pPage = sqlite3PagerLookup(pPager, pgno);
 364   if( pPage ){
 365     sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
 366     Tcl_AppendResult(interp, zBuf, 0);
 367   }
 368   return TCL_OK;
 369 }
 370
 371 /*
 372 ** Usage:   pager_truncate ID PGNO
 373 */
 374 static int SQLITE_TCLAPI pager_truncate(
 375   void *NotUsed,
 376   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 377   int argc,              /* Number of arguments */
 378   const char **argv      /* Text of each argument */
 379 ){
 380   Pager *pPager;
 381   int pgno;
 382   if( argc!=3 ){
 383     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 384        " ID PGNO\"", 0);
 385     return TCL_ERROR;
 386   }
 387   pPager = sqlite3TestTextToPtr(argv[1]);
 388   if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
 389   sqlite3PagerTruncateImage(pPager, pgno);
 390   return TCL_OK;
 391 }
 392
 393
 394 /*
 395 ** Usage:   page_unref PAGE
 396 **
 397 ** Drop a pointer to a page.
 398 */
 399 static int SQLITE_TCLAPI page_unref(
 400   void *NotUsed,
 401   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 402   int argc,              /* Number of arguments */
 403   const char **argv      /* Text of each argument */
 404 ){
 405   DbPage *pPage;
 406   if( argc!=2 ){
 407     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 408        " PAGE\"", 0);
 409     return TCL_ERROR;
 410   }
 411   pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
 412   sqlite3PagerUnref(pPage);
 413   return TCL_OK;
 414 }
 415
 416 /*
 417 ** Usage:   page_read PAGE
 418 **
 419 ** Return the content of a page
 420 */
 421 static int SQLITE_TCLAPI page_read(
 422   void *NotUsed,
 423   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 424   int argc,              /* Number of arguments */
 425   const char **argv      /* Text of each argument */
 426 ){
 427   char zBuf[100];
 428   DbPage *pPage;
 429   if( argc!=2 ){
 430     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 431        " PAGE\"", 0);
 432     return TCL_ERROR;
 433   }
 434   pPage = sqlite3TestTextToPtr(argv[1]);
 435   memcpy(zBuf, sqlite3PagerGetData(pPage), sizeof(zBuf));
 436   Tcl_AppendResult(interp, zBuf, 0);
 437   return TCL_OK;
 438 }
 439
 440 /*
 441 ** Usage:   page_number PAGE
 442 **
 443 ** Return the page number for a page.
 444 */
 445 static int SQLITE_TCLAPI page_number(
 446   void *NotUsed,
 447   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 448   int argc,              /* Number of arguments */
 449   const char **argv      /* Text of each argument */
 450 ){
 451   char zBuf[100];
 452   DbPage *pPage;
 453   if( argc!=2 ){
 454     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 455        " PAGE\"", 0);
 456     return TCL_ERROR;
 457   }
 458   pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
 459   sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3PagerPagenumber(pPage));
 460   Tcl_AppendResult(interp, zBuf, 0);
 461   return TCL_OK;
 462 }
 463
 464 /*
 465 ** Usage:   page_write PAGE DATA
 466 **
 467 ** Write something into a page.
 468 */
 469 static int SQLITE_TCLAPI page_write(
 470   void *NotUsed,
 471   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 472   int argc,              /* Number of arguments */
 473   const char **argv      /* Text of each argument */
 474 ){
 475   DbPage *pPage;
 476   char *pData;
 477   int rc;
 478   if( argc!=3 ){
 479     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 480        " PAGE DATA\"", 0);
 481     return TCL_ERROR;
 482   }
 483   pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
 484   rc = sqlite3PagerWrite(pPage);
 485   if( rc!=SQLITE_OK ){
 486     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
 487     return TCL_ERROR;
 488   }
 489   pData = sqlite3PagerGetData(pPage);
 490   strncpy(pData, argv[2], test_pagesize-1);
 491   pData[test_pagesize-1] = 0;
 492   return TCL_OK;
 493 }
 494
 495 #ifndef SQLITE_OMIT_DISKIO
 496 /*
 497 ** Usage:   fake_big_file  N  FILENAME
 498 **
 499 ** Write a few bytes at the N megabyte point of FILENAME.  This will
 500 ** create a large file.  If the file was a valid SQLite database, then
 501 ** the next time the database is opened, SQLite will begin allocating
 502 ** new pages after N.  If N is 2096 or bigger, this will test the
 503 ** ability of SQLite to write to large files.
 504 */
 505 static int SQLITE_TCLAPI fake_big_file(
 506   void *NotUsed,
 507   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 508   int argc,              /* Number of arguments */
 509   const char **argv      /* Text of each argument */
 510 ){
 511   sqlite3_vfs *pVfs;
 512   sqlite3_file *fd = 0;
 513   int rc;
 514   int n;
 515   i64 offset;
 516   char *zFile;
 517   int nFile;
 518   if( argc!=3 ){
 519     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 520        " N-MEGABYTES FILE\"", 0);
 521     return TCL_ERROR;
 522   }
 523   if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;
 524 #if defined(_WIN32)
 525   if( n>2 ){
 526     Tcl_AppendResult(interp, "cannot create ", argv[1],
 527        "MB file because Windows "
 528        "does not support sparse files", (void*)0);
 529     return TCL_ERROR;
 530   }
 531 #endif
 532
 533   pVfs = sqlite3_vfs_find(0);
 534   nFile = (int)strlen(argv[2]);
 535   zFile = sqlite3_malloc( nFile+2 );
 536   if( zFile==0 ) return TCL_ERROR;
 537   memcpy(zFile, argv[2], nFile+1);
 538   zFile[nFile+1] = 0;
 539   rc = sqlite3OsOpenMalloc(pVfs, zFile, &fd,
 540       (SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB), 0
 541   );
 542   if( rc ){
 543     Tcl_AppendResult(interp, "open failed: ", sqlite3ErrName(rc), 0);
 544     sqlite3_free(zFile);
 545     return TCL_ERROR;
 546   }
 547   offset = n;
 548   offset *= 1024*1024;
 549   rc = sqlite3OsWrite(fd, "Hello, World!", 14, offset);
 550   sqlite3OsCloseFree(fd);
 551   sqlite3_free(zFile);
 552   if( rc ){
 553     Tcl_AppendResult(interp, "write failed: ", sqlite3ErrName(rc), 0);
 554     return TCL_ERROR;
 555   }
 556   return TCL_OK;
 557 }
 558 #endif
 559
 560
 561 /*
 562 ** test_control_pending_byte  PENDING_BYTE
 563 **
 564 ** Set the PENDING_BYTE using the sqlite3_test_control() interface.
 565 */
 566 static int SQLITE_TCLAPI testPendingByte(
 567   void *NotUsed,
 568   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 569   int argc,              /* Number of arguments */
 570   const char **argv      /* Text of each argument */
 571 ){
 572   int pbyte;
 573   int rc;
 574   if( argc!=2 ){
 575     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 576                      " PENDING-BYTE\"", (void*)0);
 577     return TCL_ERROR;
 578   }
 579   if( Tcl_GetInt(interp, argv[1], &pbyte) ) return TCL_ERROR;
 580   rc = sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, pbyte);
 581   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
 582   return TCL_OK;
 583 }
 584
 585 /*
 586 ** The sqlite3FaultSim() callback:
 587 */
 588 static Tcl_Interp *faultSimInterp = 0;
 589 static int faultSimScriptSize = 0;
 590 static char *faultSimScript;
 591 static int faultSimCallback(int x){
 592   char zInt[30];
 593   int i;
 594   int isNeg;
 595   int rc;
 596   if( x==0 ){
 597     memcpy(faultSimScript+faultSimScriptSize, "0", 2);
 598   }else{
 599     /* Convert x to text without using any sqlite3 routines */
 600     if( x<0 ){
 601       isNeg = 1;
 602       x = -x;
 603     }else{
 604       isNeg = 0;
 605     }
 606     zInt[sizeof(zInt)-1] = 0;
 607     for(i=sizeof(zInt)-2; i>0 && x>0; i--, x /= 10){
 608       zInt[i] = (x%10) + '0';
 609     }
 610     if( isNeg ) zInt[i--] = '-';
 611     memcpy(faultSimScript+faultSimScriptSize, zInt+i+1, sizeof(zInt)-i-1);
 612   }
 613   rc = Tcl_Eval(faultSimInterp, faultSimScript);
 614   if( rc ){
 615     fprintf(stderr, "fault simulator script failed: [%s]", faultSimScript);
 616     rc = SQLITE_ERROR;
 617   }else{
 618     rc = atoi(Tcl_GetStringResult(faultSimInterp));
 619   }
 620   Tcl_ResetResult(faultSimInterp);
 621   return rc;
 622 }
 623
 624 /*
 625 ** sqlite3_test_control_fault_install SCRIPT
 626 **
 627 ** Arrange to invoke SCRIPT with the integer argument to sqlite3FaultSim()
 628 ** appended, whenever sqlite3FaultSim() is called.  Or, if SCRIPT is the
 629 ** empty string, cancel the sqlite3FaultSim() callback.
 630 */
 631 static int SQLITE_TCLAPI faultInstallCmd(
 632   void *NotUsed,
 633   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 634   int argc,              /* Number of arguments */
 635   const char **argv      /* Text of each argument */
 636 ){
 637   const char *zScript;
 638   int nScript;
 639   int rc;
 640   if( argc!=1 && argc!=2 ){
 641     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 642                      " SCRIPT\"", (void*)0);
 643   }
 644   zScript = argc==2 ? argv[1] : "";
 645   nScript = (int)strlen(zScript);
 646   if( faultSimScript ){
 647     free(faultSimScript);
 648     faultSimScript = 0;
 649   }
 650   if( nScript==0 ){
 651     rc = sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL, 0);
 652   }else{
 653     faultSimScript = malloc( nScript+100 );
 654     if( faultSimScript==0 ){
 655       Tcl_AppendResult(interp, "out of memory", (void*)0);
 656       return SQLITE_ERROR;
 657     }
 658     memcpy(faultSimScript, zScript, nScript);
 659     faultSimScript[nScript] = ' ';
 660     faultSimScriptSize = nScript+1;
 661     faultSimInterp = interp;
 662     rc = sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL, faultSimCallback);
 663   }
 664   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
 665   return SQLITE_OK;
 666 }
 667
 668 /*
 669 ** sqlite3BitvecBuiltinTest SIZE PROGRAM
 670 **
 671 ** Invoke the SQLITE_TESTCTRL_BITVEC_TEST operator on test_control.
 672 ** See comments on sqlite3BitvecBuiltinTest() for additional information.
 673 */
 674 static int SQLITE_TCLAPI testBitvecBuiltinTest(
 675   void *NotUsed,
 676   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 677   int argc,              /* Number of arguments */
 678   const char **argv      /* Text of each argument */
 679 ){
 680   int sz, rc;
 681   int nProg = 0;
 682   int aProg[100];
 683   const char *z;
 684   if( argc!=3 ){
 685     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 686                      " SIZE PROGRAM\"", (void*)0);
 687   }
 688   if( Tcl_GetInt(interp, argv[1], &sz) ) return TCL_ERROR;
 689   z = argv[2];
 690   while( nProg<99 && *z ){
 691     while( *z && !sqlite3Isdigit(*z) ){ z++; }
 692     if( *z==0 ) break;
 693     aProg[nProg++] = atoi(z);
 694     while( sqlite3Isdigit(*z) ){ z++; }
 695   }
 696   aProg[nProg] = 0;
 697   rc = sqlite3_test_control(SQLITE_TESTCTRL_BITVEC_TEST, sz, aProg);
 698   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
 699   return TCL_OK;
 700 }
 701
 702 /*
 703 ** Register commands with the TCL interpreter.
 704 */
 705 int Sqlitetest2_Init(Tcl_Interp *interp){
 706   extern int sqlite3_io_error_persist;
 707   extern int sqlite3_io_error_pending;
 708   extern int sqlite3_io_error_hit;
 709   extern int sqlite3_io_error_hardhit;
 710   extern int sqlite3_diskfull_pending;
 711   extern int sqlite3_diskfull;
 712   static struct {
 713     char *zName;
 714     Tcl_CmdProc *xProc;
 715   } aCmd[] = {
 716     { "pager_open",              (Tcl_CmdProc*)pager_open          },
 717     { "pager_close",             (Tcl_CmdProc*)pager_close         },
 718     { "pager_commit",            (Tcl_CmdProc*)pager_commit        },
 719     { "pager_rollback",          (Tcl_CmdProc*)pager_rollback      },
 720     { "pager_stmt_begin",        (Tcl_CmdProc*)pager_stmt_begin    },
 721     { "pager_stmt_commit",       (Tcl_CmdProc*)pager_stmt_commit   },
 722     { "pager_stmt_rollback",     (Tcl_CmdProc*)pager_stmt_rollback },
 723     { "pager_stats",             (Tcl_CmdProc*)pager_stats         },
 724     { "pager_pagecount",         (Tcl_CmdProc*)pager_pagecount     },
 725     { "page_get",                (Tcl_CmdProc*)page_get            },
 726     { "page_lookup",             (Tcl_CmdProc*)page_lookup         },
 727     { "page_unref",              (Tcl_CmdProc*)page_unref          },
 728     { "page_read",               (Tcl_CmdProc*)page_read           },
 729     { "page_write",              (Tcl_CmdProc*)page_write          },
 730     { "page_number",             (Tcl_CmdProc*)page_number         },
 731     { "pager_truncate",          (Tcl_CmdProc*)pager_truncate      },
 732 #ifndef SQLITE_OMIT_DISKIO
 733     { "fake_big_file",           (Tcl_CmdProc*)fake_big_file       },
 734 #endif
 735     { "sqlite3BitvecBuiltinTest",(Tcl_CmdProc*)testBitvecBuiltinTest     },
 736     { "sqlite3_test_control_pending_byte",  (Tcl_CmdProc*)testPendingByte },
 737     { "sqlite3_test_control_fault_install", (Tcl_CmdProc*)faultInstallCmd },
 738   };
 739   int i;
 740   for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
 741     Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
 742   }
 743   Tcl_LinkVar(interp, "sqlite_io_error_pending",
 744      (char*)&sqlite3_io_error_pending, TCL_LINK_INT);
 745   Tcl_LinkVar(interp, "sqlite_io_error_persist",
 746      (char*)&sqlite3_io_error_persist, TCL_LINK_INT);
 747   Tcl_LinkVar(interp, "sqlite_io_error_hit",
 748      (char*)&sqlite3_io_error_hit, TCL_LINK_INT);
 749   Tcl_LinkVar(interp, "sqlite_io_error_hardhit",
 750      (char*)&sqlite3_io_error_hardhit, TCL_LINK_INT);
 751   Tcl_LinkVar(interp, "sqlite_diskfull_pending",
 752      (char*)&sqlite3_diskfull_pending, TCL_LINK_INT);
 753   Tcl_LinkVar(interp, "sqlite_diskfull",
 754      (char*)&sqlite3_diskfull, TCL_LINK_INT);
 755 #ifndef SQLITE_OMIT_WSD
 756   Tcl_LinkVar(interp, "sqlite_pending_byte",
 757      (char*)&sqlite3PendingByte, TCL_LINK_INT | TCL_LINK_READ_ONLY);
 758 #endif
 759   return TCL_OK;
 760 }