Make clear that contributing code to the Redis project means to release it under...

[redis.git] / tests / test_helper.tcl

diff --git a/tests/test_helper.tcl b/tests/test_helper.tcl
index dd91d2cbb08b9a2cbff1db5c0d1e4d86e8396d01..853193ccdc1f5349ded96703ef9ec5db8d9624e9 100644 (file)
--- a/tests/test_helper.tcl
+++ b/tests/test_helper.tcl
@@ -25,14 +25,23 @@ set ::all_tests {
     unit/other
     unit/cas
     unit/quit
     unit/other
     unit/cas
     unit/quit

+    unit/aofrw

     integration/replication
     integration/replication-2
     integration/replication-3
     integration/replication
     integration/replication-2
     integration/replication-3

+    integration/replication-4

     integration/aof
     integration/aof

+    integration/rdb
+    integration/convert-zipmap-hash-on-load

     unit/pubsub
     unit/slowlog
     unit/scripting
     unit/maxmemory
     unit/pubsub
     unit/slowlog
     unit/scripting
     unit/maxmemory

+    unit/introspection
+    unit/limits
+    unit/obuf-limits
+    unit/dump
+    unit/bitops

 }
 # Index to the next test to run in the ::all_tests list.
 set ::next_test 0
 }
 # Index to the next test to run in the ::all_tests list.
 set ::next_test 0


@@ -42,6 +51,7 @@ set ::port 21111
 set ::traceleaks 0
 set ::valgrind 0
 set ::verbose 0
 set ::traceleaks 0
 set ::valgrind 0
 set ::verbose 0

+set ::quiet 0

 set ::denytags {}
 set ::allowtags {}
 set ::external 0; # If "1" this means, we are running against external instance
 set ::denytags {}
 set ::allowtags {}
 set ::external 0; # If "1" this means, we are running against external instance


@@ -112,7 +122,7 @@ proc reconnect {args} {
     }
 
     # re-set $srv in the servers list
     }
 
     # re-set $srv in the servers list

