test/multiplex.test

   1 # 2010 October 29
   2 #
   3 # The author disclaims copyright to this source code.  In place of
   4 # a legal notice, here is a blessing:
   5 #
   6 #    May you do good and not evil.
   7 #    May you find forgiveness for yourself and forgive others.
   8 #    May you share freely, never taking more than you give.
   9 #
  10 #***********************************************************************
  11 #
  12
  13 set testdir [file dirname $argv0]
  14 source $testdir/tester.tcl
  15 source $testdir/malloc_common.tcl
  16
  17 # The tests in this file assume that SQLite is compiled without
  18 # ENABLE_8_3_NAMES.
  19 #
  20 ifcapable 8_3_names {
  21   puts -nonewline "SQLite compiled with SQLITE_ENABLE_8_3_NAMES. "
  22   puts            "Skipping tests multiplex-*."
  23   finish_test
  24   return
  25 }
  26
  27 set g_chunk_size [ expr ($::SQLITE_MAX_PAGE_SIZE*16384) ]
  28 set g_max_chunks 32
  29
  30 # This handles appending the chunk number
  31 # to the end of the filename.  if
  32 # SQLITE_MULTIPLEX_EXT_OVWR is defined, then
  33 # it overwrites the last 2 bytes of the
  34 # file name with the chunk number.
  35 proc multiplex_name {name chunk} {
  36   if {$chunk==0} { return $name }
  37   set num [format "%03d" $chunk]
  38   ifcapable {multiplex_ext_overwrite} {
  39     set name [string range $name 0 [expr [string length $name]-2-1]]
  40   }
  41   return $name$num
  42 }
  43
  44 # This saves off the parameters and calls the
  45 # underlying sqlite3_multiplex_control() API.
  46 proc multiplex_set {db name chunk_size max_chunks} {
  47   global g_chunk_size
  48   global g_max_chunks
  49   set g_chunk_size [ expr (($chunk_size+($::SQLITE_MAX_PAGE_SIZE-1)) & ~($::SQLITE_MAX_PAGE_SIZE-1)) ]
  50   set g_max_chunks $max_chunks
  51   set rc [catch {sqlite3_multiplex_control $db $name chunk_size $chunk_size} msg]
  52   if { $rc==0 } {
  53     set rc [catch {sqlite3_multiplex_control $db $name max_chunks $max_chunks} msg]
  54   }
  55   list $msg
  56 }
  57
  58 # This attempts to delete the base file and
  59 # and files with the chunk extension.
  60 proc multiplex_delete {name} {
  61   global g_max_chunks
  62   forcedelete $name
  63   for {set i 0} {$i<$g_max_chunks} {incr i} {
  64     forcedelete [multiplex_name $name $i]
  65     forcedelete [multiplex_name $name-journal $i]
  66     forcedelete [multiplex_name $name-wal $i]
  67   }
  68 }
  69
  70 db close
  71 sqlite3_shutdown
  72 test_sqlite3_log xLog
  73 proc xLog {error_code msg} {
  74   lappend ::log $error_code $msg
  75 }
  76 unset -nocomplain log
  77
  78 multiplex_delete test.db
  79 multiplex_delete test2.db
  80
  81 #-------------------------------------------------------------------------
  82 #   multiplex-1.1.*: Test initialize and shutdown.
  83
  84 do_test multiplex-1.1 { sqlite3_multiplex_initialize nosuchvfs 1 } {SQLITE_ERROR}
  85 do_test multiplex-1.2 { sqlite3_multiplex_initialize "" 1 }        {SQLITE_OK}
  86 do_test multiplex-1.3 { sqlite3_multiplex_initialize "" 1 }        {SQLITE_MISUSE}
  87 do_test multiplex-1.4 { sqlite3_multiplex_shutdown }               {SQLITE_OK}
  88
  89 do_test multiplex-1.5 { sqlite3_multiplex_initialize "" 0 }        {SQLITE_OK}
  90 do_test multiplex-1.6 { sqlite3_multiplex_shutdown }               {SQLITE_OK}
  91 do_test multiplex-1.7 { sqlite3_multiplex_initialize "" 1 }        {SQLITE_OK}
  92 do_test multiplex-1.8 { sqlite3_multiplex_shutdown }               {SQLITE_OK}
  93
  94
  95 do_test multiplex-1.9.1  { sqlite3_multiplex_initialize "" 1 }     {SQLITE_OK}
  96 do_test multiplex-1.9.2  { sqlite3 db test.db }                    {}
  97 do_test multiplex-1.9.3  { multiplex_set db main 32768 16 }        {SQLITE_OK}
  98 do_test multiplex-1.9.4  { multiplex_set db main 32768 -1 }        {SQLITE_OK}
  99 do_test multiplex-1.9.6  { multiplex_set db main 31 16 }           {SQLITE_OK}
 100 do_test multiplex-1.9.7  { multiplex_set db main 32768 100 }       {SQLITE_OK}
 101 do_test multiplex-1.9.8  { multiplex_set db main 1073741824 1 }    {SQLITE_OK}
 102 do_test multiplex-1.9.9  { db close }                              {}
 103 do_test multiplex-1.9.10 { sqlite3_multiplex_shutdown }            {SQLITE_OK}
 104
 105 do_test multiplex-1.10.1  { sqlite3_multiplex_initialize "" 1 }                                  {SQLITE_OK}
 106 do_test multiplex-1.10.2  { sqlite3 db test.db }                                                 {}
 107 do_test multiplex-1.10.3  { lindex [ catchsql { SELECT multiplex_control(2, 32768); } ] 0 }      {0}
 108 do_test multiplex-1.10.4  { lindex [ catchsql { SELECT multiplex_control(3, -1); } ] 0 }         {0}
 109 do_test multiplex-1.10.6  { lindex [ catchsql { SELECT multiplex_control(2, 31); } ] 0 }         {0}
 110 do_test multiplex-1.10.7  { lindex [ catchsql { SELECT multiplex_control(3, 100); } ] 0 }        {0}
 111 do_test multiplex-1.10.8  { lindex [ catchsql { SELECT multiplex_control(2, 1073741824); } ] 0 } {0}
 112 do_test multiplex-1.10.9  { db close }                                                           {}
 113 do_test multiplex-1.10.10 { sqlite3_multiplex_shutdown }                                         {SQLITE_OK}
 114
 115 do_test multiplex-1.11.1  { sqlite3_multiplex_initialize "" 1 }               {SQLITE_OK}
 116 do_test multiplex-1.11.2  { sqlite3 db test.db }                              {}
 117 do_test multiplex-1.11.3  { sqlite3_multiplex_control db main enable 0  }     {SQLITE_OK}
 118 do_test multiplex-1.11.4  { sqlite3_multiplex_control db main enable 1  }     {SQLITE_OK}
 119 do_test multiplex-1.11.5  { sqlite3_multiplex_control db main enable -1 }     {SQLITE_OK}
 120 do_test multiplex-1.11.6  { db close }                                        {}
 121 do_test multiplex-1.11.7  { sqlite3_multiplex_shutdown }                      {SQLITE_OK}
 122
 123 do_test multiplex-1.12.1  { sqlite3_multiplex_initialize "" 1 }                           {SQLITE_OK}
 124 do_test multiplex-1.12.2  { sqlite3 db test.db }                                          {}
 125 do_test multiplex-1.12.3  { lindex [ catchsql { SELECT multiplex_control(1, 0); } ] 0 }   {0}
 126 do_test multiplex-1.12.4  { lindex [ catchsql { SELECT multiplex_control(1, 1); } ] 0 }   {0}
 127 do_test multiplex-1.12.5  { lindex [ catchsql { SELECT multiplex_control(1, -1); } ] 0 }  {0}
 128 do_test multiplex-1.12.6  { db close }                                                    {}
 129 do_test multiplex-1.12.7  { sqlite3_multiplex_shutdown }                                  {SQLITE_OK}
 130
 131 do_test multiplex-1.13.1  { sqlite3_multiplex_initialize "" 1 }                           {SQLITE_OK}
 132 do_test multiplex-1.13.2  { sqlite3 db test.db }                                          {}
 133 do_test multiplex-1.13.3  { lindex [ catchsql { SELECT multiplex_control(-1, 0); } ] 0 }  {1}
 134 do_test multiplex-1.13.4  { lindex [ catchsql { SELECT multiplex_control(4, 1); } ] 0 }   {1}
 135 do_test multiplex-1.13.6  { db close }                                                    {}
 136 do_test multiplex-1.13.7  { sqlite3_multiplex_shutdown }                                  {SQLITE_OK}
 137
 138 #-------------------------------------------------------------------------
 139 # Some simple warm-body tests with a single database file in rollback
 140 # mode:
 141 #
 142 #   multiplex-2.1.*: Test simple writing to a multiplex file.
 143 #
 144 #   multiplex-2.2.*: More writing.
 145 #
 146 #   multiplex-2.3.*: Open and close a second db.
 147 #
 148 #   multiplex-2.4.*: Try to shutdown the multiplex system before closing the db
 149 #                file. Check that this fails and the multiplex system still works
 150 #                afterwards. Then close the database and successfully shut
 151 #                down the multiplex system.
 152 #
 153 #   multiplex-2.5.*: More reading/writing.
 154 #
 155 #   multiplex-2.6.*: More reading/writing with varying small chunk sizes, as
 156 #                well as varying journal mode.
 157 #
 158 #   multiplex-2.7.*: Disable/enable tests.
 159 #
 160
 161 sqlite3_multiplex_initialize "" 1
 162 multiplex_set db main 32768 16
 163
 164 forcedelete test.x
 165 foreach f [glob -nocomplain {test.x*[0-9][0-9][0-9]}] {
 166   forcedelete $f
 167 }
 168 do_test multiplex-2.1.2 {
 169   sqlite3 db test.x
 170   execsql {
 171     PRAGMA page_size=1024;
 172     PRAGMA auto_vacuum=OFF;
 173     PRAGMA journal_mode=DELETE;
 174   }
 175   execsql {
 176     CREATE TABLE t1(a, b);
 177     INSERT INTO t1 VALUES(1, randomblob(1100));
 178     INSERT INTO t1 VALUES(2, randomblob(1100));
 179   }
 180 } {}
 181 do_test multiplex-2.1.3 { file size [multiplex_name test.x 0] } {4096}
 182 do_test multiplex-2.1.4 {
 183   execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
 184 } {}
 185 do_execsql_test multiplex-2.1.5 {
 186   PRAGMA multiplex_enabled;
 187   PRAGMA multiplex_filecount;
 188   PRAGMA multiplex_chunksize;
 189 } {1 1 2147418112}
 190
 191 do_test multiplex-2.2.1 {
 192   execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
 193 } {}
 194 do_test multiplex-2.2.3 { file size [multiplex_name test.x 0] } {6144}
 195
 196 do_test multiplex-2.3.1 {
 197   sqlite3 db2 test2.x
 198   db2 close
 199 } {}
 200
 201
 202 unset -nocomplain ::log
 203 #do_test multiplex-2.4.1 {
 204 #  sqlite3_multiplex_shutdown
 205 #} {SQLITE_MISUSE}
 206 do_test multiplex-2.4.2 {
 207   execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
 208 } {}
 209 #do_test multiplex-2.4.3 {
 210 #  set ::log
 211 #} {SQLITE_MISUSE {sqlite3_multiplex_shutdown() called while database connections are still open}}
 212
 213 do_test multiplex-2.4.4 { file size [multiplex_name test.x 0] } {7168}
 214 do_test multiplex-2.4.5 {
 215   db close
 216   sqlite3 db test.x
 217   db eval vacuum
 218   db close
 219   glob test.x*
 220 } {test.x}
 221 do_test multiplex-2.4.99 {
 222   sqlite3_multiplex_shutdown
 223 } {SQLITE_OK}
 224
 225 do_test multiplex-2.5.1 {
 226   multiplex_delete test.x
 227   sqlite3_multiplex_initialize "" 1
 228   sqlite3 db test.x
 229   multiplex_set db main 4096 16
 230 } {SQLITE_OK}
 231
 232 do_test multiplex-2.5.2 {
 233   execsql {
 234     PRAGMA page_size = 1024;
 235     PRAGMA journal_mode = delete;
 236     PRAGMA auto_vacuum = off;
 237     CREATE TABLE t1(a PRIMARY KEY, b);
 238   }
 239 } {delete}
 240
 241 do_test multiplex-2.5.3 {
 242   execsql {
 243     INSERT INTO t1 VALUES(1, 'one');
 244     INSERT INTO t1 VALUES(2, randomblob(4000));
 245     INSERT INTO t1 VALUES(3, 'three');
 246     INSERT INTO t1 VALUES(4, randomblob(4000));
 247     INSERT INTO t1 VALUES(5, 'five');
 248     INSERT INTO t1 VALUES(6, randomblob($g_chunk_size));
 249     INSERT INTO t1 VALUES(7, randomblob($g_chunk_size));
 250   }
 251 } {}
 252
 253 do_test multiplex-2.5.4 {
 254   db eval {SELECT * FROM t1 WHERE a=1}
 255 } {1 one}
 256
 257 do_test multiplex-2.5.5 {
 258   db eval {SELECT * FROM t1 WHERE a=3}
 259 } {3 three}
 260
 261 do_test multiplex-2.5.6 {
 262   db eval {SELECT * FROM t1 WHERE a=5}
 263 } {5 five}
 264
 265 do_test multiplex-2.5.7 {
 266   db eval {SELECT a,length(b) FROM t1 WHERE a=2}
 267 } {2 4000}
 268
 269 do_test multiplex-2.5.8 {
 270   db eval {SELECT a,length(b) FROM t1 WHERE a=4}
 271 } {4 4000}
 272
 273 do_test multiplex-2.5.9 { file size [multiplex_name test.x 0] } [list $g_chunk_size]
 274 do_test multiplex-2.5.10 { file size [multiplex_name test.x 1] } [list $g_chunk_size]
 275 do_execsql_test multiplex-2.5.11 {
 276   PRAGMA multiplex_enabled;
 277   PRAGMA multiplex_filecount;
 278   PRAGMA multiplex_chunksize;
 279 } {1 3 65536}
 280 sqlite3 db test.x
 281 do_execsql_test multiplex-2.5.12 {
 282   PRAGMA multiplex_filecount;
 283   PRAGMA multiplex_chunksize;
 284 } {3 65536}
 285
 286
 287
 288 do_test multiplex-2.5.99 {
 289   db close
 290   sqlite3_multiplex_shutdown
 291 } {SQLITE_OK}
 292
 293
 294 set all_journal_modes {delete persist truncate memory off}
 295 foreach jmode $all_journal_modes {
 296   for {set sz 151} {$sz<8000} {set sz [expr $sz+419]} {
 297
 298     do_test multiplex-2.6.1.$sz.$jmode {
 299       multiplex_delete test.db
 300       sqlite3_multiplex_initialize "" 1
 301       sqlite3 db test.db
 302       multiplex_set db main $sz 32
 303     } {SQLITE_OK}
 304
 305     do_test multiplex-2.6.2.$sz.$jmode {
 306       db eval {
 307         PRAGMA page_size = 1024;
 308         PRAGMA auto_vacuum = off;
 309       }
 310       db eval "PRAGMA journal_mode = $jmode;"
 311     } $jmode
 312
 313     do_test multiplex-2.6.3.$sz.$jmode {
 314       execsql {
 315         CREATE TABLE t1(a PRIMARY KEY, b);
 316         INSERT INTO t1 VALUES(1, 'one');
 317         INSERT INTO t1 VALUES(2, randomblob($g_chunk_size));
 318       }
 319     } {}
 320
 321     do_test multiplex-2.6.4.$sz.$jmode {
 322       db eval {SELECT b FROM t1 WHERE a=1}
 323     } {one}
 324
 325     do_test multiplex-2.6.5.$sz.$jmode {
 326       db eval {SELECT length(b) FROM t1 WHERE a=2}
 327     } [list $g_chunk_size]
 328
 329     do_test multiplex-2.6.6.$sz.$jmode { file size [multiplex_name test.db 0] } [list $g_chunk_size]
 330
 331     do_test multiplex-2.6.99.$sz.$jmode {
 332       db close
 333       sqlite3_multiplex_shutdown
 334     } {SQLITE_OK}
 335
 336   }
 337 }
 338
 339 do_test multiplex-2.7.1  { multiplex_delete test.db }                                       {}
 340 do_test multiplex-2.7.2  { sqlite3_multiplex_initialize "" 1 }                              {SQLITE_OK}
 341 do_test multiplex-2.7.3  { sqlite3 db test.db }                                             {}
 342 do_test multiplex-2.7.4  { lindex [ catchsql { SELECT multiplex_control(2, 65536); } ] 0 }  {0}
 343 do_test multiplex-2.7.5  { lindex [ catchsql { SELECT multiplex_control(1, 0); } ] 0 }      {0}
 344 do_test multiplex-2.7.6 {
 345   execsql {
 346     CREATE TABLE t1(a PRIMARY KEY, b);
 347     INSERT INTO t1 VALUES(1, randomblob(1000));
 348   }
 349 } {}
 350 # verify only one file, and file size is less than chunks size
 351 do_test multiplex-2.7.7  { expr ([file size [multiplex_name test.db 0]] < 65536) } {1}
 352 do_test multiplex-2.7.8  { file exists [multiplex_name test.db 1] }                {0}
 353 do_test multiplex-2.7.9 {
 354   execsql {
 355     INSERT INTO t1 VALUES(2, randomblob(65536));
 356   }
 357 } {}
 358 # verify only one file, and file size exceeds chunks size
 359 do_test multiplex-2.7.10 { expr ([file size [multiplex_name test.db 0]] > 65536) } {1}
 360 do_test multiplex-2.7.11 { file exists [multiplex_name test.db 1] }                {0}
 361 do_test multiplex-2.7.12 { db close }                                              {}
 362 do_test multiplex-2.7.13 { sqlite3_multiplex_shutdown }                            {SQLITE_OK}
 363
 364 #-------------------------------------------------------------------------
 365 # Try some tests with more than one connection to a database file. Still
 366 # in rollback mode.
 367 #
 368 #   multiplex-3.1.*: Two connections to a single database file.
 369 #
 370 #   multiplex-3.2.*: Two connections to each of several database files (that
 371 #                are in the same multiplex group).
 372 #
 373 do_test multiplex-3.1.1 {
 374   multiplex_delete test.db
 375   sqlite3_multiplex_initialize "" 1
 376   sqlite3 db test.db
 377   multiplex_set db main 32768 16
 378 } {SQLITE_OK}
 379 do_test multiplex-3.1.2 {
 380   execsql {
 381     PRAGMA page_size = 1024;
 382     PRAGMA journal_mode = delete;
 383     PRAGMA auto_vacuum = off;
 384     CREATE TABLE t1(a PRIMARY KEY, b);
 385     INSERT INTO t1 VALUES(1, 'one');
 386   }
 387   file size [multiplex_name test.db 0]
 388 } {3072}
 389 do_test multiplex-3.1.3 {
 390   sqlite3 db2 test.db
 391   execsql { CREATE TABLE t2(a, b) } db2
 392 } {}
 393 do_test multiplex-3.1.4 {
 394   execsql { CREATE TABLE t3(a, b) }
 395 } {}
 396 do_test multiplex-3.1.5 {
 397   catchsql { CREATE TABLE t3(a, b) }
 398 } {1 {table t3 already exists}}
 399 do_test multiplex-3.1.6 {
 400   db close
 401   db2 close
 402 } {}
 403
 404 do_test multiplex-3.2.1a {
 405
 406   multiplex_delete test.db
 407   multiplex_delete test2.db
 408
 409   sqlite3 db1a test.db
 410   sqlite3 db2a test2.db
 411
 412   foreach db {db1a db2a} {
 413     execsql {
 414       PRAGMA page_size = 1024;
 415       PRAGMA journal_mode = delete;
 416       PRAGMA auto_vacuum = off;
 417       CREATE TABLE t1(a, b);
 418     } $db
 419   }
 420
 421   list [file size [multiplex_name test.db 0]] [file size [multiplex_name test2.db 0]]
 422 } {2048 2048}
 423
 424 do_test multiplex-3.2.1b {
 425   sqlite3 db1b test.db
 426   sqlite3 db2b test2.db
 427 } {}
 428
 429 do_test multiplex-3.2.2 { execsql { INSERT INTO t1 VALUES('x', 'y') } db1a } {}
 430 do_test multiplex-3.2.3 { execsql { INSERT INTO t1 VALUES('v', 'w') } db1b } {}
 431 do_test multiplex-3.2.4 { execsql { INSERT INTO t1 VALUES('t', 'u') } db2a } {}
 432 do_test multiplex-3.2.5 { execsql { INSERT INTO t1 VALUES('r', 's') } db2b } {}
 433
 434 do_test multiplex-3.2.6 {
 435   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a
 436 } {}
 437 do_test multiplex-3.2.7 {
 438   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b
 439 } {}
 440 do_test multiplex-3.2.8 {
 441   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a
 442 } {}
 443 do_test multiplex-3.2.9 {
 444   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b
 445 } {}
 446
 447 do_test multiplex-3.3.1 {
 448   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a
 449   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b
 450   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a
 451   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b
 452 } {}
 453
 454 do_test multiplex-3.2.X {
 455   foreach db {db1a db2a db2b db1b} { catch { $db close } }
 456 } {}
 457
 458 #-------------------------------------------------------------------------
 459 #
 460
 461 sqlite3_multiplex_initialize "" 1
 462 multiplex_set db main 32768 16
 463
 464 # Return a list of all currently defined multiplexs.
 465 proc multiplex_list {} {
 466   glob -nocomplain test2.db*
 467 }
 468
 469 do_test multiplex-4.1.6 {
 470   multiplex_delete test2.db
 471   sqlite3 db test2.db
 472   db eval {CREATE TABLE t2(x); INSERT INTO t2 VALUES('tab-t2');}
 473   set res [multiplex_list]
 474   list [regexp {test2.db} $res]
 475 } {1}
 476 do_test multiplex-4.1.6a {
 477   sqlite3 db2 test2.db
 478   db2 eval {SELECT * FROM t2}
 479 } {tab-t2}
 480 do_test multiplex-4.1.7 {
 481   execsql {INSERT INTO t2 VALUES(zeroblob(200000))}
 482 } {}
 483 do_test multiplex-4.1.8 {
 484   sqlite3 db2 test2.db
 485   db2 eval {SELECT count(*) FROM t2}
 486 } {2}
 487 do_test multiplex-4.1.8a {
 488    db2 eval { DELETE FROM t2 WHERE x = 'tab-t2' }
 489 } {}
 490 do_test multiplex-4.1.8b {
 491   sqlite3 db2 test2.db
 492   db2 eval {SELECT count(*) FROM t2}
 493 } {1}
 494
 495
 496 do_test multiplex-4.1.9 {
 497   execsql {INSERT INTO t2 VALUES(zeroblob(200000))}
 498 } {}
 499 do_test multiplex-4.1.10 {
 500   set res [multiplex_list]
 501   list [regexp {test2.db} $res]
 502 } {1}
 503 do_test multiplex-4.1.11 {
 504   db2 close
 505   set res [multiplex_list]
 506   list [regexp {test2.db} $res]
 507 } {1}
 508 do_test multiplex-4.1.12 {
 509   db close
 510   multiplex_list
 511 } {test2.db}
 512
 513
 514 #-------------------------------------------------------------------------
 515 # The following tests test that the multiplex VFS handles malloc and IO
 516 # errors.
 517 #
 518
 519 sqlite3_multiplex_initialize "" 1
 520 multiplex_set db main 32768 16
 521
 522 do_faultsim_test multiplex-5.1 -prep {
 523   catch {db close}
 524 } -body {
 525   sqlite3 db test2.db
 526 }
 527 do_faultsim_test multiplex-5.2 -prep {
 528   catch {db close}
 529 } -body {
 530   sqlite3 db test.db
 531 }
 532
 533 catch { db close }
 534 multiplex_delete test.db
 535 multiplex_delete test2.db
 536
 537 do_test multiplex-5.3.prep {
 538   sqlite3 db test.db
 539   execsql {
 540     PRAGMA auto_vacuum = 1;
 541     PRAGMA page_size = 1024;
 542     CREATE TABLE t1(a, b);
 543     INSERT INTO t1 VALUES(10, zeroblob(1200));
 544   }
 545   faultsim_save_and_close
 546 } {}
 547 do_faultsim_test multiplex-5.3 -prep {
 548   faultsim_restore_and_reopen
 549 } -body {
 550   execsql { DELETE FROM t1 }
 551 }
 552
 553 do_test multiplex-5.4.1 {
 554   catch { db close }
 555   multiplex_delete test.db
 556   file mkdir test.db
 557   list [catch { sqlite3 db test.db } msg] $msg
 558 } {1 {unable to open database file}}
 559 catch { delete_file test.db }
 560
 561 do_faultsim_test multiplex-5.5 -prep {
 562   catch { sqlite3_multiplex_shutdown }
 563 } -body {
 564   sqlite3_multiplex_initialize "" 1
 565   multiplex_set db main 32768 16
 566 }
 567
 568 #-------------------------------------------------------------------------
 569 # Test that you can vacuum a multiplex'ed DB.
 570
 571 ifcapable vacuum {
 572
 573 sqlite3_multiplex_shutdown
 574 do_test multiplex-6.0.0 {
 575   multiplex_delete test.db
 576   multiplex_delete test.x
 577   sqlite3_multiplex_initialize "" 1
 578   sqlite3 db test.x
 579   multiplex_set db main 4096 16
 580 } {SQLITE_OK}
 581
 582 do_test multiplex-6.1.0 {
 583   execsql {
 584     PRAGMA page_size=1024;
 585     PRAGMA journal_mode=DELETE;
 586     PRAGMA auto_vacuum=OFF;
 587   }
 588   execsql {
 589     CREATE TABLE t1(a, b);
 590     INSERT INTO t1 VALUES(1, randomblob($g_chunk_size));
 591     INSERT INTO t1 VALUES(2, randomblob($g_chunk_size));
 592   }
 593 } {}
 594 do_test multiplex-6.2.1 { file size [multiplex_name test.x 0] } [list $g_chunk_size]
 595 do_test multiplex-6.2.2 { file size [multiplex_name test.x 1] } [list $g_chunk_size]
 596
 597 do_test multiplex-6.3.0 {
 598   execsql { VACUUM }
 599 } {}
 600
 601 do_test multiplex-6.99 {
 602   db close
 603   multiplex_delete test.x
 604   sqlite3_multiplex_shutdown
 605 } {SQLITE_OK}
 606
 607 }
 608
 609
 610 catch { db close }
 611 catch { sqlite3_multiplex_shutdown }
 612 sqlite3_shutdown
 613 test_sqlite3_log
 614 sqlite3_initialize
 615 finish_test