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

third_party/sqlite/src/test/fts3rnd.test

 # 2009 December 03
 #
 #    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.
 #
 #***********************************************************************
 #
 # Brute force (random data) tests for FTS3.
 #
@@ skipping 144 matching lines @@
       if {[regexp $reg " $col "]} { lappend ret $key ; break }
     }
   }
 
   #lsort -uniq -integer $ret
   set ret
 }
 
 # This [proc] is used to test the FTS3 matchinfo() function.
 # 
-proc simple_token_matchinfo {zToken} {
+proc simple_token_matchinfo {zToken bDesc} {
 
   set nDoc(0) 0
   set nDoc(1) 0
   set nDoc(2) 0
   set nHit(0) 0
   set nHit(1) 0
   set nHit(2) 0
 
+  set dir -inc
+  if {$bDesc} { set dir -dec }
 
   foreach key [array names ::t1] {
     set value $::t1($key)
     set a($key) [list]
     foreach i {0 1 2} col $value {
       set hit [llength [lsearch -all $col $zToken]]
       lappend a($key) $hit
       incr nHit($i) $hit
       if {$hit>0} { incr nDoc($i) }
     }
   }
 
   set ret [list]
-  foreach docid [lsort -integer [array names a]] {
+  foreach docid [lsort -integer $dir [array names a]] {
     if { [lindex [lsort -integer $a($docid)] end] } {
       set matchinfo [list 1 3]
       foreach i {0 1 2} hit $a($docid) {
         lappend matchinfo $hit $nHit($i) $nDoc($i)
       }
       lappend ret $docid $matchinfo
     }
   }
 
   set ret
@@ skipping 57 matching lines @@
   return $ret
 }
 
 proc mit {blob} {
   set scan(littleEndian) i*
   set scan(bigEndian) I*
   binary scan $blob $scan($::tcl_platform(byteOrder)) r
   return $r
 }
 db func mit mit
-
 set sqlite_fts3_enable_parentheses 1
 
-foreach nodesize {50 500 1000 2000} {
+proc do_orderbydocid_test {tn sql res} {
+  uplevel [list do_select_test $tn.asc "$sql ORDER BY docid ASC" $res]
+  uplevel [list do_select_test $tn.desc "$sql ORDER BY docid DESC" \
+    [lsort -int -dec $res]
+  ]
+}
+
+set NUM_TRIALS 100
+
+foreach {nodesize order} {
+  50    DESC
+  50    ASC
+  500   ASC
+  1000  DESC
+  2000  ASC
+} {
   catch { array unset ::t1 }
+  set testname "$nodesize/$order"
 
   # Create the FTS3 table. Populate it (and the Tcl array) with 100 rows.
   #
   db transaction {
     catchsql { DROP TABLE t1 }
-    execsql "CREATE VIRTUAL TABLE t1 USING fts3(a, b, c)"
+    execsql "CREATE VIRTUAL TABLE t1 USING fts4(a, b, c, order=$order)"
     execsql "INSERT INTO t1(t1) VALUES('nodesize=$nodesize')"
     for {set i 0} {$i < 100} {incr i} { insert_row $i }
   }
   
-  for {set iTest 1} {$iTest <= 100} {incr iTest} {
+  for {set iTest 1} {$iTest <= $NUM_TRIALS} {incr iTest} {
     catchsql COMMIT
 
     set DO_MALLOC_TEST 0
     set nRep 10
     if {$iTest==100 && $nodesize==50} { 
       set DO_MALLOC_TEST 1 
       set nRep 2
     }
+
+    set ::testprefix fts3rnd-1.$testname.$iTest
   
     # Delete one row, update one row and insert one row.
     #
     set rows [array names ::t1]
     set nRow [llength $rows]
     set iUpdate [lindex $rows [expr {int(rand()*$nRow)}]]
     set iDelete $iUpdate
     while {$iDelete == $iUpdate} {
       set iDelete [lindex $rows [expr {int(rand()*$nRow)}]]
     }
     set iInsert $iUpdate
     while {[info exists ::t1($iInsert)]} {
       set iInsert [expr {int(rand()*1000000)}]
     }
     execsql BEGIN
       insert_row $iInsert
       update_row $iUpdate
       delete_row $iDelete
     if {0==($iTest%2)} { execsql COMMIT }
 
     if {0==($iTest%2)} { 
-      do_test fts3rnd-1.$nodesize.$iTest.0 { fts3_integrity_check t1 } ok 
+      #do_test 0 { fts3_integrity_check t1 } ok 
     }
 
     # Pick 10 terms from the vocabulary. Check that the results of querying
     # the database for the set of documents containing each of these terms
     # is the same as the result obtained by scanning the contents of the Tcl 
     # array for each term.
     #
     for {set i 0} {$i < 10} {incr i} {
       set term [random_term]
-      do_select_test fts3rnd-1.$nodesize.$iTest.1.$i {
+      do_select_test 1.$i.asc {
         SELECT docid, mit(matchinfo(t1)) FROM t1 WHERE t1 MATCH $term
-      } [simple_token_matchinfo $term]
+        ORDER BY docid ASC
+      } [simple_token_matchinfo $term 0]
+      do_select_test 1.$i.desc {
+        SELECT docid, mit(matchinfo(t1)) FROM t1 WHERE t1 MATCH $term
+        ORDER BY docid DESC
+      } [simple_token_matchinfo $term 1]
     }
 
     # This time, use the first two characters of each term as a term prefix
     # to query for. Test that querying the Tcl array produces the same results
     # as querying the FTS3 table for the prefix.
     #
     for {set i 0} {$i < $nRep} {incr i} {
       set prefix [string range [random_term] 0 end-1]
       set match "${prefix}*"
-      do_select_test fts3rnd-1.$nodesize.$iTest.2.$i {
+      do_orderbydocid_test 2.$i {
         SELECT docid FROM t1 WHERE t1 MATCH $match
       } [simple_phrase $match]
     }
 
     # Similar to the above, except for phrase queries.
     #
     for {set i 0} {$i < $nRep} {incr i} {
       set term [list [random_term] [random_term]]
       set match "\"$term\""
-      do_select_test fts3rnd-1.$nodesize.$iTest.3.$i {
+      do_orderbydocid_test 3.$i {
         SELECT docid FROM t1 WHERE t1 MATCH $match
       } [simple_phrase $term]
     }
 
     # Three word phrases.
     #
     for {set i 0} {$i < $nRep} {incr i} {
       set term [list [random_term] [random_term] [random_term]]
       set match "\"$term\""
-      do_select_test fts3rnd-1.$nodesize.$iTest.4.$i {
+      do_orderbydocid_test 4.$i {
         SELECT docid FROM t1 WHERE t1 MATCH $match
       } [simple_phrase $term]
     }
 
     # Three word phrases made up of term-prefixes.
     #
     for {set i 0} {$i < $nRep} {incr i} {
       set    query "[string range [random_term] 0 end-1]* "
       append query "[string range [random_term] 0 end-1]* "
       append query "[string range [random_term] 0 end-1]*"
 
       set match "\"$query\""
-      do_select_test fts3rnd-1.$nodesize.$iTest.5.$i {
+      do_orderbydocid_test 5.$i {
         SELECT docid FROM t1 WHERE t1 MATCH $match
       } [simple_phrase $query]
     }
 
-    # A NEAR query with terms as the arguments.
+    # A NEAR query with terms as the arguments:
+    #
+    #     ... MATCH '$term1 NEAR $term2' ...
     #
     for {set i 0} {$i < $nRep} {incr i} {
       set terms [list [random_term] [random_term]]
       set match [join $terms " NEAR "]
-      do_select_test fts3rnd-1.$nodesize.$iTest.6.$i {
+      do_orderbydocid_test 6.$i {
         SELECT docid FROM t1 WHERE t1 MATCH $match 
       } [simple_near $terms 10]
     }
 
     # A 3-way NEAR query with terms as the arguments.
     #
     for {set i 0} {$i < $nRep} {incr i} {
       set terms [list [random_term] [random_term] [random_term]]
       set nNear 11
       set match [join $terms " NEAR/$nNear "]
-      do_select_test fts3rnd-1.$nodesize.$iTest.7.$i {
+      do_orderbydocid_test 7.$i {
         SELECT docid FROM t1 WHERE t1 MATCH $match
       } [simple_near $terms $nNear]
     }
     
     # Set operations on simple term queries.
     #
     foreach {tn op proc} {
       8  OR  setop_or
       9  NOT setop_not
       10 AND setop_and
     } {
       for {set i 0} {$i < $nRep} {incr i} {
         set term1 [random_term]
         set term2 [random_term]
         set match "$term1 $op $term2"
-        do_select_test fts3rnd-1.$nodesize.$iTest.$tn.$i {
+        do_orderbydocid_test $tn.$i {
           SELECT docid FROM t1 WHERE t1 MATCH $match
         } [$proc [simple_phrase $term1] [simple_phrase $term2]]
       }
     }
  
     # Set operations on NEAR queries.
     #
     foreach {tn op proc} {
-      8  OR  setop_or
-      9  NOT setop_not
-      10 AND setop_and
+      11 OR  setop_or
+      12 NOT setop_not
+      13 AND setop_and
     } {
       for {set i 0} {$i < $nRep} {incr i} {
         set term1 [random_term]
         set term2 [random_term]
         set term3 [random_term]
         set term4 [random_term]
         set match "$term1 NEAR $term2 $op $term3 NEAR $term4"
-        do_select_test fts3rnd-1.$nodesize.$iTest.$tn.$i {
+        do_orderbydocid_test $tn.$i {
           SELECT docid FROM t1 WHERE t1 MATCH $match
         } [$proc                                  \
             [simple_near [list $term1 $term2] 10] \
             [simple_near [list $term3 $term4] 10]
           ]
       }
     }
 
     catchsql COMMIT
   }
 }
 
 finish_test