Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Add the --output=$file and --verbose=(0|1|file) options to tester.tcl. |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
f7b2c70362f10ee0347c1d2318918ffe |
User & Date: | dan 2015-06-09 15:58:28.618 |
Context
2015-06-10
| ||
14:27 | Avoid passing constraints that are unusable due to LEFT or CROSS joins to virtual table xBestIndex() methods. (check-in: 7b446771ca user: dan tags: trunk) | |
2015-06-09
| ||
15:58 | Add the --output=$file and --verbose=(0|1|file) options to tester.tcl. (check-in: f7b2c70362 user: dan tags: trunk) | |
2015-06-08
| ||
19:15 | Add the valgrindfuzz target to unix makefile. (check-in: e62aed01f1 user: drh tags: trunk) | |
Changes
Changes to test/tester.tcl.
︙ | ︙ | |||
77 78 79 80 81 82 83 84 85 86 87 88 89 90 | # # wal_is_wal_mode # wal_set_journal_mode ?DB? # wal_check_journal_mode TESTNAME?DB? # permutation # presql # # Set the precision of FP arithmatic used by the interpreter. And # configure SQLite to take database file locks on the page that begins # 64KB into the database file instead of the one 1GB in. This means # the code that handles that special case can be tested without creating # very large database files. # | > > > > > > | 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 | # # wal_is_wal_mode # wal_set_journal_mode ?DB? # wal_check_journal_mode TESTNAME?DB? # permutation # presql # # Command to test whether or not --verbose=1 was specified on the command # line (returns 0 for not-verbose, 1 for verbose and 2 for "verbose in the # output file only"). # # verbose # # Set the precision of FP arithmatic used by the interpreter. And # configure SQLite to take database file locks on the page that begins # 64KB into the database file instead of the one 1GB in. This means # the code that handles that special case can be tested without creating # very large database files. # |
︙ | ︙ | |||
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 | # --backtrace=N # --binarylog=N # --soak=N # --file-retries=N # --file-retry-delay=N # --start=[$permutation:]$testfile # --match=$pattern # set cmdlinearg(soft-heap-limit) 0 set cmdlinearg(maxerror) 1000 set cmdlinearg(malloctrace) 0 set cmdlinearg(backtrace) 10 set cmdlinearg(binarylog) 0 set cmdlinearg(soak) 0 set cmdlinearg(file-retries) 0 set cmdlinearg(file-retry-delay) 0 set cmdlinearg(start) "" set cmdlinearg(match) "" set leftover [list] foreach a $argv { switch -regexp -- $a { {^-+pause$} { # Wait for user input before continuing. This is to give the user an # opportunity to connect profiling tools to the process. | > > > > > | 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 | # --backtrace=N # --binarylog=N # --soak=N # --file-retries=N # --file-retry-delay=N # --start=[$permutation:]$testfile # --match=$pattern # --verbose=$val # --output=$filename # --help # set cmdlinearg(soft-heap-limit) 0 set cmdlinearg(maxerror) 1000 set cmdlinearg(malloctrace) 0 set cmdlinearg(backtrace) 10 set cmdlinearg(binarylog) 0 set cmdlinearg(soak) 0 set cmdlinearg(file-retries) 0 set cmdlinearg(file-retry-delay) 0 set cmdlinearg(start) "" set cmdlinearg(match) "" set cmdlinearg(verbose) "" set cmdlinearg(output) "" set leftover [list] foreach a $argv { switch -regexp -- $a { {^-+pause$} { # Wait for user input before continuing. This is to give the user an # opportunity to connect profiling tools to the process. |
︙ | ︙ | |||
453 454 455 456 457 458 459 460 461 462 463 464 465 466 | } {^-+match=.+$} { foreach {dummy cmdlinearg(match)} [split $a =] break set ::G(match) $cmdlinearg(match) if {$::G(match) == ""} {unset ::G(match)} } default { lappend leftover $a } } } set argv $leftover | > > > > > > > > > > > > > > > > | 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 | } {^-+match=.+$} { foreach {dummy cmdlinearg(match)} [split $a =] break set ::G(match) $cmdlinearg(match) if {$::G(match) == ""} {unset ::G(match)} } {^-+output=.+$} { foreach {dummy cmdlinearg(output)} [split $a =] break if {$cmdlinearg(verbose)==""} { set cmdlinearg(verbose) 2 } } {^-+verbose=.+$} { foreach {dummy cmdlinearg(verbose)} [split $a =] break if {$cmdlinearg(verbose)=="file"} { set cmdlinearg(verbose) 2 } elseif {[string is boolean -strict $cmdlinearg(verbose)]==0} { error "option --verbose= must be set to a boolean or to \"file\"" } } default { lappend leftover $a } } } set argv $leftover |
︙ | ︙ | |||
480 481 482 483 484 485 486 487 488 489 490 491 492 493 | } # Set the backtrace depth, if malloc tracing is enabled. # if {$cmdlinearg(malloctrace)} { sqlite3_memdebug_backtrace $cmdlinearg(backtrace) } } # Update the soft-heap-limit each time this script is run. In that # way if an individual test file changes the soft-heap-limit, it # will be reset at the start of the next test file. # sqlite3_soft_heap_limit $cmdlinearg(soft-heap-limit) | > > > > > > > > > > | 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 | } # Set the backtrace depth, if malloc tracing is enabled. # if {$cmdlinearg(malloctrace)} { sqlite3_memdebug_backtrace $cmdlinearg(backtrace) } if {$cmdlinearg(output)!=""} { puts "Copying output to file $cmdlinearg(output)" set ::G(output_fd) [open $cmdlinearg(output) w] fconfigure $::G(output_fd) -buffering line } if {$cmdlinearg(verbose)==""} { set cmdlinearg(verbose) 1 } } # Update the soft-heap-limit each time this script is run. In that # way if an individual test file changes the soft-heap-limit, it # will be reset at the start of the next test file. # sqlite3_soft_heap_limit $cmdlinearg(soft-heap-limit) |
︙ | ︙ | |||
550 551 552 553 554 555 556 | set f [set_test_counter fail_list] lappend f $name set_test_counter fail_list $f set_test_counter errors [expr [set_test_counter errors] + 1] set nFail [set_test_counter errors] if {$nFail>=$::cmdlinearg(maxerror)} { | | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 | set f [set_test_counter fail_list] lappend f $name set_test_counter fail_list $f set_test_counter errors [expr [set_test_counter errors] + 1] set nFail [set_test_counter errors] if {$nFail>=$::cmdlinearg(maxerror)} { output2 "*** Giving up..." finalize_testing } } # Remember a warning message to be displayed at the conclusion of all testing # proc warning {msg {append 1}} { output2 "Warning: $msg" set warnList [set_test_counter warn_list] if {$append} { lappend warnList $msg } set_test_counter warn_list $warnList } # Increment the number of tests run # proc incr_ntest {} { set_test_counter count [expr [set_test_counter count] + 1] } # Return true if --verbose=1 was specified on the command line. Otherwise, # return false. # proc verbose {} { return $::cmdlinearg(verbose) } # Use the following commands instead of [puts] for test output within # this file. Test scripts can still use regular [puts], which is directed # to stdout and, if one is open, the --output file. # # output1: output that should be printed if --verbose=1 was specified. # output2: output that should be printed unconditionally. # output2_if_no_verbose: output that should be printed only if --verbose=0. # proc output1 {args} { set v [verbose] if {$v==1} { uplevel output2 $args } elseif {$v==2} { uplevel puts [lrange $args 0 end-1] $::G(output_fd) [lrange $args end end] } } proc output2 {args} { set nArg [llength $args] uplevel puts $args } proc output2_if_no_verbose {args} { set v [verbose] if {$v==0} { uplevel output2 $args } elseif {$v==2} { uplevel puts [lrange $args 0 end-1] stdout [lrange $args end end] } } # Override the [puts] command so that if no channel is explicitly # specified the string is written to both stdout and to the file # specified by "--output=", if any. # proc puts_override {args} { set nArg [llength $args] if {$nArg==1 || ($nArg==2 && [string first [lindex $args 0] -nonewline]==0)} { uplevel puts_original $args if {[info exists ::G(output_fd)]} { uplevel puts [lrange $args 0 end-1] $::G(output_fd) [lrange $args end end] } } else { # A channel was explicitly specified. uplevel puts_original $args } } rename puts puts_original proc puts {args} { uplevel puts_override $args } # Invoke the do_test procedure to run a single test # proc do_test {name cmd expected} { global argv cmdlinearg |
︙ | ︙ | |||
600 601 602 603 604 605 606 | # } if {[info exists ::G(perm:prefix)]} { set name "$::G(perm:prefix)$name" } incr_ntest | | > | | 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 | # } if {[info exists ::G(perm:prefix)]} { set name "$::G(perm:prefix)$name" } incr_ntest output1 -nonewline $name... flush stdout if {![info exists ::G(match)] || [string match $::G(match) $name]} { if {[catch {uplevel #0 "$cmd;\n"} result]} { output2_if_no_verbose -nonewline $name... output2 "\nError: $result" fail_test $name } else { if {[regexp {^~?/.*/$} $expected]} { # "expected" is of the form "/PATTERN/" then the result if correct if # regular expression PATTERN matches the result. "~/PATTERN/" means # the regular expression must not match. if {[string index $expected 0]=="~"} { |
︙ | ︙ | |||
649 650 651 652 653 654 655 | } else { set ok [expr {[string compare $result $expected]==0}] } if {!$ok} { # if {![info exists ::testprefix] || $::testprefix eq ""} { # error "no test prefix" # } | > | | | | 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 | } else { set ok [expr {[string compare $result $expected]==0}] } if {!$ok} { # if {![info exists ::testprefix] || $::testprefix eq ""} { # error "no test prefix" # } output2_if_no_verbose -nonewline $name... output2 "\nExpected: \[$expected\]\n Got: \[$result\]" fail_test $name } else { output1 " Ok" } } } else { output1 " Omitted" omit_test $name "pattern mismatch" 0 } flush stdout } proc dumpbytes {s} { set r "" |
︙ | ︙ | |||
833 834 835 836 837 838 839 | } } # Run an SQL script. # Return the number of microseconds per statement. # proc speed_trial {name numstmt units sql} { | | | | | | | | | | 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 | } } # Run an SQL script. # Return the number of microseconds per statement. # proc speed_trial {name numstmt units sql} { output2 -nonewline [format {%-21.21s } $name...] flush stdout set speed [time {sqlite3_exec_nr db $sql}] set tm [lindex $speed 0] if {$tm == 0} { set rate [format %20s "many"] } else { set rate [format %20.5f [expr {1000000.0*$numstmt/$tm}]] } set u2 $units/s output2 [format {%12d uS %s %s} $tm $rate $u2] global total_time set total_time [expr {$total_time+$tm}] lappend ::speed_trial_times $name $tm } proc speed_trial_tcl {name numstmt units script} { output2 -nonewline [format {%-21.21s } $name...] flush stdout set speed [time {eval $script}] set tm [lindex $speed 0] if {$tm == 0} { set rate [format %20s "many"] } else { set rate [format %20.5f [expr {1000000.0*$numstmt/$tm}]] } set u2 $units/s output2 [format {%12d uS %s %s} $tm $rate $u2] global total_time set total_time [expr {$total_time+$tm}] lappend ::speed_trial_times $name $tm } proc speed_trial_init {name} { global total_time set total_time 0 set ::speed_trial_times [list] sqlite3 versdb :memory: set vers [versdb one {SELECT sqlite_source_id()}] versdb close output2 "SQLite $vers" } proc speed_trial_summary {name} { global total_time output2 [format {%-21.21s %12d uS TOTAL} $name $total_time] if { 0 } { sqlite3 versdb :memory: set vers [lindex [versdb one {SELECT sqlite_source_id()}] 0] versdb close output2 "CREATE TABLE IF NOT EXISTS time(version, script, test, us);" foreach {test us} $::speed_trial_times { output2 "INSERT INTO time VALUES('$vers', '$name', '$test', $us);" } } } # Run this routine last # proc finish_test {} { |
︙ | ︙ | |||
927 928 929 930 931 932 933 | close $fd foreach x $content {set known_error($x) 1} foreach x [set_test_counter fail_list] { if {[info exists known_error($x)]} {incr nKnown} } } if {$nKnown>0} { | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 | close $fd foreach x $content {set known_error($x) 1} foreach x [set_test_counter fail_list] { if {[info exists known_error($x)]} {incr nKnown} } } if {$nKnown>0} { output2 "[expr {$nErr-$nKnown}] new errors and $nKnown known errors\ out of $nTest tests" } else { output2 "$nErr errors out of $nTest tests" } if {$nErr>$nKnown} { output2 -nonewline "Failures on these tests:" foreach x [set_test_counter fail_list] { if {![info exists known_error($x)]} {output2 -nonewline " $x"} } output2 "" } foreach warning [set_test_counter warn_list] { output2 "Warning: $warning" } run_thread_tests 1 if {[llength $omitList]>0} { output2 "Omitted test cases:" set prec {} foreach {rec} [lsort $omitList] { if {$rec==$prec} continue set prec $rec output2 [format { %-12s %s} [lindex $rec 0] [lindex $rec 1]] } } if {$nErr>0 && ![working_64bit_int]} { output2 "******************************************************************" output2 "N.B.: The version of TCL that you used to build this test harness" output2 "is defective in that it does not support 64-bit integers. Some or" output2 "all of the test failures above might be a result from this defect" output2 "in your TCL build." output2 "******************************************************************" } if {$::cmdlinearg(binarylog)} { vfslog finalize binarylog } if {$sqlite_open_file_count} { output2 "$sqlite_open_file_count files were left open" incr nErr } if {[lindex [sqlite3_status SQLITE_STATUS_MALLOC_COUNT 0] 1]>0 || [sqlite3_memory_used]>0} { output2 "Unfreed memory: [sqlite3_memory_used] bytes in\ [lindex [sqlite3_status SQLITE_STATUS_MALLOC_COUNT 0] 1] allocations" incr nErr ifcapable memdebug||mem5||(mem3&&debug) { output2 "Writing unfreed memory log to \"./memleak.txt\"" sqlite3_memdebug_dump ./memleak.txt } } else { output2 "All memory allocations freed - no leaks" ifcapable memdebug||mem5 { sqlite3_memdebug_dump ./memusage.txt } } show_memstats output2 "Maximum memory usage: [sqlite3_memory_highwater 1] bytes" output2 "Current memory usage: [sqlite3_memory_highwater] bytes" if {[info commands sqlite3_memdebug_malloc_count] ne ""} { output2 "Number of malloc() : [sqlite3_memdebug_malloc_count] calls" } if {$::cmdlinearg(malloctrace)} { output2 "Writing mallocs.sql..." memdebug_log_sql sqlite3_memdebug_log stop sqlite3_memdebug_log clear if {[sqlite3_memory_used]>0} { output2 "Writing leaks.sql..." sqlite3_memdebug_log sync memdebug_log_sql leaks.sql } } foreach f [glob -nocomplain test.db-*-journal] { forcedelete $f } foreach f [glob -nocomplain test.db-mj*] { forcedelete $f } exit [expr {$nErr>0}] } # Display memory statistics for analysis and debugging purposes. # proc show_memstats {} { set x [sqlite3_status SQLITE_STATUS_MEMORY_USED 0] set y [sqlite3_status SQLITE_STATUS_MALLOC_SIZE 0] set val [format {now %10d max %10d max-size %10d} \ [lindex $x 1] [lindex $x 2] [lindex $y 2]] output1 "Memory used: $val" set x [sqlite3_status SQLITE_STATUS_MALLOC_COUNT 0] set val [format {now %10d max %10d} [lindex $x 1] [lindex $x 2]] output1 "Allocation count: $val" set x [sqlite3_status SQLITE_STATUS_PAGECACHE_USED 0] set y [sqlite3_status SQLITE_STATUS_PAGECACHE_SIZE 0] set val [format {now %10d max %10d max-size %10d} \ [lindex $x 1] [lindex $x 2] [lindex $y 2]] output1 "Page-cache used: $val" set x [sqlite3_status SQLITE_STATUS_PAGECACHE_OVERFLOW 0] set val [format {now %10d max %10d} [lindex $x 1] [lindex $x 2]] output1 "Page-cache overflow: $val" set x [sqlite3_status SQLITE_STATUS_SCRATCH_USED 0] set val [format {now %10d max %10d} [lindex $x 1] [lindex $x 2]] output1 "Scratch memory used: $val" set x [sqlite3_status SQLITE_STATUS_SCRATCH_OVERFLOW 0] set y [sqlite3_status SQLITE_STATUS_SCRATCH_SIZE 0] set val [format {now %10d max %10d max-size %10d} \ [lindex $x 1] [lindex $x 2] [lindex $y 2]] output1 "Scratch overflow: $val" ifcapable yytrackmaxstackdepth { set x [sqlite3_status SQLITE_STATUS_PARSER_STACK 0] set val [format { max %10d} [lindex $x 2]] output2 "Parser stack depth: $val" } } # A procedure to execute SQL # proc execsql {sql {db db}} { # puts "SQL = $sql" uplevel [list $db eval $sql] } proc execsql_timed {sql {db db}} { set tm [time { set x [uplevel [list $db eval $sql]] } 1] set tm [lindex $tm 0] output1 -nonewline " ([expr {$tm*0.001}]ms) " set x } # Execute SQL and catch exceptions. # proc catchsql {sql {db db}} { # puts "SQL = $sql" |
︙ | ︙ | |||
1591 1592 1593 1594 1595 1596 1597 | do_test $testname.$n.6 { catch {db close} catch {db2 close} set ::DB [sqlite3 db test.db; sqlite3_connection_pointer db] set nowcksum [cksum] set res [expr {$nowcksum==$::checksum || $nowcksum==$::goodcksum}] if {$res==0} { | | | | | 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 | do_test $testname.$n.6 { catch {db close} catch {db2 close} set ::DB [sqlite3 db test.db; sqlite3_connection_pointer db] set nowcksum [cksum] set res [expr {$nowcksum==$::checksum || $nowcksum==$::goodcksum}] if {$res==0} { output2 "now=$nowcksum" output2 "the=$::checksum" output2 "fwd=$::goodcksum" } set res } 1 } set ::sqlite_io_error_hardhit 0 set ::sqlite_io_error_pending 0 |
︙ | ︙ | |||
1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 | foreach {var value} [list \ ::argv0 $::argv0 \ ::argv {} \ ::SLAVE 1 \ ] { interp eval tinterp [list set $var $value] } # The alias used to access the global test counters. tinterp alias set_test_counter set_test_counter # Set up the ::cmdlinearg array in the slave. interp eval tinterp [list array set ::cmdlinearg [array get ::cmdlinearg]] | > > > > > > | 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 | foreach {var value} [list \ ::argv0 $::argv0 \ ::argv {} \ ::SLAVE 1 \ ] { interp eval tinterp [list set $var $value] } # If output is being copied into a file, share the file-descriptor with # the interpreter. if {[info exists ::G(output_fd)]} { interp share {} $::G(output_fd) tinterp } # The alias used to access the global test counters. tinterp alias set_test_counter set_test_counter # Set up the ::cmdlinearg array in the slave. interp eval tinterp [list array set ::cmdlinearg [array get ::cmdlinearg]] |
︙ | ︙ | |||
1885 1886 1887 1888 1889 1890 1891 | ifcapable shared_cache { set res [expr {[sqlite3_enable_shared_cache] == $scs}] do_test ${tail}-sharedcachesetting [list set {} $res] 1 } # Add some info to the output. # | | | 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 | ifcapable shared_cache { set res [expr {[sqlite3_enable_shared_cache] == $scs}] do_test ${tail}-sharedcachesetting [list set {} $res] 1 } # Add some info to the output. # output2 "Time: $tail $ms ms" show_memstats } # Open a new connection on database test.db and execute the SQL script # supplied as an argument. Before returning, close the new conection and # restore the 4 byte fields starting at header offsets 28, 92 and 96 # to the values they held before the SQL was executed. This simulates |
︙ | ︙ |