527 lines
12 KiB
Perl
527 lines
12 KiB
Perl
########################################################################
|
|
# Command line syntax tests
|
|
########################################################################
|
|
|
|
$ sysbench foo bar
|
|
sysbench * (glob)
|
|
|
|
FATAL: Cannot find benchmark 'foo': no such built-in test, file or module
|
|
[1]
|
|
|
|
$ sysbench foo bar baz
|
|
Unrecognized command line argument: baz
|
|
[1]
|
|
|
|
$ sysbench --unknown <<EOF
|
|
> EOF
|
|
sysbench * (glob)
|
|
|
|
|
|
$ sysbench fileio
|
|
sysbench * (glob)
|
|
|
|
The 'fileio' test requires a command argument. See 'sysbench fileio help'
|
|
[1]
|
|
|
|
$ sysbench --help foo | grep Usage:
|
|
Usage:
|
|
|
|
$ sysbench <<EOF
|
|
> print('test')
|
|
> EOF
|
|
sysbench * (glob)
|
|
|
|
test
|
|
|
|
$ sysbench run <<EOF
|
|
> print('script body')
|
|
> function event()
|
|
> print('event function')
|
|
> end
|
|
> EOF
|
|
sysbench * (glob)
|
|
|
|
FATAL: Cannot find benchmark 'run': no such built-in test, file or module
|
|
[1]
|
|
|
|
$ cat >$CRAMTMP/cmdline.lua <<EOF
|
|
> #!/usr/bin/env sysbench
|
|
> print('script body')
|
|
> function event()
|
|
> print('event function')
|
|
> end
|
|
> EOF
|
|
$ sysbench --events=1 $CRAMTMP/cmdline.lua
|
|
sysbench * (glob)
|
|
|
|
script body
|
|
|
|
$ sysbench --events=1 $CRAMTMP/cmdline.lua run
|
|
sysbench * (glob)
|
|
|
|
script body
|
|
Running the test with following options:
|
|
Number of threads: 1
|
|
Initializing random number generator from current time
|
|
|
|
|
|
Initializing worker threads...
|
|
|
|
script body
|
|
Threads started!
|
|
|
|
event function
|
|
|
|
Throughput:
|
|
events/s (eps): *.* (glob)
|
|
time elapsed:*s (glob)
|
|
total number of events: 1
|
|
|
|
Latency (ms):
|
|
min: *.* (glob)
|
|
avg: *.* (glob)
|
|
max: *.* (glob)
|
|
95th percentile: *.* (glob)
|
|
sum: *.* (glob)
|
|
|
|
Threads fairness:
|
|
events (avg/stddev): 1.0000/0.00
|
|
execution time (avg/stddev): *.*/0.00 (glob)
|
|
|
|
########################################################################
|
|
Command line options tests
|
|
########################################################################
|
|
|
|
$ cat >cmdline.lua <<EOF
|
|
> sysbench.cmdline.options = {
|
|
> str_opt1 = {"str_opt1 description"},
|
|
> str_opt2 = {"str_opt2 description", "opt2"},
|
|
> str_opt3 = {"str_opt3 description", "opt3", sysbench.cmdline.ARG_STRING},
|
|
> bool_opt1 = {"bool_opt1 description", false},
|
|
> bool_opt2 = {"bool_opt2 description", true},
|
|
> bool_opt3 = {"bool_opt3 description", nil, sysbench.cmdline.ARG_BOOL},
|
|
> int_opt1 = {"int_opt1 description", 10},
|
|
> int_opt2 = {"int_opt2 description", nil, sysbench.cmdline.ARG_INT},
|
|
> int_opt3 = {"int_opt3 description", 20, sysbench.cmdline.ARG_INT},
|
|
> float_opt1 = {"float_opt1 description", 3.14, sysbench.cmdline.ARG_DOUBLE},
|
|
> float_opt2 = {"float_opt2 description", 0.2},
|
|
> list_opt1 = {"list_opt1 description", {"foo", "bar"}},
|
|
> list_opt2 = {"list_opt2 description", nil, sysbench.cmdline.ARG_LIST},
|
|
> ["dash-opt"] = {"dash-opt desc", "dash-opt val"}
|
|
> }
|
|
>
|
|
> function print_opt_table()
|
|
> local o = sysbench.opt
|
|
> print(o.str_opt1)
|
|
> print(o.str_opt2)
|
|
> print(o.str_opt3)
|
|
> print(o.bool_opt1)
|
|
> print(o.bool_opt2)
|
|
> print(o.bool_opt3)
|
|
> print(o.int_opt1)
|
|
> print(o.int_opt2)
|
|
> print(o.float_opt1)
|
|
> print(o.float_opt2)
|
|
> print(o.list_opt1)
|
|
> print(o.list_opt2)
|
|
> print(o.dash_opt)
|
|
> print()
|
|
> end
|
|
>
|
|
> function help()
|
|
> print("function help()")
|
|
> print("Available options:")
|
|
> sysbench.cmdline.print_test_options()
|
|
> print_opt_table()
|
|
> end
|
|
>
|
|
> function init()
|
|
> print("function init()")
|
|
> print_opt_table()
|
|
> end
|
|
>
|
|
> function thread_init()
|
|
> print("function thread_init()")
|
|
> print_opt_table()
|
|
> end
|
|
>
|
|
> function event()
|
|
> print("function event()")
|
|
> print_opt_table()
|
|
> end
|
|
>
|
|
> function thread_done()
|
|
> print("function thread_done()")
|
|
> print_opt_table()
|
|
> end
|
|
>
|
|
> function done()
|
|
> print("function done()")
|
|
> print_opt_table()
|
|
> end
|
|
> EOF
|
|
|
|
$ sysbench cmdline.lua
|
|
sysbench * (glob)
|
|
|
|
$ sysbench cmdline.lua help
|
|
sysbench * (glob)
|
|
|
|
function help()
|
|
Available options:
|
|
--bool_opt1[=on|off] bool_opt1 description [off]
|
|
--bool_opt2[=on|off] bool_opt2 description [on]
|
|
--bool_opt3[=on|off] bool_opt3 description
|
|
--dash-opt=STRING dash-opt desc [dash-opt val]
|
|
--float_opt1=N float_opt1 description [3.14]
|
|
--float_opt2=N float_opt2 description [0.2]
|
|
--int_opt1=N int_opt1 description [10]
|
|
--int_opt2=N int_opt2 description
|
|
--int_opt3=N int_opt3 description [20]
|
|
--list_opt1=[LIST,...] list_opt1 description [foo,bar]
|
|
--list_opt2=[LIST,...] list_opt2 description
|
|
--str_opt1=STRING str_opt1 description
|
|
--str_opt2=STRING str_opt2 description [opt2]
|
|
--str_opt3=STRING str_opt3 description [opt3]
|
|
|
|
|
|
opt2
|
|
opt3
|
|
false
|
|
true
|
|
true
|
|
10
|
|
0
|
|
3.14
|
|
0.2
|
|
table: 0x* (glob)
|
|
table: 0x* (glob)
|
|
dash-opt val
|
|
|
|
$ sysbench cmdline.lua prepare
|
|
sysbench * (glob)
|
|
|
|
'cmdline.lua' test does not implement the 'prepare' command.
|
|
[1]
|
|
|
|
$ sysbench --non-existing-option=3 cmdline.lua prepare
|
|
sysbench * (glob)
|
|
|
|
invalid option: --non-existing-option=3
|
|
[1]
|
|
|
|
$ sysbench cmdline.lua --events=1 run
|
|
sysbench * (glob)
|
|
|
|
function init()
|
|
|
|
opt2
|
|
opt3
|
|
false
|
|
true
|
|
true
|
|
10
|
|
0
|
|
3.14
|
|
0.2
|
|
table: 0x* (glob)
|
|
table: 0x* (glob)
|
|
dash-opt val
|
|
|
|
Running the test with following options:
|
|
Number of threads: 1
|
|
Initializing random number generator from current time
|
|
|
|
|
|
Initializing worker threads...
|
|
|
|
function thread_init()
|
|
|
|
opt2
|
|
opt3
|
|
false
|
|
true
|
|
true
|
|
10
|
|
0
|
|
3.14
|
|
0.2
|
|
table: 0x* (glob)
|
|
table: 0x* (glob)
|
|
dash-opt val
|
|
|
|
Threads started!
|
|
|
|
function event()
|
|
|
|
opt2
|
|
opt3
|
|
false
|
|
true
|
|
true
|
|
10
|
|
0
|
|
3.14
|
|
0.2
|
|
table: 0x* (glob)
|
|
table: 0x* (glob)
|
|
dash-opt val
|
|
|
|
function thread_done()
|
|
|
|
opt2
|
|
opt3
|
|
false
|
|
true
|
|
true
|
|
10
|
|
0
|
|
3.14
|
|
0.2
|
|
table: 0x* (glob)
|
|
table: 0x* (glob)
|
|
dash-opt val
|
|
|
|
|
|
Throughput:
|
|
events/s (eps): *.* (glob)
|
|
time elapsed: *s (glob)
|
|
total number of events: 1
|
|
|
|
Latency (ms):
|
|
min: * (glob)
|
|
avg: * (glob)
|
|
max: * (glob)
|
|
95th percentile: * (glob)
|
|
sum: *.* (glob)
|
|
|
|
Threads fairness:
|
|
events (avg/stddev): 1.0000/0.00
|
|
execution time (avg/stddev): */0.00 (glob)
|
|
|
|
function done()
|
|
|
|
opt2
|
|
opt3
|
|
false
|
|
true
|
|
true
|
|
10
|
|
0
|
|
3.14
|
|
0.2
|
|
table: 0x* (glob)
|
|
table: 0x* (glob)
|
|
dash-opt val
|
|
|
|
|
|
$ sysbench cmdline.lua cleanup
|
|
sysbench * (glob)
|
|
|
|
'cmdline.lua' test does not implement the 'cleanup' command.
|
|
[1]
|
|
|
|
$ cat >cmdline.lua <<EOF
|
|
>
|
|
> EOF
|
|
|
|
$ sysbench cmdline.lua help
|
|
sysbench * (glob)
|
|
|
|
'cmdline.lua' test does not implement the 'help' command.
|
|
[1]
|
|
|
|
$ cat >cmdline.lua <<EOF
|
|
> sysbench.cmdline.options = {
|
|
> {},
|
|
> }
|
|
>
|
|
> function help()
|
|
> end
|
|
> EOF
|
|
$ sysbench cmdline.lua help
|
|
sysbench * (glob)
|
|
|
|
FATAL: `sysbench.cmdline.read_cmdline_options' function failed: [string "sysbench.cmdline.lua"]:*: wrong table structure in sysbench.cmdline.options (glob)
|
|
[1]
|
|
|
|
$ sysbench fileio --invalid-option prepare
|
|
sysbench * (glob)
|
|
|
|
invalid option: --invalid-option
|
|
[1]
|
|
|
|
# Custom commands
|
|
|
|
$ sysbench <<EOF
|
|
> sysbench.cmdline.commands = {
|
|
> cmd1 = "wrong structure"
|
|
> }
|
|
> EOF
|
|
sysbench * (glob)
|
|
|
|
$ sysbench <<EOF
|
|
> sysbench.cmdline.commands = {
|
|
> cmd1 = { non_existing_func }
|
|
> }
|
|
> EOF
|
|
sysbench * (glob)
|
|
|
|
$ cat >cmdline.lua <<EOF
|
|
> ffi.cdef "unsigned int sleep(unsigned int);"
|
|
> function cmd1_func()
|
|
> print("cmd1, sysbench.tid = " .. sysbench.tid)
|
|
> end
|
|
> function cmd2_func()
|
|
> ffi.C.sleep(sysbench.tid % 2)
|
|
> print("cmd2, sysbench.tid = " .. sysbench.tid)
|
|
> end
|
|
> function prepare_func()
|
|
> ffi.C.sleep(sysbench.tid % 2)
|
|
> print("prepare_func, sysbench.tid = " .. sysbench.tid)
|
|
> end
|
|
> sysbench.cmdline.commands = {
|
|
> cmd1 = { cmd1_func },
|
|
> cmd2 = { cmd2_func, sysbench.cmdline.PARALLEL_COMMAND },
|
|
> prepare = { prepare_func, sysbench.cmdline.PARALLEL_COMMAND }
|
|
> }
|
|
> EOF
|
|
|
|
$ sysbench --threads=2 cmdline.lua cmd1
|
|
sysbench * (glob)
|
|
|
|
cmd1, sysbench.tid = 0
|
|
$ sysbench --threads=2 cmdline.lua cmd2
|
|
sysbench * (glob)
|
|
|
|
Initializing worker threads...
|
|
|
|
cmd2, sysbench.tid = [01] (re)
|
|
cmd2, sysbench.tid = [01] (re)
|
|
|
|
$ sysbench --threads=2 cmdline.lua prepare
|
|
sysbench * (glob)
|
|
|
|
Initializing worker threads...
|
|
|
|
prepare_func, sysbench.tid = [01] (re)
|
|
prepare_func, sysbench.tid = [01] (re)
|
|
|
|
$ sysbench --threads=2 cmdline.lua cmd3
|
|
sysbench * (glob)
|
|
|
|
Unknown command: cmd3
|
|
[1]
|
|
|
|
$ cat >cmdline.lua <<EOF
|
|
> sysbench.cmdline.options = { opt1 = {"opt1"}, opt2 = {"opt2"} }
|
|
> function print_cmd()
|
|
> print("argv = " .. require("inspect")(sysbench.cmdline.argv))
|
|
> print(string.format("sysbench.cmdline.command = %s",sysbench.cmdline.command))
|
|
> end
|
|
> function prepare()
|
|
> print_cmd()
|
|
> end
|
|
> print_cmd()
|
|
> EOF
|
|
$ sysbench --opt1 --opt2=val cmdline.lua
|
|
sysbench * (glob)
|
|
|
|
argv = { "--opt1", "--opt2=val", "cmdline.lua",
|
|
[0] = "sysbench"
|
|
}
|
|
sysbench.cmdline.command = nil
|
|
$ sysbench --opt1 --opt2=val cmdline.lua prepare
|
|
sysbench * (glob)
|
|
|
|
argv = { "--opt1", "--opt2=val", "cmdline.lua", "prepare",
|
|
[0] = "sysbench"
|
|
}
|
|
sysbench.cmdline.command = prepare
|
|
argv = { "--opt1", "--opt2=val", "cmdline.lua", "prepare",
|
|
[0] = "sysbench"
|
|
}
|
|
sysbench.cmdline.command = prepare
|
|
|
|
$ sysbench - <<EOF
|
|
> print("hello")
|
|
> EOF
|
|
sysbench * (glob)
|
|
|
|
hello
|
|
|
|
$ sysbench - prepare <<EOF
|
|
> function prepare()
|
|
> print("prepare")
|
|
> end
|
|
> print("global")
|
|
> EOF
|
|
sysbench * (glob)
|
|
|
|
global
|
|
|
|
# Test benchmark specification as a module
|
|
|
|
$ cat > cmdline_module.lua <<EOF
|
|
> print("cmdline_module loaded")
|
|
> function event()
|
|
> print("cmdline_module event")
|
|
> end
|
|
> EOF
|
|
|
|
$ LUA_PATH="$PWD/?.lua;$LUA_PATH" sysbench cmdline_module --verbosity=0
|
|
cmdline_module loaded
|
|
|
|
$ LUA_PATH="$PWD/?.lua;$LUA_PATH" sysbench cmdline_module --events=1 --verbosity=0 run
|
|
cmdline_module loaded
|
|
cmdline_module loaded
|
|
cmdline_module event
|
|
|
|
# Test that errors thrown by the script itself are reported properly
|
|
|
|
$ cat >> cmdline_module.lua <<EOF
|
|
> error("test error")
|
|
> EOF
|
|
|
|
$ LUA_PATH="$PWD/?.lua;$LUA_PATH" sysbench cmdline_module --verbosity=0
|
|
cmdline_module loaded
|
|
FATAL: */cmdline_module.lua:5: test error (glob)
|
|
[1]
|
|
$ LUA_PATH="$PWD/?.lua;$LUA_PATH" sysbench cmdline_module --events=1 --verbosity=0 run
|
|
cmdline_module loaded
|
|
FATAL: */cmdline_module.lua:5: test error (glob)
|
|
[1]
|
|
|
|
##########################################################################
|
|
# Test boolean option validation
|
|
##########################################################################
|
|
$ cat > cmdline.lua <<EOF
|
|
> sysbench.cmdline.options = {
|
|
> bool_opt = {"Flag", false}
|
|
> }
|
|
>
|
|
> function prepare()
|
|
> print("bool_opt = " .. tostring(sysbench.opt.bool_opt))
|
|
> end
|
|
> EOF
|
|
|
|
$ SB_ARGS=--verbosity=0
|
|
$ sysbench $SB_ARGS cmdline.lua --bool-opt=on prepare
|
|
bool_opt = true
|
|
$ sysbench $SB_ARGS cmdline.lua --bool-opt=off prepare
|
|
bool_opt = false
|
|
$ sysbench $SB_ARGS cmdline.lua --bool-opt=true prepare
|
|
bool_opt = true
|
|
$ sysbench $SB_ARGS cmdline.lua --bool-opt=false prepare
|
|
bool_opt = false
|
|
$ sysbench $SB_ARGS cmdline.lua --bool-opt=1 prepare
|
|
bool_opt = true
|
|
$ sysbench $SB_ARGS cmdline.lua --bool-opt=0 prepare
|
|
bool_opt = false
|
|
$ sysbench $SB_ARGS cmdline.lua --bool-opt=5 prepare
|
|
invalid option: --bool-opt=5
|
|
[1]
|
|
$ sysbench $SB_ARGS cmdline.lua --bool-opt=foo prepare
|
|
invalid option: --bool-opt=foo
|
|
[1]
|