Import SQLite 3.8.7.4.

third_party/sqlite/src/test/quota.test

 # 2010 September 1
 #
 # 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.
 #
 #***********************************************************************
 #
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
+
+# If SQLITE_CURDIR is not defined, omit this file.
+ifcapable !curdir {
+  finish_test
+  return
+}
+
 source $testdir/malloc_common.tcl
 
+unset -nocomplain defaultVfs
+set defaultVfs [file_control_vfsname db]
 db close
 
 do_test quota-1.1 { sqlite3_quota_initialize nosuchvfs 1 } {SQLITE_ERROR}
 do_test quota-1.2 { sqlite3_quota_initialize "" 1 }        {SQLITE_OK}
 do_test quota-1.3 { sqlite3_quota_initialize "" 1 }        {SQLITE_MISUSE}
 do_test quota-1.4 { sqlite3_quota_shutdown }               {SQLITE_OK}
 
 do_test quota-1.5 { sqlite3_quota_initialize "" 0 }        {SQLITE_OK}
 do_test quota-1.6 { sqlite3_quota_shutdown }               {SQLITE_OK}
 do_test quota-1.7 { sqlite3_quota_initialize "" 1 }        {SQLITE_OK}
@@ skipping 14 matching lines @@
 #   quota-2.3.*: Open and close a db that is not part of any quota group. At
 #                one point this was causing mutex refs to be leaked.
 #
 #   quota-2.4.*: Try to shutdown the quota system before closing the db
 #                file. Check that this fails and the quota system still works
 #                afterwards. Then close the database and successfully shut
 #                down the quota system.
 #   
 sqlite3_quota_initialize "" 1
 
+unset -nocomplain quota_request_ok
 proc quota_check {filename limitvar size} {
   upvar $limitvar limit
 
   lappend ::quota [set limit] $size
   if {[info exists ::quota_request_ok]} { set limit $size }
 }
 
 do_test quota-2.1.1 {
   sqlite3_quota_set *test.db 4096 quota_check
 } {SQLITE_OK}
 do_test quota-2.1.2 {
   sqlite3 db test.db
   execsql {
     PRAGMA page_size=1024;
     PRAGMA auto_vacuum=OFF;
     PRAGMA journal_mode=DELETE;
   }
   set ::quota [list]
   execsql {
     CREATE TABLE t1(a, b);
     INSERT INTO t1 VALUES(1, randomblob(1100));
     INSERT INTO t1 VALUES(2, randomblob(1100));
   }
   set ::quota
 } {}