-    set ::servers [lreplace $::servers end+$level 1 $srv]
+    lset ::servers end+$level $srv

 }
 
 proc redis_deferring_client {args} {
 }
 
 proc redis_deferring_client {args} {


@@ -142,19 +152,19 @@ proc s {args} {
 }
 
 proc cleanup {} {
 }
 
 proc cleanup {} {

-    puts -nonewline "Cleanup: may take some time... "
+    if {!$::quiet} {puts -nonewline "Cleanup: may take some time... "}

     flush stdout
     catch {exec rm -rf {*}[glob tests/tmp/redis.conf.*]}
     catch {exec rm -rf {*}[glob tests/tmp/server.*]}
     flush stdout
     catch {exec rm -rf {*}[glob tests/tmp/redis.conf.*]}
     catch {exec rm -rf {*}[glob tests/tmp/server.*]}

-    puts "OK"
+    if {!$::quiet} {puts "OK"}

 }
 
 proc find_available_port start {
     for {set j $start} {$j < $start+1024} {incr j} {
         if {[catch {
 }
 
 proc find_available_port start {
     for {set j $start} {$j < $start+1024} {incr j} {
         if {[catch {

-            set fd [socket 127.0.0.1 $start]
+            set fd [socket 127.0.0.1 $j]

         }]} {
         }]} {

-            return $start
+            return $j

         } else {
             close $fd
         }
         } else {
             close $fd
         }


@@ -169,7 +179,9 @@ proc test_server_main {} {
     # Open a listening socket, trying different ports in order to find a
     # non busy one.
     set port [find_available_port 11111]
     # Open a listening socket, trying different ports in order to find a
     # non busy one.
     set port [find_available_port 11111]

-    puts "Starting test server at port $port"
+    if {!$::quiet} {
+        puts "Starting test server at port $port"
+    }

     socket -server accept_test_clients $port
 
     # Start the client instances
     socket -server accept_test_clients $port
 
     # Start the client instances


@@ -223,16 +235,22 @@ proc read_from_test_client fd {
     set payload [read $fd $bytes]
     foreach {status data} $payload break
     if {$status eq {ready}} {
     set payload [read $fd $bytes]
     foreach {status data} $payload break
     if {$status eq {ready}} {

-        puts "\[$status\]: $data"
+        if {!$::quiet} {
+            puts "\[$status\]: $data"
+        }

         signal_idle_client $fd
     } elseif {$status eq {done}} {
         set elapsed [expr {[clock seconds]-$::clients_start_time($fd)}]
         signal_idle_client $fd
     } elseif {$status eq {done}} {
         set elapsed [expr {[clock seconds]-$::clients_start_time($fd)}]

-        puts "\[[colorstr yellow $status]\]: $data ($elapsed seconds)"
-        puts "+++ [expr {[llength $::active_clients]-1}] units still in execution."
+        set all_tests_count [llength $::all_tests]
+        set running_tests_count [expr {[llength $::active_clients]-1}]
+        set completed_tests_count [expr {$::next_test-$running_tests_count}]
+        puts "\[$completed_tests_count/$all_tests_count [colorstr yellow $status]\]: $data ($elapsed seconds)"

         lappend ::clients_time_history $elapsed $data
         signal_idle_client $fd
     } elseif {$status eq {ok}} {
         lappend ::clients_time_history $elapsed $data
         signal_idle_client $fd
     } elseif {$status eq {ok}} {

-        puts "\[[colorstr green $status]\]: $data"
+        if {!$::quiet} {
+            puts "\[[colorstr green $status]\]: $data"
+        }

     } elseif {$status eq {err}} {
         set err "\[[colorstr red $status]\]: $data"
         puts $err
     } elseif {$status eq {err}} {
         set err "\[[colorstr red $status]\]: $data"
         puts $err


@@ -246,7 +264,9 @@ proc read_from_test_client fd {
     } elseif {$status eq {testing}} {
         # No op
     } else {
     } elseif {$status eq {testing}} {
         # No op
     } else {

-        puts "\[$status\]: $data"
+        if {!$::quiet} {
+            puts "\[$status\]: $data"
+        }

     }
 }
 
     }
 }
 


@@ -258,7 +278,9 @@ proc signal_idle_client fd {
         [lsearch -all -inline -not -exact $::active_clients $fd]
     # New unit to process?
     if {$::next_test != [llength $::all_tests]} {
         [lsearch -all -inline -not -exact $::active_clients $fd]
     # New unit to process?
     if {$::next_test != [llength $::all_tests]} {

-        puts [colorstr bold-white "Testing [lindex $::all_tests $::next_test]"]
+        if {!$::quiet} {
+            puts [colorstr bold-white "Testing [lindex $::all_tests $::next_test]"]
+        }

         set ::clients_start_time($fd) [clock seconds]
         send_data_packet $fd run [lindex $::all_tests $::next_test]
         lappend ::active_clients $fd
         set ::clients_start_time($fd) [clock seconds]
         send_data_packet $fd run [lindex $::all_tests $::next_test]
         lappend ::active_clients $fd


@@ -322,8 +344,10 @@ proc print_help_screen {} {
     puts [join {
         "--valgrind         Run the test over valgrind."
         "--accurate         Run slow randomized tests for more iterations."
     puts [join {
         "--valgrind         Run the test over valgrind."
         "--accurate         Run slow randomized tests for more iterations."

+        "--quiet            Don't show individual tests."

         "--single <unit>    Just execute the specified unit (see next option)."
         "--list-tests       List all the available test units."
         "--single <unit>    Just execute the specified unit (see next option)."
         "--list-tests       List all the available test units."

+        "--clients <num>    Number of test clients (16)."

         "--force-failure    Force the execution of a test that always fails."
         "--help             Print this help screen."
     } "\n"]
         "--force-failure    Force the execution of a test that always fails."
         "--help             Print this help screen."
     } "\n"]


@@ -344,6 +368,8 @@ for {set j 0} {$j < [llength $argv]} {incr j} {
         incr j
     } elseif {$opt eq {--valgrind}} {
         set ::valgrind 1
         incr j
     } elseif {$opt eq {--valgrind}} {
         set ::valgrind 1

+    } elseif {$opt eq {--quiet}} {
+        set ::quiet 1

     } elseif {$opt eq {--host}} {
         set ::external 1
         set ::host $arg
     } elseif {$opt eq {--host}} {
         set ::external 1
         set ::host $arg


@@ -367,6 +393,9 @@ for {set j 0} {$j < [llength $argv]} {incr j} {
         set ::client 1
         set ::test_server_port $arg
         incr j
         set ::client 1
         set ::test_server_port $arg
         incr j

+    } elseif {$opt eq {--clients}} {
+        set ::numclients $arg
+        incr j

     } elseif {$opt eq {--help}} {
         print_help_screen
         exit 0
     } elseif {$opt eq {--help}} {
         print_help_screen
         exit 0


@@ -376,6 +405,18 @@ for {set j 0} {$j < [llength $argv]} {incr j} {
     }
 }
 
     }
 }
 

+# With the parallel test running multiple Redis instances at the same time
+# we need a fast enough computer, otherwise a lot of tests may generate
+# false positives.
+# If the computer is too slow we revert the sequetial test without any
+# parallelism, that is, clients == 1.
+proc is_a_slow_computer {} {
+    set start [clock milliseconds]
+    for {set j 0} {$j < 1000000} {incr j} {}
+    set elapsed [expr [clock milliseconds]-$start]
+    expr {$elapsed > 200}
+}
+

 if {$::client} {
     if {[catch { test_client_main $::test_server_port } err]} {
         set estr "Executing test client: $err.\n$::errorInfo"
 if {$::client} {
     if {[catch { test_client_main $::test_server_port } err]} {
         set estr "Executing test client: $err.\n$::errorInfo"


@@ -385,6 +426,11 @@ if {$::client} {
         exit 1
     }
 } else {
         exit 1
     }
 } else {

+    if {[is_a_slow_computer]} {
+        puts "** SLOW COMPUTER ** Using a single client to avoid false positives."
+        set ::numclients 1
+    }
+

     if {[catch { test_server_main } err]} {
         if {[string length $err] > 0} {
             # only display error when not generated by the test suite
     if {[catch { test_server_main } err]} {
         if {[string length $err] > 0} {
             # only display error when not generated by the test suite