Add //third_party/sqlite to dirs_to_snapshot, remove net_sql.patch

third_party/sqlite/src/test/shared.test

 # 2005 December 30
 #
 # 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.
 #
 #***********************************************************************
 #
 # $Id: shared.test,v 1.36 2009/03/16 13:19:36 danielk1977 Exp $
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 db close
 
 # These tests cannot be run without the ATTACH command.
 #
 ifcapable !shared_cache||!attach {
   finish_test
   return
 }
 
 set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
 
 foreach av [list 0 1] {
 
 # Open the database connection and execute the auto-vacuum pragma
-file delete -force test.db
+forcedelete test.db
 sqlite3 db test.db
 
 ifcapable autovacuum {
   do_test shared-[expr $av+1].1.0 {
     execsql "pragma auto_vacuum=$::av"
     execsql {pragma auto_vacuum}
   } "$av"
 } else {
   if {$av} {
     db close
@@ skipping 245 matching lines @@
 #
 
 # Open two database handles db and db2. Each has a single attach database
 # (as well as main):
 #
 #     db.main   ->   ./test.db
 #     db.test2  ->   ./test2.db
 #     db2.main  ->   ./test2.db
 #     db2.test  ->   ./test.db
 #
-file delete -force test.db
-file delete -force test2.db
-file delete -force test2.db-journal
+forcedelete test.db
+forcedelete test2.db
+forcedelete test2.db-journal
 sqlite3 db  test.db
 sqlite3 db2 test2.db
 do_test shared-$av.4.1.1 {
   set sqlite_open_file_count
   expr $sqlite_open_file_count-($extrafds_prelock*2)
 } {2}
 do_test shared-$av.4.1.2 {
   execsql {ATTACH 'test2.db' AS test2}
   set sqlite_open_file_count
   expr $sqlite_open_file_count-($extrafds_postlock*2)
@@ skipping 110 matching lines @@
 } {1 {(6) database schema is locked: test}}
 
 
 catch {db2 close}
 catch {db close}
 
 #--------------------------------------------------------------------------
 # Tests shared-5.* 
 #
 foreach db [list test.db test1.db test2.db test3.db] {
-  file delete -force $db ${db}-journal
+  forcedelete $db ${db}-journal
 }
 do_test shared-$av.5.1.1 {
   sqlite3 db1 test.db
   sqlite3 db2 test.db
   execsql {
     ATTACH 'test1.db' AS test1;
     ATTACH 'test2.db' AS test2;
     ATTACH 'test3.db' AS test3;
   } db1
   execsql {
@@ skipping 110 matching lines @@
     } {
       lappend ret $d
     }
   }
   set ret
 } {}
 
 catch {db1 close}
 catch {db2 close}
 foreach f [list test.db test2.db] {
-  file delete -force $f ${f}-journal
+  forcedelete $f ${f}-journal
 }
 
 #--------------------------------------------------------------------------
 # Tests shared-7.* test auto-vacuum does not invalidate cursors from
 # other shared-cache users when it reorganizes the database on 
 # COMMIT.
 #
 do_test shared-$av.7.1 {
   # This test case sets up a test database in auto-vacuum mode consisting 
   # of two tables, t1 and t2. Both have a single index. Table t1 is 
@@ skipping 65 matching lines @@
 } {0}
 
 catch {db close}
 catch {db2 close}
 unset -nocomplain contents
 
 #--------------------------------------------------------------------------
 # The following tests try to trick the shared-cache code into assuming
 # the wrong encoding for a database.
 #
-file delete -force test.db test.db-journal
+forcedelete test.db test.db-journal
 ifcapable utf16 {
   do_test shared-$av.8.1.1 {
     sqlite3 db test.db
     execsql {
       PRAGMA encoding = 'UTF-16';
       SELECT * FROM sqlite_master;
     }
   } {}
   do_test shared-$av.8.1.2 {
     string range [execsql {PRAGMA encoding;}] 0 end-2
@@ skipping 11 matching lines @@
       SELECT * FROM sqlite_master;
     }
   } "table abc abc [expr $AUTOVACUUM?3:2] {CREATE TABLE abc(a, b, c)}"
   do_test shared-$av.8.1.5 {
     db2 close
     execsql {
       PRAGMA encoding;
     }
   } {UTF-8}
 
-  file delete -force test2.db test2.db-journal
+  forcedelete test2.db test2.db-journal
   do_test shared-$av.8.2.1 {
     execsql {
       ATTACH 'test2.db' AS aux;
       SELECT * FROM aux.sqlite_master;
     }
   } {}
   do_test shared-$av.8.2.2 {
     sqlite3 db2 test2.db
     execsql {
       PRAGMA encoding = 'UTF-16';
       CREATE TABLE def(d, e, f);
     } db2
     string range [execsql {PRAGMA encoding;} db2] 0 end-2
   } {UTF-16}
 
   catch {db close}
   catch {db2 close}
-  file delete -force test.db test2.db
+  forcedelete test.db test2.db
 
   do_test shared-$av.8.3.2 {
     sqlite3 db test.db
     execsql { CREATE TABLE def(d, e, f) }
     execsql { PRAGMA encoding }
   } {UTF-8}
   do_test shared-$av.8.3.3 {
     set zDb16 "[encoding convertto unicode test.db]\x00\x00"
     set db16 [sqlite3_open16 $zDb16 {}]
 
@@ skipping 18 matching lines @@
   do_test shared-$av.8.2.3 {
     catchsql {
       SELECT * FROM aux.sqlite_master;
     }
   } {1 {attached databases must use the same text encoding as main database}}
 }
 }
 
 catch {db close}
 catch {db2 close}
-file delete -force test.db test2.db
+forcedelete test.db test2.db
 
 #---------------------------------------------------------------------------
 # The following tests - shared-9.* - test interactions between TEMP triggers
 # and shared-schemas.
 #
 ifcapable trigger&&tempdb {
 
 do_test shared-$av.9.1 {
   sqlite3 db test.db
   sqlite3 db2 test.db
@@ skipping 19 matching lines @@
 } {}
 
 } ; # End shared-9.*
 
 #---------------------------------------------------------------------------
 # The following tests - shared-10.* - test that the library behaves 
 # correctly when a connection to a shared-cache is closed. 
 #
 do_test shared-$av.10.1 {
   # Create a small sample database with two connections to it (db and db2).
-  file delete -force test.db
+  forcedelete test.db
   sqlite3 db  test.db
   sqlite3 db2 test.db
   execsql {
     CREATE TABLE ab(a PRIMARY KEY, b);
     CREATE TABLE de(d PRIMARY KEY, e);
     INSERT INTO ab VALUES('Chiang Mai', 100000);
     INSERT INTO ab VALUES('Bangkok', 8000000);
     INSERT INTO de VALUES('Ubon', 120000);
     INSERT INTO de VALUES('Khon Kaen', 200000);
   }
@@ skipping 60 matching lines @@
   # Commit the external transaction.
   catchsql {COMMIT} db3
 } {0 {}}
 integrity_check shared-$av.10.10
 do_test shared-$av.10.11 {
   db close
   db3 close
 } {}
 
 do_test shared-$av.11.1 {
-  file delete -force test.db
+  forcedelete test.db
   sqlite3 db  test.db
   sqlite3 db2 test.db
   execsql {
     CREATE TABLE abc(a, b, c);
     CREATE TABLE abc2(a, b, c);
     BEGIN;
     INSERT INTO abc VALUES(1, 2, 3);
   }
 } {}
 do_test shared-$av.11.2 {
@@ skipping 30 matching lines @@
     SELECT abc.a as I, abc2.a as II FROM abc, abc2;
   } {
     execsql {
       DELETE FROM abc WHERE 1;
     }
     lappend res $I $II
   }
   set res
 } {1 4 {} 7}
 if {[llength [info command sqlite3_shared_cache_report]]==1} {
-  do_test shared-$av.11.9 {
-    string tolower [sqlite3_shared_cache_report]
-  } [string tolower [list [file nativename [file normalize test.db]] 2]]
+  ifcapable curdir {
+    do_test shared-$av.11.9 {
+      string tolower [sqlite3_shared_cache_report]
+    } [string tolower [list [file nativename [file normalize test.db]] 2]]
+  }
 }
 
 do_test shared-$av.11.11 {
   db close
   db2 close
 } {}
 
 # This tests that if it is impossible to free any pages, SQLite will
 # exceed the limit set by PRAGMA cache_size.