+do_test quota-2.1.2.1 {
+  file_control_vfsname db
+} quota/$defaultVfs
 do_test quota-2.1.3 { file size test.db } {4096}
 do_test quota-2.1.4 {
   catchsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
 } {1 {database or disk is full}}
 do_test quota-2.1.5 { set ::quota } {4096 5120}
 
 set ::quota_request_ok 1
 set ::quota [list]
 do_test quota-2.2.1 {
   execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
@@ skipping 30 matching lines @@
 #   quota-3.2.*: Two connections to each of several database files (that
 #                are in the same quota group).
 #
 proc quota_check {filename limitvar size} {
   upvar $limitvar limit
   lappend ::quota [set limit] $size
   if {[info exists ::quota_request_ok]} { set limit $size }
 }
 
 do_test quota-3.1.1 {
-  file delete -force test.db
+  forcedelete test.db
   sqlite3_quota_initialize "" 1
   sqlite3_quota_set *test.db 4096 quota_check
 } {SQLITE_OK}
 do_test quota-3.1.2 {
   sqlite3 db test.db
   execsql {
     PRAGMA page_size = 1024;
     PRAGMA journal_mode = delete;
     PRAGMA auto_vacuum = off;
     CREATE TABLE t1(a PRIMARY KEY, b);
@@ skipping 14 matching lines @@
   set ::quota_request_ok 1
   execsql { CREATE TABLE t3(a, b) }
 } {}
 do_test quota-3.1.6 {
   db close
   db2 close
   sqlite3_quota_set *test.db 0 {}
 } {SQLITE_OK}
 
 do_test quota-3.2.1 {
-  file delete force test.db test2.db 
+  delete_file force test.db test2.db 
 
   sqlite3_quota_set * 4096 {}
   sqlite3 db1a test.db
   sqlite3 db2a test2.db
 
   foreach db {db1a db2a} {
     execsql {
       PRAGMA page_size = 1024;
       PRAGMA journal_mode = delete;
       PRAGMA auto_vacuum = off;
@@ skipping 23 matching lines @@
 do_test quota-3.2.8 { 
   catchsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a
 } {1 {database or disk is full}}
 do_test quota-3.2.9 { 
   catchsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b
 } {1 {database or disk is full}}
 
 set ::quota [list]
 proc quota_callback {file limitvar size} {
   upvar $limitvar limit
+  if {$::tcl_platform(platform)=="windows"} {
+    set file [ lindex [string map {\\ \/} $file] 0 ]
+  }
   lappend ::quota $file $size
   set limit 0
 }
 sqlite3_quota_set * 4096 quota_callback
 do_test quota-3.3.1 { 
   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a
   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b
   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a
   execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b
   set ::quota
-} [list [file join [pwd] test.db] 5120]
+} [list [file join [get_pwd] test.db] 5120]
 
 do_test quota-3.2.X {
   foreach db {db1a db2a db2b db1b} { catch { $db close } }
   sqlite3_quota_set * 0 {}
 } {SQLITE_OK}
 
 #-------------------------------------------------------------------------
-# Quotas are deleted when unused and when there limit is set to zero
+# Quotas are deleted when unused and when their limit is set to zero
 #
 
 # Return a list of all currently defined quotas.  Each quota is identified
 # by its pattern.
 proc quota_list {} {
   set allq {}
   foreach q [sqlite3_quota_dump] {
     lappend allq [lindex $q 0]
   }
   return [lsort $allq]
 }
+proc quota_size {name} {
+  set allq {}
+  foreach q [sqlite3_quota_dump] {
+    if {[lindex $q 0]==$name} {return [lindex $q 2]}
+  }
+  return 0
+}
 
 do_test quota-4.1.1 {
   sqlite3_quota_set *test.db 0 {}
   quota_list
 } {}
 do_test quota-4.1.2 {
   sqlite3_quota_set *test.db 4096 {}
   quota_list
 } {*test.db}
 do_test quota-4.1.3 {
   sqlite3_quota_set *test2.db 0 {}
   quota_list
 } {*test.db}
 do_test quota-4.1.4 {
   sqlite3_quota_set *test2.db 100000 {}
   quota_list
 } {*test.db *test2.db}
 do_test quota-4.1.5 {
   sqlite3_quota_set *test.db 0 {}
   quota_list
 } {*test2.db}
 do_test quota-4.1.6 {
-  file delete -force test2.db test2.db-journal test2.db-wal
+  forcedelete test2.db test2.db-journal test2.db-wal
   sqlite3 db test2.db
   db eval {CREATE TABLE t2(x); INSERT INTO t2 VALUES('tab-t2');}
   quota_list
 } {*test2.db}
 do_test quota-4.1.7 {
   catchsql {INSERT INTO t2 VALUES(zeroblob(200000))}
 } {1 {database or disk is full}}
 do_test quota-4.1.8 {
   sqlite3 db2 test2.db
   db2 eval {SELECT * FROM t2}
@@ skipping 51 matching lines @@
 } {}
 
 do_test quota-4.3.1 {
   sqlite3_quota_set A 1000 quota_callback
   sqlite3 db A
   sqlite3_quota_set A 0 quota_callback
   db close
   quota_list
 } {}
 
+unset -nocomplain quotagroup
+if {$tcl_platform(platform)=="windows"} {
+  set quotagroup *\\quota-test-A?.db
+} else {
+  set quotagroup */quota-test-A?.db
+} 
+foreach file [glob -nocomplain quota-test-A*] {
+  forcedelete $file
+}
 do_test quota-4.4.1 {
+  set ::quota {}
+  sqlite3_quota_set $::quotagroup 10000 quota_callback
+  forcedelete ./quota-test-A1.db ./quota-test-A2.db
+  sqlite3 db ./quota-test-A1.db
+  db eval {
+     CREATE TABLE t1(x);
+     INSERT INTO t1 VALUES(randomblob(5000));
+  }
+  quota_list
+} [list $quotagroup]
+do_test quota-4.4.2 {
+  expr {$::quota==""}
+} {1}
+do_test quota-4.4.3 {
+  db close
+  sqlite3 db ./quota-test-A2.db
+  db eval {
+     CREATE TABLE t1(x);
+     INSERT INTO t1 VALUES(randomblob(5000));
+  }
+  quota_list
+} [list $quotagroup]
+do_test quota-4.4.4 {
+  expr {$::quota!=""}
+} {1}
+do_test quota-4.4.5 {
+  db close
+  sqlite3_quota_set $::quotagroup 0 {}
+  sqlite3_quota_dump
+} {}
+do_test quota-4.4.6 {
+  sqlite3_quota_set $quotagroup 10000 quota_callback
+  sqlite3 db quota-test-A1.db
+  db eval {SELECT count(*) FROM sqlite_master}
+  quota_size $quotagroup
+} [file size quota-test-A1.db]
+do_test quota-4.4.7 {
+  sqlite3_quota_file quota-test-A2.db
+  quota_size $::quotagroup
+} [expr {[file size quota-test-A1.db]+[file size quota-test-A2.db]}]
+
+unset -nocomplain quotagroup
+if {$tcl_platform(platform)=="windows"} {
+  set quotagroup *\\quota-test-B*
+} else {
+  set quotagroup */quota-test-B*
+} 
+foreach file [glob -nocomplain quota-test-B*] {
+  forcedelete $file
+}
+do_test quota-4.5.1 {
+  sqlite3_quota_set $::quotagroup 100000 quota_callback
+  quota_size $::quotagroup
+} {0}
+do_test quota-4.5.2 {
+  sqlite3_quota_file quota-test-B1.txt
+  quota_size $::quotagroup
+} {0}
+proc add_to_file {name n} {
+  set out [open $name a]
+  fconfigure $out -translation binary
+  puts -nonewline $out [string repeat x $n]
+  close $out
+}
+do_test quota-4.5.3 {
+  add_to_file quota-test-B1.txt 123
+  sqlite3_quota_file quota-test-B1.txt
+  quota_size $::quotagroup
+} {123}
+do_test quota-4.5.4 {
+  add_to_file quota-test-B2.txt 234
+  sqlite3_quota_file quota-test-B2.txt
+  quota_size $::quotagroup
+} {357}
+do_test quota-4.5.5 {
+  add_to_file quota-test-B1.txt 2000
+  sqlite3_quota_file quota-test-B1.txt
+  quota_size $::quotagroup
+} {2357}
+do_test quota-4.5.6 {
+  forcedelete quota-test-B1.txt
+  sqlite3_quota_file quota-test-B1.txt
+  quota_size $::quotagroup
+} {234}
+do_test quota-4.5.7 {
+  forcedelete quota-test-B2.txt
+  sqlite3_quota_file quota-test-B2.txt
+  quota_size $::quotagroup
+} {0}
+do_test quota-4.5.8 {
+  add_to_file quota-test-B3.txt 1234
+  sqlite3_quota_file quota-test-B3.txt
+  quota_size $::quotagroup
+} {1234}
+do_test quota-4.5.9 {
+  sqlite3_quota_set $quotagroup 0 {}
+  quota_size $::quotagroup
+} {0}
+
+do_test quota-4.9.1 {
+  db close
   sqlite3_quota_set A 1000 quota_callback
   sqlite3_quota_shutdown
 } {SQLITE_OK}
-do_test quota-4.4.2 {
+do_test quota-4.9.2 {
   quota_list
 } {}
 
 #-------------------------------------------------------------------------
 # The following tests test that the quota VFS handles malloc and IO 
 # errors.
 #
 
 sqlite3_quota_initialize "" 1
 sqlite3_quota_set *test.db 4096 {}
 
 do_faultsim_test quota-5.1 -prep {
   catch {db close}
 } -body {
   sqlite3 db test2.db
 }
 do_faultsim_test quota-5.2 -prep {
   catch {db close}
 } -body {
   sqlite3 db test.db
 }
 
 catch { db close }
-file delete -force test.db
+forcedelete test.db
 
 do_test quota-5.3.prep {
   sqlite3 db test.db
   execsql {
     PRAGMA auto_vacuum = 1;
     PRAGMA page_size = 1024;
     CREATE TABLE t1(a, b);
     INSERT INTO t1 VALUES(10, zeroblob(1200));
   }
   faultsim_save_and_close
 } {}
 do_faultsim_test quota-5.3 -prep {
   faultsim_restore_and_reopen
 } -body {
   execsql { DELETE FROM t1 }
 }
 
 do_test quota-5.4.1 {
   catch { db close }
-  file delete -force test.db
+  forcedelete test.db
   file mkdir test.db
   list [catch { sqlite3 db test.db } msg] $msg
 } {1 {unable to open database file}}
 
 do_faultsim_test quota-5.5 -prep {
   catch { sqlite3_quota_shutdown }
 } -body {
   sqlite3_quota_initialize "" 1
 }
 
 do_faultsim_test quota-5.6 -prep {
   catch { sqlite3_quota_shutdown }
   sqlite3_quota_initialize "" 1
 } -body {
   sqlite3_quota_set * 4096 {}
 }
 
 catch { sqlite3_quota_shutdown }
 finish_test