Return to crashtest1.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test

Annotation of embedaddon/sqlite3/test/crashtest1.c, revision 1.1.1.1

1.1       misho       1: /*
                      2: ** This program tests the ability of SQLite database to recover from a crash.
                      3: ** This program runs under Unix only, but the results are applicable to all
                      4: ** systems.
                      5: **
                      6: ** The main process first constructs a test database, then starts creating
                      7: ** subprocesses that write to that database.  Each subprocess is killed off,
                      8: ** without a chance to clean up its database connection, after a random
                      9: ** delay.  This killing of the subprocesses simulates a crash or power
                     10: ** failure.  The next subprocess to open the database should rollback
                     11: ** whatever operation was in process at the time of the simulated crash.
                     12: **
                     13: ** If any problems are encountered, an error is reported and the test stops.
                     14: ** If no problems are seen after a large number of tests, we assume that
                     15: ** the rollback mechanism is working.
                     16: */
                     17: #include <stdio.h>
                     18: #include <unistd.h>
                     19: #include <sys/types.h>
                     20: #include <sys/wait.h>
                     21: #include <signal.h>
                     22: #include <stdlib.h>
                     23: #include <string.h>
                     24: #include <sched.h>
                     25: #include "sqlite.h"
                     26: 
                     27: static void do_some_sql(int parent){
                     28:   char *zErr;
                     29:   int rc = SQLITE_OK;
                     30:   sqlite *db;
                     31:   int cnt = 0;
                     32:   static char zBig[] = 
                     33:     "-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
                     34:     "-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
                     35: 
                     36:   if( access("./test.db-journal",0)==0 ){
                     37:     /*printf("pid %d: journal exists.  rollback will be required\n",getpid());*/    unlink("test.db-saved");
                     38:     system("cp test.db test.db-saved");
                     39:     unlink("test.db-journal-saved");
                     40:     system("cp test.db-journal test.db-journal-saved");
                     41:   }
                     42:   db = sqlite_open("./test.db", 0, &zErr);
                     43:   if( db==0 ){
                     44:     printf("ERROR: %s\n", zErr);
                     45:     if( strcmp(zErr,"database disk image is malformed")==0 ){
                     46:       kill(parent, SIGKILL);
                     47:     }
                     48:     exit(1);
                     49:   }
                     50:   srand(getpid());
                     51:   while( rc==SQLITE_OK ){
                     52:     cnt++;
                     53:     rc = sqlite_exec_printf(db, 
                     54:        "INSERT INTO t1 VALUES(%d,'%d%s')", 0, 0, &zErr,
                     55:        rand(), rand(), zBig);
                     56:   }
                     57:   if( rc!=SQLITE_OK ){
                     58:     printf("ERROR #%d: %s\n", rc, zErr);
                     59:     if( rc==SQLITE_CORRUPT ){
                     60:       kill(parent, SIGKILL);
                     61:     }
                     62:   }
                     63:   printf("pid %d: cnt=%d\n", getpid(), cnt);
                     64: }
                     65: 
                     66: 
                     67: int main(int argc, char **argv){
                     68:   int i;
                     69:   sqlite *db;
                     70:   char *zErr;
                     71:   int status;
                     72:   int parent = getpid();
                     73: 
                     74:   unlink("test.db");
                     75:   unlink("test.db-journal");
                     76:   db = sqlite_open("test.db", 0, &zErr);
                     77:   if( db==0 ){
                     78:     printf("Cannot initialize: %s\n", zErr);
                     79:     return 1;
                     80:   }
                     81:   sqlite_exec(db, "CREATE TABLE t1(a,b)", 0, 0, 0);
                     82:   sqlite_close(db);
                     83:   for(i=0; i<10000; i++){
                     84:     int pid = fork();
                     85:     if( pid==0 ){
                     86:       sched_yield();
                     87:       do_some_sql(parent);
                     88:       return 0;
                     89:     }
                     90:     printf("test %d, pid=%d\n", i, pid);
                     91:     usleep(rand()%10000 + 1000);
                     92:     kill(pid, SIGKILL);
                     93:     waitpid(pid, &status, 0);
                     94:   }
                     95:   return 0;
                     96: }