-file delete -force test.db test.db-journal
+forcedelete test.db test.db-journal
 sqlite3 db test.db 
 ifcapable pager_pragmas {
   do_test shared-$av.12.1 {
     execsql {
       PRAGMA cache_size = 10;
       PRAGMA cache_size;
     }
   } {10}
 }
 do_test shared-$av.12.2 {
@@ skipping 26 matching lines @@
   }
 } {}
 
 # Internally, locks are acquired on shared B-Tree structures in the order
 # that the structures appear in the virtual memory address space. This
 # test case attempts to cause the order of the structures in memory 
 # to be different from the order in which they are attached to a given
 # database handle. This covers an extra line or two.
 #
 do_test shared-$av.13.1 {
-  file delete -force test2.db test3.db test4.db test5.db
+  forcedelete test2.db test3.db test4.db test5.db
   sqlite3 db :memory:
   execsql {
     ATTACH 'test2.db' AS aux2;
     ATTACH 'test3.db' AS aux3;
     ATTACH 'test4.db' AS aux4;
     ATTACH 'test5.db' AS aux5;
     DETACH aux2;
     DETACH aux3;
     DETACH aux4;
     ATTACH 'test2.db' AS aux2;
@@ skipping 42 matching lines @@
 } {}
 
 # Populate a database schema using connection [db]. Then drop it using
 # [db2]. This is to try to find any points where shared-schema elements
 # are allocated using the lookaside buffer of [db].
 # 
 # Mutexes are enabled for this test as that activates a couple of useful
 # assert() statements in the C code.
 #
 do_test shared-$av-15.1 {
-  file delete -force test.db
+  forcedelete test.db
   sqlite3 db test.db -fullmutex 1
   sqlite3 db2 test.db -fullmutex 1
   execsql {
     CREATE TABLE t1(a, b, c);
     CREATE INDEX i1 ON t1(a, b);
     CREATE VIEW v1 AS SELECT * FROM t1; 
     CREATE VIEW v2 AS SELECT * FROM t1, v1 
                       WHERE t1.c=v1.c GROUP BY t1.a ORDER BY v1.b; 
     CREATE TRIGGER tr1 AFTER INSERT ON t1 
       WHEN new.a!=1
     BEGIN
       DELETE FROM t1 WHERE a=5;
       INSERT INTO t1 VALUES(1, 2, 3);
       UPDATE t1 SET c=c+1;
     END;
 
     INSERT INTO t1 VALUES(5, 6, 7);
     INSERT INTO t1 VALUES(8, 9, 10);
     INSERT INTO t1 VALUES(11, 12, 13);
     ANALYZE;
     SELECT * FROM t1;
   }
 } {1 2 6 8 9 12 1 2 5 11 12 14 1 2 4}
 do_test shared-$av-15.2 {
   execsql { DROP TABLE t1 } db2
 } {}
 db close
 db2 close
 
-}
+# Shared cache on a :memory: database.  This only works for URI filenames.
+#
+do_test shared-$av-16.1 {
+  sqlite3 db1 file::memory: -uri 1
+  sqlite3 db2 file::memory: -uri 1
+  db1 eval {
+    CREATE TABLE t1(x); INSERT INTO t1 VALUES(1),(2),(3);
+  }
+  db2 eval {
+    SELECT x FROM t1 ORDER BY x;
+  }
+} {1 2 3}
+do_test shared-$av-16.2 {
+  db2 eval {
+    INSERT INTO t1 VALUES(99);
+    DELETE FROM t1 WHERE x=2;
+  }
+  db1 eval {
+    SELECT x FROM t1 ORDER BY x;
+  }
+} {1 3 99}
+
+# Verify that there is no cache sharing ordinary (non-URI) filenames are
+# used.
+#
+do_test shared-$av-16.3 {
+  db1 close
+  db2 close
+  sqlite3 db1 :memory:
+  sqlite3 db2 :memory:
+  db1 eval {
+    CREATE TABLE t1(x); INSERT INTO t1 VALUES(4),(5),(6);
+  }
+  catchsql {
+    SELECT * FROM t1;
+  } db2
+} {1 {no such table: t1}}
+
+# Shared cache on named memory databases.
+#
+do_test shared-$av-16.4 {
+  db1 close
+  db2 close
+  forcedelete test.db test.db-wal test.db-journal
+  sqlite3 db1 file:test.db?mode=memory -uri 1
+  sqlite3 db2 file:test.db?mode=memory -uri 1
+  db1 eval {
+    CREATE TABLE t1(x); INSERT INTO t1 VALUES(1),(2),(3);
+  }
+  db2 eval {
+    SELECT x FROM t1 ORDER BY x;
+  }
+} {1 2 3}
+do_test shared-$av-16.5 {
+  db2 eval {
+    INSERT INTO t1 VALUES(99);
+    DELETE FROM t1 WHERE x=2;
+  }
+  db1 eval {
+    SELECT x FROM t1 ORDER BY x;
+  }
+} {1 3 99}
+do_test shared-$av-16.6 {
+  file exists test.db
+} {0}  ;# Verify that the database is in-memory
+
+# Shared cache on named memory databases with different names.
+#
+do_test shared-$av-16.7 {
+  db1 close
+  db2 close
+  forcedelete test1.db test2.db
+  sqlite3 db1 file:test1.db?mode=memory -uri 1
+  sqlite3 db2 file:test2.db?mode=memory -uri 1
+  db1 eval {
+    CREATE TABLE t1(x); INSERT INTO t1 VALUES(1),(2),(3);
+  }
+  catchsql {
+    SELECT x FROM t1 ORDER BY x;
+  } db2
+} {1 {no such table: t1}}
+do_test shared-$av-16.8 {
+  file exists test1.db
+} {0}  ;# Verify that the database is in-memory
+
+# Shared cache on named memory databases attached to readonly connections.
+#
+do_test shared-$av-16.8.1 {
+  db1 close
+  db2 close
+
+  sqlite3 db test1.db
+  db eval { 
+    CREATE TABLE yy(a, b);
+    INSERT INTO yy VALUES(77, 88);
+  }
+  db close
+
+  sqlite3 db1 test1.db -uri 1 -readonly 1
+  sqlite3 db2 test2.db -uri 1 
+
+  db1 eval { 
+    ATTACH 'file:mem?mode=memory&cache=shared' AS shared; 
+    CREATE TABLE shared.xx(a, b);
+    INSERT INTO xx VALUES(55, 66);
+  }
+  db2 eval { 
+    ATTACH 'file:mem?mode=memory&cache=shared' AS shared;
+    SELECT * FROM xx;
+  }
+} {55 66}
+
+do_test shared-$av-16.8.2 { db1 eval { SELECT * FROM yy } } {77 88}
+do_test shared-$av-16.8.3 { 
+  list [catch {db1 eval { INSERT INTO yy VALUES(1, 2) }} msg] $msg
+} {1 {attempt to write a readonly database}}
+
+db1 close
+db2 close
+
+}  ;# end of autovacuum on/off loop
 
 sqlite3_enable_shared_cache $::enable_shared_cache
 finish_test