PageRenderTime 39ms CodeModel.GetById 13ms RepoModel.GetById 0ms app.codeStats 0ms

/trunk/src/sqlite/test/multiplex.test

#
Unknown | 571 lines | 499 code | 72 blank | 0 comment | 0 complexity | f63bfa5e777e24f80bf3ddba7dd5b206 MD5 | raw file
Possible License(s): BSD-3-Clause
  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. set testdir [file dirname $argv0]
  13. source $testdir/tester.tcl
  14. source $testdir/malloc_common.tcl
  15. set g_chunk_size [ expr ($::SQLITE_MAX_PAGE_SIZE*16384) ]
  16. set g_max_chunks 32
  17. # This handles appending the chunk number
  18. # to the end of the filename. if
  19. # SQLITE_MULTIPLEX_EXT_OVWR is defined, then
  20. # it overwrites the last 2 bytes of the
  21. # file name with the chunk number.
  22. proc multiplex_name {name chunk} {
  23. if {$chunk==0} { return $name }
  24. set num [format "%02d" $chunk]
  25. ifcapable {multiplex_ext_overwrite} {
  26. set name [string range $name 0 [expr [string length $name]-2-1]]
  27. }
  28. return $name$num
  29. }
  30. # This saves off the parameters and calls the
  31. # underlying sqlite3_multiplex_control() API.
  32. proc multiplex_set {db name chunk_size max_chunks} {
  33. global g_chunk_size
  34. global g_max_chunks
  35. set g_chunk_size [ expr (($chunk_size+($::SQLITE_MAX_PAGE_SIZE-1)) & ~($::SQLITE_MAX_PAGE_SIZE-1)) ]
  36. set g_max_chunks $max_chunks
  37. set rc [catch {sqlite3_multiplex_control $db $name chunk_size $chunk_size} msg]
  38. if { $rc==0 } {
  39. set rc [catch {sqlite3_multiplex_control $db $name max_chunks $max_chunks} msg]
  40. }
  41. list $msg
  42. }
  43. # This attempts to delete the base file and
  44. # and files with the chunk extension.
  45. proc multiplex_delete {name} {
  46. global g_max_chunks
  47. for {set i 0} {$i<$g_max_chunks} {incr i} {
  48. forcedelete [multiplex_name $name $i]
  49. forcedelete [multiplex_name $name-journal $i]
  50. forcedelete [multiplex_name $name-wal $i]
  51. }
  52. }
  53. db close
  54. multiplex_delete test.db
  55. multiplex_delete test2.db
  56. #-------------------------------------------------------------------------
  57. # multiplex-1.1.*: Test initialize and shutdown.
  58. do_test multiplex-1.1 { sqlite3_multiplex_initialize nosuchvfs 1 } {SQLITE_ERROR}
  59. do_test multiplex-1.2 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
  60. do_test multiplex-1.3 { sqlite3_multiplex_initialize "" 1 } {SQLITE_MISUSE}
  61. do_test multiplex-1.4 { sqlite3_multiplex_shutdown } {SQLITE_OK}
  62. do_test multiplex-1.5 { sqlite3_multiplex_initialize "" 0 } {SQLITE_OK}
  63. do_test multiplex-1.6 { sqlite3_multiplex_shutdown } {SQLITE_OK}
  64. do_test multiplex-1.7 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
  65. do_test multiplex-1.8 { sqlite3_multiplex_shutdown } {SQLITE_OK}
  66. do_test multiplex-1.9.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
  67. do_test multiplex-1.9.2 { sqlite3 db test.db } {}
  68. do_test multiplex-1.9.3 { multiplex_set db main 32768 16 } {SQLITE_OK}
  69. do_test multiplex-1.9.4 { multiplex_set db main 32768 -1 } {SQLITE_MISUSE}
  70. do_test multiplex-1.9.5 { multiplex_set db main -1 16 } {SQLITE_MISUSE}
  71. do_test multiplex-1.9.6 { multiplex_set db main 31 16 } {SQLITE_OK}
  72. do_test multiplex-1.9.7 { multiplex_set db main 32768 100 } {SQLITE_MISUSE}
  73. do_test multiplex-1.9.8 { multiplex_set db main 1073741824 1 } {SQLITE_OK}
  74. do_test multiplex-1.9.9 { db close } {}
  75. do_test multiplex-1.9.10 { sqlite3_multiplex_shutdown } {SQLITE_OK}
  76. do_test multiplex-1.10.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
  77. do_test multiplex-1.10.2 { sqlite3 db test.db } {}
  78. do_test multiplex-1.10.3 { lindex [ catchsql { SELECT multiplex_control(2, 32768); } ] 0 } {0}
  79. do_test multiplex-1.10.4 { lindex [ catchsql { SELECT multiplex_control(3, -1); } ] 0 } {1}
  80. do_test multiplex-1.10.5 { lindex [ catchsql { SELECT multiplex_control(2, -1); } ] 0 } {1}
  81. do_test multiplex-1.10.6 { lindex [ catchsql { SELECT multiplex_control(2, 31); } ] 0 } {0}
  82. do_test multiplex-1.10.7 { lindex [ catchsql { SELECT multiplex_control(3, 100); } ] 0 } {1}
  83. do_test multiplex-1.10.8 { lindex [ catchsql { SELECT multiplex_control(2, 1073741824); } ] 0 } {0}
  84. do_test multiplex-1.10.9 { db close } {}
  85. do_test multiplex-1.10.10 { sqlite3_multiplex_shutdown } {SQLITE_OK}
  86. do_test multiplex-1.11.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
  87. do_test multiplex-1.11.2 { sqlite3 db test.db } {}
  88. do_test multiplex-1.11.3 { sqlite3_multiplex_control db main enable 0 } {SQLITE_OK}
  89. do_test multiplex-1.11.4 { sqlite3_multiplex_control db main enable 1 } {SQLITE_OK}
  90. do_test multiplex-1.11.5 { sqlite3_multiplex_control db main enable -1 } {SQLITE_OK}
  91. do_test multiplex-1.11.6 { db close } {}
  92. do_test multiplex-1.11.7 { sqlite3_multiplex_shutdown } {SQLITE_OK}
  93. do_test multiplex-1.12.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
  94. do_test multiplex-1.12.2 { sqlite3 db test.db } {}
  95. do_test multiplex-1.12.3 { lindex [ catchsql { SELECT multiplex_control(1, 0); } ] 0 } {0}
  96. do_test multiplex-1.12.4 { lindex [ catchsql { SELECT multiplex_control(1, 1); } ] 0 } {0}
  97. do_test multiplex-1.12.5 { lindex [ catchsql { SELECT multiplex_control(1, -1); } ] 0 } {0}
  98. do_test multiplex-1.12.6 { db close } {}
  99. do_test multiplex-1.12.7 { sqlite3_multiplex_shutdown } {SQLITE_OK}
  100. do_test multiplex-1.13.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
  101. do_test multiplex-1.13.2 { sqlite3 db test.db } {}
  102. do_test multiplex-1.13.3 { lindex [ catchsql { SELECT multiplex_control(-1, 0); } ] 0 } {1}
  103. do_test multiplex-1.13.4 { lindex [ catchsql { SELECT multiplex_control(4, 1); } ] 0 } {1}
  104. do_test multiplex-1.13.6 { db close } {}
  105. do_test multiplex-1.13.7 { sqlite3_multiplex_shutdown } {SQLITE_OK}
  106. #-------------------------------------------------------------------------
  107. # Some simple warm-body tests with a single database file in rollback
  108. # mode:
  109. #
  110. # multiplex-2.1.*: Test simple writing to a multiplex file.
  111. #
  112. # multiplex-2.2.*: More writing.
  113. #
  114. # multiplex-2.3.*: Open and close a second db.
  115. #
  116. # multiplex-2.4.*: Try to shutdown the multiplex system before closing the db
  117. # file. Check that this fails and the multiplex system still works
  118. # afterwards. Then close the database and successfully shut
  119. # down the multiplex system.
  120. #
  121. # multiplex-2.5.*: More reading/writing.
  122. #
  123. # multiplex-2.6.*: More reading/writing with varying small chunk sizes, as
  124. # well as varying journal mode.
  125. #
  126. # multiplex-2.7.*: Disable/enable tests.
  127. #
  128. sqlite3_multiplex_initialize "" 1
  129. multiplex_set db main 32768 16
  130. do_test multiplex-2.1.2 {
  131. sqlite3 db test.db
  132. execsql {
  133. PRAGMA page_size=1024;
  134. PRAGMA auto_vacuum=OFF;
  135. PRAGMA journal_mode=DELETE;
  136. }
  137. execsql {
  138. CREATE TABLE t1(a, b);
  139. INSERT INTO t1 VALUES(1, randomblob(1100));
  140. INSERT INTO t1 VALUES(2, randomblob(1100));
  141. }
  142. } {}
  143. do_test multiplex-2.1.3 { file size [multiplex_name test.db 0] } {4096}
  144. do_test multiplex-2.1.4 {
  145. execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
  146. } {}
  147. do_test multiplex-2.2.1 {
  148. execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
  149. } {}
  150. do_test multiplex-2.2.3 { file size [multiplex_name test.db 0] } {6144}
  151. do_test multiplex-2.3.1 {
  152. sqlite3 db2 test2.db
  153. db2 close
  154. } {}
  155. do_test multiplex-2.4.1 {
  156. sqlite3_multiplex_shutdown
  157. } {SQLITE_MISUSE}
  158. do_test multiplex-2.4.2 {
  159. execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
  160. } {}
  161. do_test multiplex-2.4.4 { file size [multiplex_name test.db 0] } {7168}
  162. do_test multiplex-2.4.99 {
  163. db close
  164. sqlite3_multiplex_shutdown
  165. } {SQLITE_OK}
  166. do_test multiplex-2.5.1 {
  167. multiplex_delete test.db
  168. sqlite3_multiplex_initialize "" 1
  169. sqlite3 db test.db
  170. multiplex_set db main 4096 16
  171. } {SQLITE_OK}
  172. do_test multiplex-2.5.2 {
  173. execsql {
  174. PRAGMA page_size = 1024;
  175. PRAGMA journal_mode = delete;
  176. PRAGMA auto_vacuum = off;
  177. CREATE TABLE t1(a PRIMARY KEY, b);
  178. }
  179. } {delete}
  180. do_test multiplex-2.5.3 {
  181. execsql {
  182. INSERT INTO t1 VALUES(1, 'one');
  183. INSERT INTO t1 VALUES(2, randomblob(4000));
  184. INSERT INTO t1 VALUES(3, 'three');
  185. INSERT INTO t1 VALUES(4, randomblob(4000));
  186. INSERT INTO t1 VALUES(5, 'five');
  187. INSERT INTO t1 VALUES(6, randomblob($g_chunk_size));
  188. INSERT INTO t1 VALUES(7, randomblob($g_chunk_size));
  189. }
  190. } {}
  191. do_test multiplex-2.5.4 {
  192. db eval {SELECT * FROM t1 WHERE a=1}
  193. } {1 one}
  194. do_test multiplex-2.5.5 {
  195. db eval {SELECT * FROM t1 WHERE a=3}
  196. } {3 three}
  197. do_test multiplex-2.5.6 {
  198. db eval {SELECT * FROM t1 WHERE a=5}
  199. } {5 five}
  200. do_test multiplex-2.5.7 {
  201. db eval {SELECT a,length(b) FROM t1 WHERE a=2}
  202. } {2 4000}
  203. do_test multiplex-2.5.8 {
  204. db eval {SELECT a,length(b) FROM t1 WHERE a=4}
  205. } {4 4000}
  206. do_test multiplex-2.5.9 { file size [multiplex_name test.db 0] } [list $g_chunk_size]
  207. do_test multiplex-2.5.10 { file size [multiplex_name test.db 1] } [list $g_chunk_size]
  208. do_test multiplex-2.5.99 {
  209. db close
  210. sqlite3_multiplex_shutdown
  211. } {SQLITE_OK}
  212. set all_journal_modes {delete persist truncate memory off}
  213. foreach jmode $all_journal_modes {
  214. for {set sz 151} {$sz<8000} {set sz [expr $sz+419]} {
  215. do_test multiplex-2.6.1.$sz.$jmode {
  216. multiplex_delete test.db
  217. sqlite3_multiplex_initialize "" 1
  218. sqlite3 db test.db
  219. multiplex_set db main $sz 32
  220. } {SQLITE_OK}
  221. do_test multiplex-2.6.2.$sz.$jmode {
  222. db eval {
  223. PRAGMA page_size = 1024;
  224. PRAGMA auto_vacuum = off;
  225. }
  226. db eval "PRAGMA journal_mode = $jmode;"
  227. } $jmode
  228. do_test multiplex-2.6.3.$sz.$jmode {
  229. execsql {
  230. CREATE TABLE t1(a PRIMARY KEY, b);
  231. INSERT INTO t1 VALUES(1, 'one');
  232. INSERT INTO t1 VALUES(2, randomblob($g_chunk_size));
  233. }
  234. } {}
  235. do_test multiplex-2.6.4.$sz.$jmode {
  236. db eval {SELECT b FROM t1 WHERE a=1}
  237. } {one}
  238. do_test multiplex-2.6.5.$sz.$jmode {
  239. db eval {SELECT length(b) FROM t1 WHERE a=2}
  240. } [list $g_chunk_size]
  241. do_test multiplex-2.6.6.$sz.$jmode { file size [multiplex_name test.db 0] } [list $g_chunk_size]
  242. do_test multiplex-2.6.99.$sz.$jmode {
  243. db close
  244. sqlite3_multiplex_shutdown
  245. } {SQLITE_OK}
  246. }
  247. }
  248. do_test multiplex-2.7.1 { multiplex_delete test.db } {}
  249. do_test multiplex-2.7.2 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
  250. do_test multiplex-2.7.3 { sqlite3 db test.db } {}
  251. do_test multiplex-2.7.4 { lindex [ catchsql { SELECT multiplex_control(2, 65536); } ] 0 } {0}
  252. do_test multiplex-2.7.5 { lindex [ catchsql { SELECT multiplex_control(1, 0); } ] 0 } {0}
  253. do_test multiplex-2.7.6 {
  254. execsql {
  255. CREATE TABLE t1(a PRIMARY KEY, b);
  256. INSERT INTO t1 VALUES(1, randomblob(1000));
  257. }
  258. } {}
  259. # verify only one file, and file size is less than chunks size
  260. do_test multiplex-2.7.7 { expr ([file size [multiplex_name test.db 0]] < 65536) } {1}
  261. do_test multiplex-2.7.8 { file exists [multiplex_name test.db 1] } {0}
  262. do_test multiplex-2.7.9 {
  263. execsql {
  264. INSERT INTO t1 VALUES(2, randomblob(65536));
  265. }
  266. } {}
  267. # verify only one file, and file size exceeds chunks size
  268. do_test multiplex-2.7.10 { expr ([file size [multiplex_name test.db 0]] > 65536) } {1}
  269. do_test multiplex-2.7.11 { file exists [multiplex_name test.db 1] } {0}
  270. do_test multiplex-2.7.12 { db close } {}
  271. do_test multiplex-2.7.13 { sqlite3_multiplex_shutdown } {SQLITE_OK}
  272. #-------------------------------------------------------------------------
  273. # Try some tests with more than one connection to a database file. Still
  274. # in rollback mode.
  275. #
  276. # multiplex-3.1.*: Two connections to a single database file.
  277. #
  278. # multiplex-3.2.*: Two connections to each of several database files (that
  279. # are in the same multiplex group).
  280. #
  281. do_test multiplex-3.1.1 {
  282. multiplex_delete test.db
  283. sqlite3_multiplex_initialize "" 1
  284. sqlite3 db test.db
  285. multiplex_set db main 32768 16
  286. } {SQLITE_OK}
  287. do_test multiplex-3.1.2 {
  288. execsql {
  289. PRAGMA page_size = 1024;
  290. PRAGMA journal_mode = delete;
  291. PRAGMA auto_vacuum = off;
  292. CREATE TABLE t1(a PRIMARY KEY, b);
  293. INSERT INTO t1 VALUES(1, 'one');
  294. }
  295. file size [multiplex_name test.db 0]
  296. } {3072}
  297. do_test multiplex-3.1.3 {
  298. sqlite3 db2 test.db
  299. execsql { CREATE TABLE t2(a, b) } db2
  300. } {}
  301. do_test multiplex-3.1.4 {
  302. execsql { CREATE TABLE t3(a, b) }
  303. } {}
  304. do_test multiplex-3.1.5 {
  305. catchsql { CREATE TABLE t3(a, b) }
  306. } {1 {table t3 already exists}}
  307. do_test multiplex-3.1.6 {
  308. db close
  309. db2 close
  310. } {}
  311. do_test multiplex-3.2.1a {
  312. multiplex_delete test.db
  313. multiplex_delete test2.db
  314. sqlite3 db1a test.db
  315. sqlite3 db2a test2.db
  316. foreach db {db1a db2a} {
  317. execsql {
  318. PRAGMA page_size = 1024;
  319. PRAGMA journal_mode = delete;
  320. PRAGMA auto_vacuum = off;
  321. CREATE TABLE t1(a, b);
  322. } $db
  323. }
  324. list [file size [multiplex_name test.db 0]] [file size [multiplex_name test2.db 0]]
  325. } {2048 2048}
  326. do_test multiplex-3.2.1b {
  327. sqlite3 db1b test.db
  328. sqlite3 db2b test2.db
  329. } {}
  330. do_test multiplex-3.2.2 { execsql { INSERT INTO t1 VALUES('x', 'y') } db1a } {}
  331. do_test multiplex-3.2.3 { execsql { INSERT INTO t1 VALUES('v', 'w') } db1b } {}
  332. do_test multiplex-3.2.4 { execsql { INSERT INTO t1 VALUES('t', 'u') } db2a } {}
  333. do_test multiplex-3.2.5 { execsql { INSERT INTO t1 VALUES('r', 's') } db2b } {}
  334. do_test multiplex-3.2.6 {
  335. execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a
  336. } {}
  337. do_test multiplex-3.2.7 {
  338. execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b
  339. } {}
  340. do_test multiplex-3.2.8 {
  341. execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a
  342. } {}
  343. do_test multiplex-3.2.9 {
  344. execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b
  345. } {}
  346. do_test multiplex-3.3.1 {
  347. execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a
  348. execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b
  349. execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a
  350. execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b
  351. } {}
  352. do_test multiplex-3.2.X {
  353. foreach db {db1a db2a db2b db1b} { catch { $db close } }
  354. } {}
  355. #-------------------------------------------------------------------------
  356. #
  357. sqlite3_multiplex_initialize "" 1
  358. multiplex_set db main 32768 16
  359. # Return a list of all currently defined multiplexs.
  360. proc multiplex_list {} {
  361. set allq {}
  362. foreach q [sqlite3_multiplex_dump] {
  363. lappend allq [lindex $q 0]
  364. }
  365. return [lsort $allq]
  366. }
  367. do_test multiplex-4.1.6 {
  368. multiplex_delete test2.db
  369. sqlite3 db test2.db
  370. db eval {CREATE TABLE t2(x); INSERT INTO t2 VALUES('tab-t2');}
  371. set res [multiplex_list]
  372. list [regexp {test2.db} $res]
  373. } {1}
  374. do_test multiplex-4.1.6a {
  375. sqlite3 db2 test2.db
  376. db2 eval {SELECT * FROM t2}
  377. } {tab-t2}
  378. do_test multiplex-4.1.7 {
  379. execsql {INSERT INTO t2 VALUES(zeroblob(200000))}
  380. } {}
  381. do_test multiplex-4.1.8 {
  382. sqlite3 db2 test2.db
  383. db2 eval {SELECT count(*) FROM t2}
  384. } {2}
  385. do_test multiplex-4.1.8a {
  386. db2 eval { DELETE FROM t2 WHERE x = 'tab-t2' }
  387. } {}
  388. do_test multiplex-4.1.8b {
  389. sqlite3 db2 test2.db
  390. db2 eval {SELECT count(*) FROM t2}
  391. } {1}
  392. do_test multiplex-4.1.9 {
  393. execsql {INSERT INTO t2 VALUES(zeroblob(200000))}
  394. } {}
  395. do_test multiplex-4.1.10 {
  396. set res [multiplex_list]
  397. list [regexp {test2.db} $res]
  398. } {1}
  399. do_test multiplex-4.1.11 {
  400. db2 close
  401. set res [multiplex_list]
  402. list [regexp {test2.db} $res]
  403. } {1}
  404. do_test multiplex-4.1.12 {
  405. db close
  406. multiplex_list
  407. } {}
  408. #-------------------------------------------------------------------------
  409. # The following tests test that the multiplex VFS handles malloc and IO
  410. # errors.
  411. #
  412. sqlite3_multiplex_initialize "" 1
  413. multiplex_set db main 32768 16
  414. do_faultsim_test multiplex-5.1 -prep {
  415. catch {db close}
  416. } -body {
  417. sqlite3 db test2.db
  418. }
  419. do_faultsim_test multiplex-5.2 -prep {
  420. catch {db close}
  421. } -body {
  422. sqlite3 db test.db
  423. }
  424. catch { db close }
  425. multiplex_delete test.db
  426. multiplex_delete test2.db
  427. do_test multiplex-5.3.prep {
  428. sqlite3 db test.db
  429. execsql {
  430. PRAGMA auto_vacuum = 1;
  431. PRAGMA page_size = 1024;
  432. CREATE TABLE t1(a, b);
  433. INSERT INTO t1 VALUES(10, zeroblob(1200));
  434. }
  435. faultsim_save_and_close
  436. } {}
  437. do_faultsim_test multiplex-5.3 -prep {
  438. faultsim_restore_and_reopen
  439. } -body {
  440. execsql { DELETE FROM t1 }
  441. }
  442. do_test multiplex-5.4.1 {
  443. catch { db close }
  444. multiplex_delete test.db
  445. file mkdir test.db
  446. list [catch { sqlite3 db test.db } msg] $msg
  447. } {1 {unable to open database file}}
  448. catch { file delete test.db }
  449. do_faultsim_test multiplex-5.5 -prep {
  450. catch { sqlite3_multiplex_shutdown }
  451. } -body {
  452. sqlite3_multiplex_initialize "" 1
  453. multiplex_set db main 32768 16
  454. }
  455. # test that mismatch filesize is detected
  456. #
  457. # Do not run this test if $::G(perm:presql) is set. If it is set, then the
  458. # expected IO error will occur within the Tcl [sqlite3] wrapper, not within
  459. # the first SQL statement executed below. This breaks the test case.
  460. #
  461. if {0==[info exists ::G(perm:presql)] || $::G(perm:presql) == ""} {
  462. set all_journal_modes {delete persist truncate memory off}
  463. foreach jmode $all_journal_modes {
  464. do_test multiplex-5.6.1.$jmode {
  465. sqlite3_multiplex_shutdown
  466. multiplex_delete test.db
  467. sqlite3 db test.db
  468. db eval {
  469. PRAGMA page_size = 1024;
  470. PRAGMA auto_vacuum = off;
  471. }
  472. db eval "PRAGMA journal_mode = $jmode;"
  473. } $jmode
  474. do_test multiplex-5.6.2.$jmode {
  475. execsql {
  476. CREATE TABLE t1(a, b);
  477. INSERT INTO t1 VALUES(1, randomblob(15000));
  478. INSERT INTO t1 VALUES(2, randomblob(15000));
  479. INSERT INTO t1 VALUES(3, randomblob(15000));
  480. INSERT INTO t1 VALUES(4, randomblob(15000));
  481. INSERT INTO t1 VALUES(5, randomblob(15000));
  482. }
  483. db close
  484. sqlite3_multiplex_initialize "" 1
  485. sqlite3 db test.db
  486. multiplex_set db main 4096 16
  487. } {SQLITE_OK}
  488. do_test multiplex-5.6.3.$jmode {
  489. catchsql {
  490. INSERT INTO t1 VALUES(6, randomblob(15000));
  491. }
  492. } {1 {disk I/O error}}
  493. do_test multiplex-5.6.4.$jmode {
  494. db close
  495. } {}
  496. }
  497. }
  498. catch { sqlite3_multiplex_shutdown }
  499. finish_test