/trunk/test/incrvacuum.test |
@@ -0,0 +1,786 @@ |
# 2007 April 26 |
# |
# The author disclaims copyright to this source code. In place of |
# a legal notice, here is a blessing: |
# |
# May you do good and not evil. |
# May you find forgiveness for yourself and forgive others. |
# May you share freely, never taking more than you give. |
# |
#*********************************************************************** |
# This file implements regression tests for SQLite library. The |
# focus of this file is testing the incremental vacuum feature. |
# |
# Note: There are also some tests for incremental vacuum and IO |
# errors in incrvacuum_ioerr.test. |
# |
# $Id: incrvacuum.test,v 1.23 2009/02/18 20:31:18 drh Exp $ |
|
set testdir [file dirname $argv0] |
source $testdir/tester.tcl |
|
# If this build of the library does not support auto-vacuum, omit this |
# whole file. |
ifcapable {!autovacuum || !pragma} { |
finish_test |
return |
} |
|
#--------------------------------------------------------------------- |
# Test the pragma on an empty database. |
# |
do_test incrvacuum-1.1 { |
execsql { |
pragma auto_vacuum; |
} |
} $sqlite_options(default_autovacuum) |
do_test incrvacuum-1.2.0 { |
# File size is sometimes 1 instead of 0 due to the hack we put in |
# to work around ticket #3260. Search for comments on #3260 in |
# os_unix.c. |
expr {[file size test.db] > 1} |
} {0} |
do_test incrvacuum-1.2 { |
# This command will create the database. |
execsql { |
pragma auto_vacuum = 'full'; |
pragma auto_vacuum; |
} |
} {1} |
do_test incrvacuum-1.2.1 { |
expr {[file size test.db] > 0} |
} {1} |
do_test incrvacuum-1.3 { |
execsql { |
pragma auto_vacuum = 'incremental'; |
pragma auto_vacuum; |
} |
} {2} |
do_test incrvacuum-1.4 { |
# In this case the invalid value is ignored and the auto_vacuum |
# setting remains unchanged. |
execsql { |
pragma auto_vacuum = 'invalid'; |
pragma auto_vacuum; |
} |
} {2} |
do_test incrvacuum-1.5 { |
execsql { |
pragma auto_vacuum = 1; |
pragma auto_vacuum; |
} |
} {1} |
do_test incrvacuum-1.6 { |
execsql { |
pragma auto_vacuum = '2'; |
pragma auto_vacuum; |
} |
} {2} |
do_test incrvacuum-1.7 { |
# Invalid value. auto_vacuum setting remains unchanged. |
execsql { |
pragma auto_vacuum = 5; |
pragma auto_vacuum; |
} |
} {2} |
|
#--------------------------------------------------------------------- |
# Test the pragma on a non-empty database. It is possible to toggle |
# the connection between "full" and "incremental" mode, but not to |
# change from either of these to "none", or from "none" to "full" or |
# "incremental". |
# |
do_test incrvacuum-2.1 { |
execsql { |
pragma auto_vacuum = 1; |
CREATE TABLE abc(a, b, c); |
} |
} {} |
do_test incrvacuum-2.2 { |
execsql { |
pragma auto_vacuum = 'none'; |
pragma auto_vacuum; |
} |
} {1} |
do_test incrvacuum-2.2.1 { |
db close |
sqlite3 db test.db |
execsql { |
pragma auto_vacuum; |
} |
} {1} |
do_test incrvacuum-2.3 { |
execsql { |
pragma auto_vacuum = 'incremental'; |
pragma auto_vacuum; |
} |
} {2} |
do_test incrvacuum-2.4 { |
execsql { |
pragma auto_vacuum = 'full'; |
pragma auto_vacuum; |
} |
} {1} |
|
#--------------------------------------------------------------------- |
# Test that when the auto_vacuum mode is "incremental", the database |
# does not shrink when pages are removed from it. But it does if |
# the mode is set to "full". |
# |
do_test incrvacuum-3.1 { |
execsql { |
pragma auto_vacuum; |
} |
} {1} |
do_test incrvacuum-3.2 { |
set ::str [string repeat 1234567890 110] |
execsql { |
PRAGMA auto_vacuum = 2; |
BEGIN; |
CREATE TABLE tbl2(str); |
INSERT INTO tbl2 VALUES($::str); |
COMMIT; |
} |
# 5 pages: |
# |
# 1 -> database header |
# 2 -> first back-pointer page |
# 3 -> table abc |
# 4 -> table tbl2 |
# 5 -> table tbl2 overflow page. |
# |
expr {[file size test.db] / 1024} |
} {5} |
do_test incrvacuum-3.3 { |
execsql { |
DROP TABLE abc; |
DELETE FROM tbl2; |
} |
expr {[file size test.db] / 1024} |
} {5} |
do_test incrvacuum-3.4 { |
execsql { |
PRAGMA auto_vacuum = 1; |
INSERT INTO tbl2 VALUES('hello world'); |
} |
expr {[file size test.db] / 1024} |
} {3} |
|
#--------------------------------------------------------------------- |
# Try to run a very simple incremental vacuum. Also verify that |
# PRAGMA incremental_vacuum is a harmless no-op against a database that |
# does not support auto-vacuum. |
# |
do_test incrvacuum-4.1 { |
set ::str [string repeat 1234567890 110] |
execsql { |
PRAGMA auto_vacuum = 2; |
INSERT INTO tbl2 VALUES($::str); |
CREATE TABLE tbl1(a, b, c); |
} |
expr {[file size test.db] / 1024} |
} {5} |
do_test incrvacuum-4.2 { |
execsql { |
DELETE FROM tbl2; |
DROP TABLE tbl1; |
} |
expr {[file size test.db] / 1024} |
} {5} |
do_test incrvacuum-4.3 { |
set ::nStep 0 |
db eval {pragma incremental_vacuum(10)} { |
incr ::nStep |
} |
list [expr {[file size test.db] / 1024}] $::nStep |
} {3 2} |
|
#--------------------------------------------------------------------- |
# The following tests - incrvacuum-5.* - test incremental vacuum |
# from within a transaction. |
# |
do_test incrvacuum-5.1.1 { |
expr {[file size test.db] / 1024} |
} {3} |
do_test incrvacuum-5.1.2 { |
execsql { |
BEGIN; |
DROP TABLE tbl2; |
PRAGMA incremental_vacuum; |
COMMIT; |
} |
expr {[file size test.db] / 1024} |
} {1} |
|
do_test incrvacuum-5.2.1 { |
set ::str [string repeat abcdefghij 110] |
execsql { |
BEGIN; |
CREATE TABLE tbl1(a); |
INSERT INTO tbl1 VALUES($::str); |
PRAGMA incremental_vacuum; -- this is a no-op. |
COMMIT; |
} |
expr {[file size test.db] / 1024} |
} {4} |
do_test incrvacuum-5.2.2 { |
set ::str [string repeat abcdefghij 110] |
execsql { |
BEGIN; |
INSERT INTO tbl1 VALUES($::str); |
INSERT INTO tbl1 SELECT * FROM tbl1; |
DELETE FROM tbl1 WHERE oid%2; -- Put 2 overflow pages on free-list. |
COMMIT; |
} |
expr {[file size test.db] / 1024} |
} {7} |
do_test incrvacuum-5.2.3 { |
execsql { |
BEGIN; |
PRAGMA incremental_vacuum; -- Vacuum up the two pages. |
CREATE TABLE tbl2(b); -- Use one free page as a table root. |
INSERT INTO tbl2 VALUES('a nice string'); |
COMMIT; |
} |
expr {[file size test.db] / 1024} |
} {6} |
do_test incrvacuum-5.2.4 { |
execsql { |
SELECT * FROM tbl2; |
} |
} {{a nice string}} |
do_test incrvacuum-5.2.5 { |
execsql { |
DROP TABLE tbl1; |
DROP TABLE tbl2; |
PRAGMA incremental_vacuum; |
} |
expr {[file size test.db] / 1024} |
} {1} |
|
|
# Test cases incrvacuum-5.3.* use the following list as input data. |
# Two new databases are opened, one with incremental vacuum enabled, |
# the other with no auto-vacuum completely disabled. After executing |
# each element of the following list on both databases, test that |
# the integrity-check passes and the contents of each are identical. |
# |
set TestScriptList [list { |
BEGIN; |
CREATE TABLE t1(a, b); |
CREATE TABLE t2(a, b); |
CREATE INDEX t1_i ON t1(a); |
CREATE INDEX t2_i ON t2(a); |
} { |
INSERT INTO t1 VALUES($::str1, $::str2); |
INSERT INTO t1 VALUES($::str1||$::str2, $::str2||$::str1); |
INSERT INTO t2 SELECT b, a FROM t1; |
INSERT INTO t2 SELECT a, b FROM t1; |
INSERT INTO t1 SELECT b, a FROM t2; |
UPDATE t2 SET b = ''; |
PRAGMA incremental_vacuum; |
} { |
UPDATE t2 SET b = (SELECT b FROM t1 WHERE t1.oid = t2.oid); |
PRAGMA incremental_vacuum; |
} { |
CREATE TABLE t3(a, b); |
INSERT INTO t3 SELECT * FROM t2; |
DROP TABLE t2; |
PRAGMA incremental_vacuum; |
} { |
CREATE INDEX t3_i ON t3(a); |
COMMIT; |
} { |
BEGIN; |
DROP INDEX t3_i; |
PRAGMA incremental_vacuum; |
INSERT INTO t3 VALUES('hello', 'world'); |
ROLLBACK; |
} { |
INSERT INTO t3 VALUES('hello', 'world'); |
} |
] |
|
# If this build omits subqueries, step 2 in the above list will not |
# work. Replace it with "" in this case. |
# |
ifcapable !subquery { lset TestScriptList 2 "" } |
|
# Compare the contents of databases $A and $B. |
# |
proc compare_dbs {A B tname} { |
set tbl_list [execsql { |
SELECT tbl_name FROM sqlite_master WHERE type = 'table' |
} $A] |
|
do_test ${tname}.1 [subst { |
execsql { |
SELECT tbl_name FROM sqlite_master WHERE type = 'table' |
} $B |
}] $tbl_list |
|
set tn 1 |
foreach tbl $tbl_list { |
set control [execsql "SELECT * FROM $tbl" $A] |
do_test ${tname}.[incr tn] [subst { |
execsql "SELECT * FROM $tbl" $B |
}] $control |
} |
} |
|
set ::str1 [string repeat abcdefghij 130] |
set ::str2 [string repeat 1234567890 105] |
|
file delete -force test1.db test1.db-journal test2.db test2.db-journal |
sqlite3 db1 test1.db |
sqlite3 db2 test2.db |
execsql { PRAGMA auto_vacuum = 'none' } db1 |
execsql { PRAGMA auto_vacuum = 'incremental' } db2 |
|
set tn 1 |
foreach sql $::TestScriptList { |
execsql $sql db1 |
execsql $sql db2 |
|
compare_dbs db1 db2 incrvacuum-5.3.${tn} |
do_test incrvacuum-5.3.${tn}.integrity1 { |
execsql { PRAGMA integrity_check; } db1 |
} {ok} |
do_test incrvacuum-5.3.${tn}.integrity2 { |
execsql { PRAGMA integrity_check; } db2 |
} {ok} |
incr tn |
} |
db1 close |
db2 close |
# |
# End of test cases 5.3.* |
|
#--------------------------------------------------------------------- |
# The following tests - incrvacuum-6.* - test running incremental |
# vacuum while another statement (a read) is being executed. |
# |
for {set jj 0} {$jj < 10} {incr jj} { |
# Build some test data. Two tables are created in an empty |
# database. tbl1 data is a contiguous block starting at page 5 (pages |
# 3 and 4 are the table roots). tbl2 is a contiguous block starting |
# right after tbl1. |
# |
# Then drop tbl1 so that when an incr vacuum is run the pages |
# of tbl2 have to be moved to fill the gap. |
# |
do_test incrvacuum-6.${jj}.1 { |
execsql { |
DROP TABLE IF EXISTS tbl1; |
DROP TABLE IF EXISTS tbl2; |
PRAGMA incremental_vacuum; |
CREATE TABLE tbl1(a, b); |
CREATE TABLE tbl2(a, b); |
BEGIN; |
} |
for {set ii 0} {$ii < 1000} {incr ii} { |
db eval {INSERT INTO tbl1 VALUES($ii, $ii || $ii)} |
} |
execsql { |
INSERT INTO tbl2 SELECT * FROM tbl1; |
COMMIT; |
DROP TABLE tbl1; |
} |
expr {[file size test.db] / 1024} |
} {36} |
|
# Run a linear scan query on tbl2. After reading ($jj*100) rows, |
# run the incremental vacuum to shrink the database. |
# |
do_test incrvacuum-6.${jj}.2 { |
set ::nRow 0 |
db eval {SELECT a FROM tbl2} {} { |
if {$a == [expr $jj*100]} { |
db eval {PRAGMA incremental_vacuum} |
} |
incr ::nRow |
} |
list [expr {[file size test.db] / 1024}] $nRow |
} {19 1000} |
} |
|
#--------------------------------------------------------------------- |
# This test - incrvacuum-7.* - is to check that the database can be |
# written in the middle of an incremental vacuum. |
# |
set ::iWrite 1 |
while 1 { |
do_test incrvacuum-7.${::iWrite}.1 { |
execsql { |
DROP TABLE IF EXISTS tbl1; |
DROP TABLE IF EXISTS tbl2; |
PRAGMA incremental_vacuum; |
CREATE TABLE tbl1(a, b); |
CREATE TABLE tbl2(a, b); |
BEGIN; |
} |
for {set ii 0} {$ii < 1000} {incr ii} { |
db eval {INSERT INTO tbl1 VALUES($ii, $ii || $ii)} |
} |
execsql { |
INSERT INTO tbl2 SELECT * FROM tbl1; |
COMMIT; |
DROP TABLE tbl1; |
} |
expr {[file size test.db] / 1024} |
} {36} |
|
do_test incrvacuum-7.${::iWrite}.2 { |
set ::nRow 0 |
db eval {PRAGMA incremental_vacuum} { |
incr ::nRow |
if {$::nRow == $::iWrite} { |
db eval { |
CREATE TABLE tbl1(a, b); |
INSERT INTO tbl1 VALUES('hello', 'world'); |
} |
} |
} |
list [expr {[file size test.db] / 1024}] |
} {20} |
|
do_test incrvacuum-7.${::iWrite}.3 { |
execsql { |
SELECT * FROM tbl1; |
} |
} {hello world} |
|
if {$::nRow == $::iWrite} break |
incr ::iWrite |
} |
|
#--------------------------------------------------------------------- |
# This test - incrvacuum-8.* - is to check that nothing goes wrong |
# with an incremental-vacuum if it is the first statement executed |
# after an existing database is opened. |
# |
# At one point, this would always return SQLITE_SCHEMA (which |
# causes an infinite loop in tclsqlite.c if using the Tcl interface). |
# |
do_test incrvacuum-8.1 { |
db close |
sqlite3 db test.db |
execsql { |
PRAGMA incremental_vacuum(50); |
} |
} {} |
|
#--------------------------------------------------------------------- |
# At one point this test case was causing an assert() to fail. |
# |
do_test incrvacuum-9.1 { |
db close |
file delete -force test.db test.db-journal |
sqlite3 db test.db |
|
execsql { |
PRAGMA auto_vacuum = 'incremental'; |
CREATE TABLE t1(a, b, c); |
CREATE TABLE t2(a, b, c); |
INSERT INTO t2 VALUES(randstr(500,500),randstr(500,500),randstr(500,500)); |
INSERT INTO t1 VALUES(1, 2, 3); |
INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1; |
INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1; |
INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1; |
INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1; |
INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1; |
INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1; |
INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1; |
INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1; |
} |
} {} |
|
do_test incrvacuum-9.2 { |
execsql { |
PRAGMA synchronous = 'OFF'; |
BEGIN; |
UPDATE t1 SET a = a, b = b, c = c; |
DROP TABLE t2; |
PRAGMA incremental_vacuum(10); |
ROLLBACK; |
} |
} {} |
|
do_test incrvacuum-9.3 { |
execsql { |
PRAGMA cache_size = 10; |
BEGIN; |
UPDATE t1 SET a = a, b = b, c = c; |
DROP TABLE t2; |
PRAGMA incremental_vacuum(10); |
ROLLBACK; |
} |
} {} |
|
#--------------------------------------------------------------------- |
# Test that the parameter to the incremental_vacuum pragma works. That |
# is, if the user executes "PRAGMA incremental_vacuum(N)", at most |
# N pages are vacuumed. |
# |
do_test incrvacuum-10.1 { |
execsql { |
DROP TABLE t1; |
DROP TABLE t2; |
} |
expr [file size test.db] / 1024 |
} {29} |
|
do_test incrvacuum-10.2 { |
execsql { |
PRAGMA incremental_vacuum(1); |
} |
expr [file size test.db] / 1024 |
} {28} |
|
do_test incrvacuum-10.3 { |
execsql { |
PRAGMA incremental_vacuum(5); |
} |
expr [file size test.db] / 1024 |
} {23} |
|
do_test incrvacuum-10.4 { |
execsql { |
PRAGMA incremental_vacuum('1'); |
} |
expr [file size test.db] / 1024 |
} {22} |
|
do_test incrvacuum-10.5 { |
execsql { |
PRAGMA incremental_vacuum("+3"); |
} |
expr [file size test.db] / 1024 |
} {19} |
|
do_test incrvacuum-10.6 { |
execsql { |
PRAGMA incremental_vacuum = 1; |
} |
expr [file size test.db] / 1024 |
} {18} |
|
do_test incrvacuum-10.7 { |
# Use a really big number as an argument to incremetal_vacuum. Should |
# be interpreted as "free all possible space". |
execsql { |
PRAGMA incremental_vacuum(2147483649); |
} |
expr [file size test.db] / 1024 |
} {1} |
|
do_test incrvacuum-10.8 { |
execsql { |
CREATE TABLE t1(x); |
INSERT INTO t1 VALUES(hex(randomblob(1000))); |
DROP TABLE t1; |
} |
# A negative number means free all possible space. |
execsql { |
PRAGMA incremental_vacuum=-1; |
} |
expr [file size test.db] / 1024 |
} {1} |
|
#---------------------------------------------------------------- |
# Test that if we set the auto_vacuum mode to 'incremental', then |
# create a database, thereafter that database defaults to incremental |
# vacuum mode. |
# |
db close |
file delete -force test.db test.db-journal |
sqlite3 db test.db |
|
ifcapable default_autovacuum { |
do_test incrvacuum-11.1-av-dflt-on { |
execsql { |
PRAGMA auto_vacuum; |
} |
} $AUTOVACUUM |
} else { |
do_test incrvacuum-11.1-av-dflt-off { |
execsql { |
PRAGMA auto_vacuum; |
} |
} {0} |
} |
do_test incrvacuum-11.2 { |
execsql { |
PRAGMA auto_vacuum = incremental; |
} |
} {} |
do_test incrvacuum-11.3 { |
execsql { |
PRAGMA auto_vacuum; |
} |
} {2} |
do_test incrvacuum-11.4 { |
# The database has now been created. |
expr {[file size test.db]>0} |
} {1} |
do_test incrvacuum-11.5 { |
# Close and reopen the connection. |
db close |
sqlite3 db test.db |
|
# Test we are still in incremental vacuum mode. |
execsql { PRAGMA auto_vacuum; } |
} {2} |
do_test incrvacuum-11.6 { |
execsql { |
PRAGMA auto_vacuum = 'full'; |
PRAGMA auto_vacuum; |
} |
} {1} |
do_test incrvacuum-11.7 { |
# Close and reopen the connection. |
db close |
sqlite3 db test.db |
|
# Test we are still in "full" auto-vacuum mode. |
execsql { PRAGMA auto_vacuum; } |
} {1} |
|
#---------------------------------------------------------------------- |
# Special case: What happens if the database is locked when a "PRAGMA |
# auto_vacuum = XXX" statement is executed. |
# |
db close |
file delete -force test.db test.db-journal |
sqlite3 db test.db |
|
do_test incrvacuum-12.1 { |
execsql { |
PRAGMA auto_vacuum = 1; |
} |
expr {[file size test.db]>0} |
} {1} |
|
# Try to change the auto-vacuum from "full" to "incremental" while the |
# database is locked. Nothing should change. |
# |
do_test incrvacuum-12.2 { |
sqlite3 db2 test.db |
execsql { BEGIN EXCLUSIVE; } db2 |
catchsql { PRAGMA auto_vacuum = 2; } |
} {1 {database is locked}} |
|
do_test incrvacuum-12.3 { |
execsql { ROLLBACK; } db2 |
execsql { PRAGMA auto_vacuum } |
} {2} ;# Still 2 because PRAGMA auto_vacuum setting held in case of vacuum |
do_test incrvacuum-12.4 { |
db close |
sqlite3 db test.db |
execsql { PRAGMA auto_vacuum } |
} {1} ;# Revert to 1 because the database file did not change |
|
do_test incrvacuum-12.5 { |
execsql { SELECT * FROM sqlite_master } |
execsql { PRAGMA auto_vacuum } |
} {1} |
|
#---------------------------------------------------------------------- |
# Special case #2: What if one process prepares a "PRAGMA auto_vacuum = XXX" |
# statement when the database is empty, but doesn't execute it until |
# after some other process has created the database. |
# |
db2 close |
db close |
file delete -force test.db test.db-journal |
sqlite3 db test.db ; set ::DB [sqlite3_connection_pointer db] |
sqlite3 db2 test.db |
|
do_test incrvacuum-13.1 { |
# File size is sometimes 1 instead of 0 due to the hack we put in |
# to work around ticket #3260. Search for comments on #3260 in |
# os_unix.c. |
expr {[file size test.db]>1} |
} {0} |
do_test incrvacuum-13.2 { |
set ::STMT [sqlite3_prepare $::DB {PRAGMA auto_vacuum = 2} -1 DUMMY] |
execsql { |
PRAGMA auto_vacuum = none; |
PRAGMA default_cache_size = 1024; |
PRAGMA auto_vacuum; |
} db2 |
} {0} |
do_test incrvacuum-13.3 { |
expr {[file size test.db]>0} |
} {1} |
do_test incrvacuum-13.4 { |
set rc [sqlite3_step $::STMT] |
list $rc [sqlite3_finalize $::STMT] |
} {SQLITE_DONE SQLITE_OK} |
do_test incrvacuum-13.5 { |
execsql { |
PRAGMA auto_vacuum; |
} |
} {0} |
|
|
# Verify that the incremental_vacuum pragma fails gracefully if it |
# is used against an invalid database file. |
# |
if {[permutation] == ""} { |
do_test incrvacuum-14.1 { |
set out [open invalid.db w] |
puts $out "This is not an SQLite database file" |
close $out |
sqlite3 db3 invalid.db |
catchsql { |
PRAGMA incremental_vacuum(10); |
} db3 |
} {1 {file is encrypted or is not a database}} |
db3 close |
} |
|
do_test incrvacuum-15.1 { |
db close |
db2 close |
file delete -force test.db |
sqlite3 db test.db |
|
set str [string repeat "abcdefghij" 500] |
|
execsql { |
PRAGMA cache_size = 10; |
PRAGMA auto_vacuum = incremental; |
CREATE TABLE t1(x, y); |
INSERT INTO t1 VALUES('a', $str); |
INSERT INTO t1 VALUES('b', $str); |
INSERT INTO t1 VALUES('c', $str); |
INSERT INTO t1 VALUES('d', $str); |
INSERT INTO t1 VALUES('e', $str); |
INSERT INTO t1 VALUES('f', $str); |
INSERT INTO t1 VALUES('g', $str); |
INSERT INTO t1 VALUES('h', $str); |
INSERT INTO t1 VALUES('i', $str); |
INSERT INTO t1 VALUES('j', $str); |
INSERT INTO t1 VALUES('j', $str); |
|
CREATE TABLE t2(x PRIMARY KEY, y); |
INSERT INTO t2 VALUES('a', $str); |
INSERT INTO t2 VALUES('b', $str); |
INSERT INTO t2 VALUES('c', $str); |
INSERT INTO t2 VALUES('d', $str); |
|
BEGIN; |
DELETE FROM t2; |
PRAGMA incremental_vacuum; |
} |
|
catchsql {INSERT INTO t2 SELECT * FROM t1} |
|
execsql { |
COMMIT; |
PRAGMA integrity_check; |
} |
} {ok} |
|
finish_test |