Get `gn gen` to succeed on Windows

third_party/sqlite/src/test/misc7.test

+# 2006 September 4
+#
+# 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.
+#
+# $Id: misc7.test,v 1.29 2009/07/16 18:21:18 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+do_test misc7-1-misuse {
+  c_misuse_test
+} {}
+
+do_test misc7-2 {
+  c_realloc_test
+} {}
+
+do_test misc7-3 {
+  c_collation_test
+} {}
+
+# Try to open a directory:
+#
+do_test misc7-4 {
+  file delete mydir
+  file mkdir mydir
+  set rc [catch {
+    sqlite3 db2 ./mydir
+  } msg]
+  list $rc $msg
+} {1 {unable to open database file}}
+
+# Try to open a file with a directory where its journal file should be.
+#
+do_test misc7-5 {
+  file delete mydir
+  file mkdir mydir-journal
+  sqlite3 db2 ./mydir
+  catchsql {
+    CREATE TABLE abc(a, b, c);
+  } db2
+} {1 {unable to open database file}}
+db2 close
+
+#--------------------------------------------------------------------
+# The following tests, misc7-6.* test the libraries behaviour when
+# it cannot open a file. To force this condition, we use up all the
+# file-descriptors before running sqlite. This probably only works
+# on unix.
+#
+
+proc use_up_files {} {
+  set ret [list]
+  catch {
+    while 1 { lappend ret [open test.db] }
+  }
+  return $ret
+}
+
+proc do_fileopen_test {prefix sql} {
+  set fd_list [use_up_files]
+  set ::go 1
+  set ::n 1
+  set ::sql $sql
+  while {$::go} {
+    catch {db close}
+    do_test ${prefix}.${::n} {
+      set rc [catch {
+        sqlite db test.db
+        db eval $::sql
+      } msg]
+      if {$rc == 0} {set ::go 0}
+  
+      expr {$rc == 0 || ($rc == 1 && [string first unable $msg]==0)}
+    } 1
+  
+    close [lindex $fd_list 0]
+    set fd_list [lrange $fd_list 1 end]
+    incr ::n
+  }
+  foreach fd $fd_list {
+    close $fd
+  }
+  db close
+}
+
+execsql { CREATE TABLE abc(a PRIMARY KEY, b, c); }
+db close
+
+if {$tcl_platform(platform)!="windows"} {
+  do_fileopen_test misc7-6.1 {
+    BEGIN;
+    INSERT INTO abc VALUES(1, 2, 3);
+    INSERT INTO abc VALUES(2, 3, 4);
+    INSERT INTO abc SELECT a+2, b, c FROM abc;
+    COMMIT;
+  }
+  
+  do_fileopen_test misc7-6.2 {
+    PRAGMA temp.cache_size = 1000;
+  }
+}
+
+#
+# End of tests for out-of-file-descriptors condition.
+#--------------------------------------------------------------------
+
+sqlite3 db test.db
+execsql {
+  DELETE FROM abc;
+  INSERT INTO abc VALUES(1, 2, 3);
+  INSERT INTO abc VALUES(2, 3, 4);
+  INSERT INTO abc SELECT a+2, b, c FROM abc;
+}
+  
+
+#--------------------------------------------------------------------
+# Test that the sqlite3_busy_timeout call seems to delay approximately
+# the right amount of time.
+#
+do_test misc7-7.0 {
+  sqlite3 db2 test.db
+  sqlite3_busy_timeout [sqlite3_connection_pointer db] 2000
+  execsql {
+    BEGIN EXCLUSIVE;
+  } db2
+
+  # Now db2 has an exclusive lock on the database file, and db has
+  # a busy-timeout of 2000 milliseconds. So check that trying to
+  # access the database using connection db delays for at least 1500 ms.
+  #
+  set tm [time {
+    set result [catchsql {
+        SELECT * FROM sqlite_master;
+      } db]
+  }]
+  set delay [lindex $tm 0]  ;# In microseconds
+  lappend result [expr {$delay>1500000 && $delay<4000000}]
+} {1 {database is locked} 1}
+db2 close
+
+#--------------------------------------------------------------------
+# Test that nothing goes horribly wrong when attaching a database
+# after the omit_readlock pragma has been exercised.
+#
+do_test misc7-7.1 {
+  file delete -force test2.db
+  file delete -force test2.db-journal
+  execsql {
+    PRAGMA omit_readlock = 1;
+    ATTACH 'test2.db' AS aux;
+    CREATE TABLE aux.hello(world);
+    SELECT name FROM aux.sqlite_master;
+  }
+} {hello}
+do_test misc7-7.2 {
+  execsql {
+    DETACH aux;
+  }
+} {}
+do_test misc7-7.3 {
+  db close
+  sqlite3 db test.db -readonly 1
+  execsql {
+    PRAGMA omit_readlock = 1;
+    ATTACH 'test2.db' AS aux;
+    SELECT name FROM aux.sqlite_master;
+    SELECT name FROM aux.sqlite_master;
+  }
+} {hello hello}
+do_test misc7-7.3 {
+  db close
+  sqlite3 db test.db
+  set ::DB [sqlite3_connection_pointer db]
+  list
+} {}
+
+# Test the UTF-16 version of the "out of memory" message (used when
+# malloc fails during sqlite3_open() ).
+#
+ifcapable utf16 {
+  do_test misc7-8 {
+    encoding convertfrom unicode [sqlite3_errmsg16 0x00000000]
+  } {out of memory}
+}
+
+do_test misc7-9 {
+  execsql {
+    SELECT * 
+    FROM (SELECT name+1 AS one FROM sqlite_master LIMIT 1 OFFSET 1) 
+    WHERE one LIKE 'hello%';
+  }
+} {}
+
+#--------------------------------------------------------------------
+# Improve coverage for vtab code.
+#
+ifcapable vtab {
+  # Run some debug code to improve reported coverage
+  #
+
+  # set sqlite_where_trace 1
+  do_test misc7-10 {
+    register_echo_module [sqlite3_connection_pointer db]
+    execsql {
+      CREATE VIRTUAL TABLE t1 USING echo(abc);
+      SELECT a FROM t1 WHERE a = 1 ORDER BY b;
+    }
+  } {1}
+  set sqlite_where_trace 0
+
+  # Specify an ORDER BY clause that cannot be indexed.
+  do_test misc7-11 {
+    execsql {
+      SELECT t1.a, t2.a FROM t1, t1 AS t2 ORDER BY 2 LIMIT 1;
+    }
+  } {1 1}
+
+  # The whole point of this is to test an error code other than
+  # SQLITE_NOMEM from the vtab xBestIndex callback.
+  #
+  do_ioerr_test misc7-12 -tclprep {
+    sqlite3 db2 test.db
+    register_echo_module [sqlite3_connection_pointer db2]
+    db2 eval {
+      CREATE TABLE abc(a PRIMARY KEY, b, c);
+      INSERT INTO abc VALUES(1, 2, 3);
+      CREATE VIRTUAL TABLE t1 USING echo(abc);
+    }
+    db2 close
+  } -tclbody {
+    register_echo_module [sqlite3_connection_pointer db]
+    execsql {SELECT * FROM t1 WHERE a = 1;}
+  } 
+
+  # The case where the virtual table module returns a very large number
+  # as the cost of a scan (greater than SQLITE_BIG_DOUBLE in the code).
+  #
+  do_test misc7-13 {
+    sqlite3 db test.db
+    register_echo_module [sqlite3_connection_pointer db]
+    set ::echo_module_cost 2.0e+99
+    execsql {SELECT * FROM t1 WHERE a = 1;}
+  } {1 2 3}
+  unset ::echo_module_cost
+}
+
+db close
+file delete -force test.db
+file delete -force test.db-journal
+sqlite3 db test.db
+
+ifcapable explain {
+  do_execsql_test misc7-14.1 {
+    CREATE TABLE abc(a PRIMARY KEY, b, c);
+    EXPLAIN QUERY PLAN SELECT * FROM abc AS t2 WHERE rowid = 1;
+  } {
+    0 0 0 {SEARCH TABLE abc AS t2 USING INTEGER PRIMARY KEY (rowid=?) (~1 rows)}
+  }
+  do_execsql_test misc7-14.2 {
+    EXPLAIN QUERY PLAN SELECT * FROM abc AS t2 WHERE a = 1;
+  } {0 0 0 
+     {SEARCH TABLE abc AS t2 USING INDEX sqlite_autoindex_abc_1 (a=?) (~1 rows)}
+  }
+  do_execsql_test misc7-14.3 {
+    EXPLAIN QUERY PLAN SELECT * FROM abc AS t2 ORDER BY a;
+  } {0 0 0 
+     {SCAN TABLE abc AS t2 USING INDEX sqlite_autoindex_abc_1 (~1000000 rows)}
+  }
+}
+
+db close
+file delete -force test.db
+file delete -force test.db-journal
+sqlite3 db test.db
+
+#--------------------------------------------------------------------
+# This is all to force the pager_remove_from_stmt_list() function
+# (inside pager.c) to remove a pager from the middle of the
+# statement-list.
+#
+do_test misc7-15.1 {
+  execsql {
+    PRAGMA cache_size = 10;
+    BEGIN;
+    CREATE TABLE abc(a PRIMARY KEY, b, c);
+    INSERT INTO abc 
+    VALUES(randstr(100,100), randstr(100,100), randstr(100,100));
+    INSERT INTO abc SELECT 
+            randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
+    INSERT INTO abc SELECT 
+            randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
+    INSERT INTO abc SELECT 
+            randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
+    INSERT INTO abc SELECT 
+            randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
+    INSERT INTO abc SELECT 
+            randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
+    INSERT INTO abc SELECT 
+            randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
+    INSERT INTO abc SELECT 
+            randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
+    INSERT INTO abc SELECT 
+            randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
+    COMMIT;
+  }
+  expr {[file size test.db]>10240}
+} {1}
+do_test misc7-15.2 {
+  execsql {
+    DELETE FROM abc WHERE rowid > 12;
+    INSERT INTO abc SELECT 
+            randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
+  }
+} {}
+
+db close
+file delete -force test.db
+file delete -force test.db-journal
+sqlite3 db test.db
+
+do_ioerr_test misc7-16 -sqlprep {
+   PRAGMA cache_size = 10;
+   PRAGMA default_cache_size = 10;
+   CREATE TABLE t3(a, b, UNIQUE(a, b));
+   INSERT INTO t3 VALUES( randstr(100, 100), randstr(100, 100) );
+   INSERT INTO t3 SELECT randstr(100, 100), randstr(100, 100) FROM t3;
+   INSERT INTO t3 SELECT randstr(100, 100), randstr(100, 100) FROM t3;
+   INSERT INTO t3 SELECT randstr(100, 100), randstr(100, 100) FROM t3;
+   INSERT INTO t3 SELECT randstr(100, 100), randstr(100, 100) FROM t3;
+   INSERT INTO t3 SELECT randstr(100, 100), randstr(100, 100) FROM t3;
+   UPDATE t3 
+   SET b = 'hello world'
+   WHERE rowid >= (SELECT max(rowid)-1 FROM t3);
+} -tclbody {
+  set rc [catch {db eval {
+    BEGIN;
+      PRAGMA cache_size = 10;
+      INSERT INTO t3 VALUES( randstr(100, 100), randstr(100, 100) );
+      UPDATE t3 SET a = b;
+    COMMIT;
+  }} msg]
+
+  if {!$rc || ($rc && [string first "columns" $msg]==0)} {
+    set msg
+  } else {
+    error $msg
+  }
+}
+
+sqlite3 db test.db
+
+do_test misc7-16.X {
+  execsql {
+    SELECT count(*) FROM t3;
+  }
+} {32}
+
+#----------------------------------------------------------------------
+# Test the situation where a hot-journal is discovered but write-access
+# to it is denied. This should return SQLITE_BUSY.
+#
+# These tests do not work on windows due to restrictions in the
+# windows file system.
+#
+if {$tcl_platform(platform)!="windows" && $tcl_platform(platform)!="os2"} {
+
+  # Some network filesystems (ex: AFP) do not support setting read-only
+  # permissions.  Only run these tests if full unix permission setting
+  # capabilities are supported.
+  #
+  file attributes test.db -permissions rw-r--r--
+  if {[file attributes test.db -permissions]==0644} {
+
+    do_test misc7-17.1 {
+      execsql {
+        BEGIN;
+        DELETE FROM t3 WHERE (oid%3)==0;
+      }
+      copy_file test.db bak.db
+      copy_file test.db-journal bak.db-journal
+      execsql {
+        COMMIT;
+      }
+    
+      db close
+      copy_file bak.db test.db
+      copy_file bak.db-journal test.db-journal
+      sqlite3 db test.db
+    
+      catch {file attributes test.db-journal -permissions r--------}
+      catch {file attributes test.db-journal -readonly 1}
+      catchsql {
+        SELECT count(*) FROM t3;
+      }
+    } {1 {unable to open database file}}
+    do_test misc7-17.2 {
+      # Note that the -readonly flag must be cleared before the -permissions
+      # are set. Otherwise, when using tcl 8.5 on mac, the fact that the 
+      # -readonly flag is set causes the attempt to set the permissions
+      # to fail.
+      catch {file attributes test.db-journal -readonly 0}
+      catch {file attributes test.db-journal -permissions rw-------}
+      catchsql {
+        SELECT count(*) FROM t3;
+      }
+    } {0 32}
+    
+    # sqlite3_test_control_pending_page [expr ($::sqlite_pending_byte / 1024) + 1]
+    set ::pending_byte_page [expr ($::sqlite_pending_byte / 1024) + 1]
+    sqlite3_test_control_pending_byte $::sqlite_pending_byte 
+    do_test misc7-17.3 {
+      db eval {
+        pragma writable_schema = true;
+        UPDATE sqlite_master 
+          SET rootpage = $pending_byte_page
+          WHERE type = 'table' AND name = 't3';
+      }
+      execsql {
+        SELECT rootpage FROM sqlite_master WHERE type = 'table' AND name = 't3';
+      }
+    } $::pending_byte_page
+    
+    do_test misc7-17.4 {
+      db close
+      sqlite3 db test.db
+      catchsql {
+        SELECT count(*) FROM t3;
+      } 
+    } {1 {database disk image is malformed}}
+  }
+}
+
+# Ticket #2470
+#
+do_test misc7-18.1 {
+  execsql {
+    CREATE TABLE table_1 (col_10);
+    CREATE TABLE table_2 (
+      col_1, col_2, col_3, col_4, col_5,
+      col_6, col_7, col_8, col_9, col_10
+    );
+    SELECT a.col_10
+    FROM
+      (SELECT table_1.col_10 AS col_10 FROM table_1) a,
+      (SELECT table_1.col_10, table_2.col_9 AS qcol_9
+         FROM table_1, table_2
+        GROUP BY table_1.col_10, qcol_9);
+  }
+} {}
+
+# Testing boundary conditions on sqlite3_status()
+#
+do_test misc7-19.1 {
+  sqlite3_status -1 0
+} {21 0 0}
+do_test misc7-19.2 {
+  sqlite3_status 1000 0
+} {21 0 0}
+
+
+# sqlite3_global_recover() is a no-op.  But we might as well test it
+# if only to get the test coverage.
+#
+do_test misc7-20.1 {
+  sqlite3_global_recover
+} {SQLITE_OK}
+
+# Try to open a really long file name.
+#
+do_test misc7-21.1 {
+  set zFile [file join [pwd] "[string repeat abcde 104].db"]
+  set rc [catch {sqlite3 db2 $zFile} msg]
+  list $rc $msg
+} {1 {unable to open database file}}
+
+
+db close
+file delete -force test.db
+
+finish_test