def create_option_parser(tester, tag)
parser = OptionParser.new
parser.banner += " TEST_FILE_OR_DIRECTORY..."
custom_groonga_httpd = false
parser.on("--groonga=COMMAND",
"Use COMMAND as groonga command",
"(#{tester.groonga})") do |command|
tester.groonga = normalize_command(command)
end
parser.on("--groonga-httpd=COMMAND",
"Use COMMAND as groonga-httpd command for groonga-httpd tests",
"(#{tester.groonga_httpd})") do |command|
tester.groonga_httpd = normalize_command(command)
custom_groonga_httpd = true
end
parser.on("--ngx-http-groonga-module-so=PATH",
"Use PATH as ngx_http_groonga_module.so for groonga-nginx tests",
"(#{tester.ngx_http_groonga_module_so})") do |path|
tester.ngx_http_groonga_module_so = path
end
parser.on("--groonga-suggest-create-dataset=COMMAND",
"Use COMMAND as groonga_suggest_create_dataset command",
"(#{tester.groonga_suggest_create_dataset})") do |command|
tester.groonga_suggest_create_dataset = normalize_command(command)
end
parser.on("--groonga-synonym-generate=COMMAND",
"Use COMMAND as groonga_synonym_generate command",
"(#{tester.groonga_synonym_generate})") do |command|
tester.groonga_synonym_generate = normalize_command(command)
end
available_interfaces = ["stdio", "http"]
available_interface_labels = available_interfaces.join(", ")
parser.on("--interface=INTERFACE", available_interfaces,
"Use INTERFACE for communicating Groonga",
"[#{available_interface_labels}]",
"(#{tester.interface})") do |interface|
tester.interface = interface
end
parser.on("--[no-]use-http-post",
"Use POST to send command by HTTP",
"(#{tester.use_http_post?})") do |boolean|
tester.use_http_post = boolean
end
parser.on("--[no-]use-http-chunked",
"Use chunked Transfer-Encoding to send body by HTTP",
"(#{tester.use_http_chunked?})") do |boolean|
tester.use_http_chunked = boolean
end
available_input_types = ["json", "apache-arrow"]
available_input_type_labels = available_input_types.join(", ")
parser.on("--input-type=TYPE", available_input_types,
"Use TYPE as the input type on load",
"[#{available_input_type_labels}]",
"(#{tester.input_type})") do |type|
tester.input_type = type
end
available_output_types = ["json", "msgpack", "apache-arrow"]
available_output_type_labels = available_output_types.join(", ")
parser.on("--output-type=TYPE", available_output_types,
"Use TYPE as the output type",
"[#{available_output_type_labels}]",
"(#{tester.output_type})") do |type|
tester.output_type = type
end
available_testees = ["groonga", "groonga-httpd", "groonga-nginx"]
available_testee_labels = available_testees.join(", ")
parser.on("--testee=TESTEE", available_testees,
"Test against TESTEE",
"[#{available_testee_labels}]",
"(#{tester.testee})") do |testee|
tester.testee = testee
case tester.testee
when "groonga-httpd"
tester.interface = "http"
when "groonga-nginx"
tester.interface = "http"
tester.groonga_httpd = "nginx" unless custom_groonga_httpd
end
end
parser.on("--base-directory=DIRECTORY",
"Use DIRECTORY as a base directory of relative path",
"(#{tester.base_directory})") do |directory|
tester.base_directory = Pathname(directory)
end
parser.on("--database=PATH",
"Use existing database at PATH " +
"instead of creating a new database",
"(creating a new database)") do |path|
tester.database_path = path
end
parser.on("--diff=DIFF",
"Use DIFF as diff command",
"Use --diff=internal to use internal differ",
"(#{tester.diff})") do |diff|
tester.diff = diff
tester.diff_options.clear
end
diff_option_is_specified = false
parser.on("--diff-option=OPTION",
"Use OPTION as diff command",
"(#{tester.diff_options.join(' ')})") do |option|
tester.diff_options.clear if diff_option_is_specified
tester.diff_options << option
diff_option_is_specified = true
end
available_reporters = [
:mark,
:"buffered-mark",
:stream,
:inplace,
:progress,
:"benchmark-json",
]
available_reporter_labels = available_reporters.join(", ")
parser.on("--reporter=REPORTER", available_reporters,
"Report test result by REPORTER",
"[#{available_reporter_labels}]",
"(auto)") do |reporter|
tester.reporter = reporter
end
parser.on("--test=NAME",
"Run only test that name is NAME",
"If NAME is /.../, NAME is treated as regular expression",
"This option can be used multiple times") do |name|
tester.test_patterns << parse_name_or_pattern(name)
end
parser.on("--test-suite=NAME",
"Run only test suite that name is NAME",
"If NAME is /.../, NAME is treated as regular expression",
"This option can be used multiple times") do |name|
tester.test_suite_patterns << parse_name_or_pattern(name)
end
parser.on("--exclude-test=NAME",
"Exclude test that name is NAME",
"If NAME is /.../, NAME is treated as regular expression",
"This option can be used multiple times") do |name|
tester.exclude_test_patterns << parse_name_or_pattern(name)
end
parser.on("--exclude-test-suite=NAME",
"Exclude test suite that name is NAME",
"If NAME is /.../, NAME is treated as regular expression",
"This option can be used multiple times") do |name|
tester.exclude_test_suite_patterns << parse_name_or_pattern(name)
end
parser.on("--n-workers=N", Integer,
"Use N workers to run tests",
"(#{tester.n_workers})") do |n|
tester.n_workers = n
end
parser.on("--gdb[=COMMAND]",
"Run Groonga on gdb and use COMMAND as gdb",
"(#{tester.default_gdb})") do |command|
tester.gdb = command || tester.default_gdb
end
parser.on("--rr[=COMMAND]",
"Run Groonga on 'rr record' and use COMMAND as rr",
"(#{tester.default_rr})") do |command|
tester.rr = command || tester.default_rr
end
parser.on("--valgrind[=COMMAND]",
"Run Groonga on valgrind and use COMMAND as valgrind",
"(#{tester.default_valgrind})") do |command|
tester.valgrind = command || tester.default_valgrind
end
parser.on("--[no-]valgrind-gen-suppressions",
"Generate suppressions for Valgrind",
"(#{tester.valgrind_gen_suppressions?})") do |boolean|
tester.valgrind_gen_suppressions = boolean
end
parser.on("--[no-]keep-database",
"Keep used database for debug after test is finished",
"(#{tester.keep_database?})") do |boolean|
tester.keep_database = boolean
end
parser.on("--[no-]stop-on-failure",
"Stop immediately on the first non success test",
"(#{tester.stop_on_failure?})") do |boolean|
tester.stop_on_failure = boolean
end
parser.on("--no-suppress-omit-log",
"Suppress omit logs",
"(#{tester.suppress_omit_log?})") do |boolean|
tester.suppress_omit_log = boolean
end
parser.on("--no-suppress-backtrace",
"Suppress backtrace",
"(#{tester.suppress_backtrace?})") do |boolean|
tester.suppress_backtrace = boolean
end
parser.on("--output=OUTPUT",
"Output to OUTPUT",
"(stdout)") do |output|
tester.output = File.open(output, "w:ascii-8bit")
end
parser.on("--[no-]use-color",
"Enable colorized output",
"(auto)") do |use_color|
tester.use_color = use_color
end
parser.on("--timeout=SECOND", Float,
"Timeout for each test",
"(#{tester.timeout})") do |timeout|
tester.timeout = timeout
end
parser.on("--read-timeout=SECOND", Float,
"Timeout for each read in test",
"(#{tester.read_timeout})") do |timeout|
tester.read_timeout = timeout
end
parser.on("--[no-]debug",
"Enable debug information",
"(#{tester.debug?})") do |debug|
tester.debug = debug
end
parser.on("--n-retries=N", Integer,
"Retry N times on failure",
"(#{tester.n_retries})") do |n|
tester.n_retries = n
end
parser.on("--shutdown-wait-timeout=SECOND", Float,
"Timeout for waiting shutdown",
"(#{tester.shutdown_wait_timeout})") do |timeout|
tester.shutdown_wait_timeout = timeout
end
parser.on("--random-seed=SEED", Integer,
"Seed for random numbers") do |seed|
srand(seed)
end
parser.on("--[no-]benchmark",
"Set options for benchmark") do |benchmark|
if benchmark
tester.n_workers = 1
tester.reporter = :"benchmark-json"
end
end
parser.on("--version",
"Show version and exit") do
puts(VERSION)
throw(tag, true)
end
parser
end