grntest 1.0.1 → 1.0.2

data/.yardopts

@@ -0,0 +1,5 @@
+--output-dir doc/reference/en
+--markup markdown
+--markup-provider redcarpet
+-
+doc/text/*

data/README.md

@@ -212,6 +212,9 @@ Here are available `NAME` s:
 * `suggest-create-dataset`
 * `include`
 * `copy-path`
+* `long-timeout`
+* `on-error`
+* `omit`
 
 `ARGUMENTS...` are depends on directive. A directive doesn't require
 any arguments but a directive requires arguments.
@@ -245,7 +248,7 @@ select Users --query _key:User29
 
 See also: `enable-logging`
 
-### `enable-logging`
+#### `enable-logging`
 
 Usage:
 
@@ -257,7 +260,7 @@ It enables logging that is disabled by `disable-logging` directive.
 
 See also: `disable-logging`
 
-### suggest-create-dataset
+#### `suggest-create-dataset`
 
 Usage:
 
@@ -284,7 +287,7 @@ load --table event_rurema --each 'suggest_preparer(_id, type, item, sequence, ti
 
 See also: `--groonga-suggest-create-dataset` option
 
-### include
+#### `include`
 
 Usage:
 
@@ -339,9 +342,9 @@ select Users --query _key:Alice
 
 See also: `--base-directory` option
 
-### `copy-path`
+#### `copy-path`
 
-Usage
+Usage:
 
 ```
 #@copy-path SOURCE DESTINATION
@@ -357,6 +360,75 @@ Example:
 register "query_expanders/tsv"
 ```
 
+#### `long-timeout`
+
+Usage:
+
+```
+#@long-timeout TIMEOUT
+```
+
+It specifies a timeout for commands that may take long time.
+`TIMEOUT` must be a number or `default`. If you specify `default` as
+`TIMEOUT`, the default timeout is used. The default timeout is 180
+seconds.
+
+Here are the commands that may take long time:
+
+* `column_create`
+* `register`
+
+Example:
+
+```
+# Wait 300 seconds until commands that may take long time output their results
+#@long-timeout 300
+column_create Lexicon users_name COLUMN_INDEX Users name
+# Reset custom timeout for commands that may take long time.
+#@long-timeout default
+```
+
+#### `on-error`
+
+Usage:
+
+```
+#@on-error ACTION
+```
+
+It specifies a action on error. `ACTION` must be `default` or
+`omit`. If you specify `default` as `ACTION`, the running test is
+continued. If you specify `omit` as `ACTION`, the running test is
+aborted and the running test is marked as omitted.
+
+Example:
+
+```
+# Omit this test if TokenKyTea tokenizer isn't available.
+#@on-error omit
+register tokenizers/kytea
+# Don't omit this test when any error is occurred in the following commands.
+#@on-error default
+```
+
+#### `omit`
+
+Usage:
+
+```
+#@omit REASON
+```
+
+Omit the test with `REASON`.
+
+Example:
+
+```
+# Omit this test until the feature is implemented.
+#@omit "This feature is not implemented yet."
+new_excelent_command
+```
+
 ## Options
 
 Grntest has many options. You don't need to specify many of them

data/doc/text/news.md

@@ -1,5 +1,22 @@
 # News
 
+## 1.0.2: 2012-12-11
+
+This is the release that add some directive.
+
+### Improvements
+
+  * Used long timeout for `column_create` and `register`.
+  * Added `long-timeout` directive.
+  * Added `on-error` directive.
+  * Added "omit" status and `omit` directive.
+  * Aborted a test when a command in it can't be parsed by
+    Groonga::Command::Parser.
+
+### Fixes
+
+  * Used stty only when the standard input is tty.
+
 ## 1.0.1: 2012-10-15
 
 This has a backward incompatible change. It is directive syntax.
@@ -12,7 +29,7 @@ New:
 
     #@NAME ARGUMENT
 
-This change is for easy to debug. Conssider about we have a typo in
+This change is for easy to debug. Consider about we have a typo in
 `NAME`. It is just ignored in old syntax because it is also a comment
 line. It is reported in new syntax because it syntax is only for
 directive. Grntest can know that user want to use a directive. If

data/grntest.gemspec

@@ -35,6 +35,7 @@ Gem::Specification.new do |spec|
   spec.summary, spec.description, = description.split(/\n\n+/, 3)
   spec.license = "GPLv3 or later"
   spec.files = ["README.md", "Rakefile", "Gemfile", "#{spec.name}.gemspec"]
+  spec.files += [".yardopts"]
   spec.files += Dir.glob("lib/**/*.rb")
   spec.files += Dir.glob("doc/text/*")
   spec.test_files += Dir.glob("test/**/*")
@@ -42,12 +43,14 @@ Gem::Specification.new do |spec|
     spec.executables = Dir.glob("*")
   end
 
-  spec.add_dependency("json")
-  spec.add_dependency("msgpack")
+  spec.add_runtime_dependency("json")
+  spec.add_runtime_dependency("msgpack")
+  spec.add_runtime_dependency("groonga-command")
 
   spec.add_development_dependency("bundler")
   spec.add_development_dependency("rake")
   spec.add_development_dependency("test-unit")
+  spec.add_development_dependency("test-unit-rr")
   spec.add_development_dependency("packnga")
   spec.add_development_dependency("redcarpet")
 end

data/lib/grntest/tester.rb

@@ -22,11 +22,12 @@ require "fileutils"
 require "tempfile"
 require "shellwords"
 require "open-uri"
-require "cgi/util"
 
 require "json"
 require "msgpack"
 
+require "groonga/command"
+
 require "grntest/version"
 
 module Grntest
@@ -407,13 +408,14 @@ module Grntest
 
     class WorkerResult < Result
       attr_reader :n_tests, :n_passed_tests, :n_leaked_tests
-      attr_reader :n_not_checked_tests
+      attr_reader :n_omitted_tests, :n_not_checked_tests
       attr_reader :failed_tests
       def initialize
         super
         @n_tests = 0
         @n_passed_tests = 0
         @n_leaked_tests = 0
+        @n_omitted_tests = 0
         @n_not_checked_tests = 0
         @failed_tests = []
       end
@@ -422,23 +424,27 @@ module Grntest
         @failed_tests.size
       end
 
-      def test_finished
+      def on_test_finish
         @n_tests += 1
       end
 
-      def test_passed
+      def on_test_success
         @n_passed_tests += 1
       end
 
-      def test_failed(name)
+      def on_test_failure(name)
         @failed_tests << name
       end
 
-      def test_leaked(name)
+      def on_test_leak(name)
         @n_leaked_tests += 1
       end
 
-      def test_not_checked
+      def on_test_omission
+        @n_omitted_tests += 1
+      end
+
+      def on_test_no_check
         @n_not_checked_tests += 1
       end
     end
@@ -471,16 +477,16 @@ module Grntest
         succeeded = true
 
         @result.measure do
-          @reporter.start_worker(self)
+          @reporter.on_worker_start(self)
           catch do |tag|
             loop do
               suite_name, test_script_path, test_name = queue.pop
               break if test_script_path.nil?
 
               unless @suite_name == suite_name
-                @reporter.finish_suite(self) if @suite_name
+                @reporter.on_suite_finish(self) if @suite_name
                 @suite_name = suite_name
-                @reporter.start_suite(self)
+                @reporter.on_suite_start(self)
               end
               @test_script_path = test_script_path
               @test_name = test_name
@@ -490,48 +496,54 @@ module Grntest
               break if interruptted?
             end
             @status = "finished"
-            @reporter.finish_suite(@suite_name) if @suite_name
+            @reporter.on_suite_finish(@suite_name) if @suite_name
             @suite_name = nil
           end
         end
-        @reporter.finish_worker(self)
+        @reporter.on_worker_finish(self)
 
         succeeded
       end
 
-      def start_test
+      def on_test_start
         @status = "running"
         @test_result = nil
-        @reporter.start_test(self)
+        @reporter.on_test_start(self)
       end
 
-      def pass_test(result)
+      def on_test_success(result)
         @status = "passed"
-        @result.test_passed
-        @reporter.pass_test(self, result)
+        @result.on_test_success
+        @reporter.on_test_success(self, result)
       end
 
-      def fail_test(result)
+      def on_test_failure(result)
         @status = "failed"
-        @result.test_failed(test_name)
-        @reporter.fail_test(self, result)
+        @result.on_test_failure(test_name)
+        @reporter.on_test_failure(self, result)
       end
 
-      def leaked_test(result)
+      def on_test_leak(result)
         @status = "leaked(#{result.n_leaked_objects})"
-        @result.test_leaked(test_name)
-        @reporter.leaked_test(self, result)
+        @result.on_test_leak(test_name)
+        @reporter.on_test_leak(self, result)
       end
 
-      def not_checked_test(result)
+      def on_test_omission(result)
+        @status = "omitted"
+        @result.on_test_omission
+        @reporter.on_test_omission(self, result)
+      end
+
+      def on_test_no_check(result)
         @status = "not checked"
-        @result.test_not_checked
-        @reporter.not_checked_test(self, result)
+        @result.on_test_no_check
+        @reporter.on_test_no_check(self, result)
       end
 
-      def finish_test(result)
-        @result.test_finished
-        @reporter.finish_test(self, result)
+      def on_test_finish(result)
+        @result.on_test_finish
+        @reporter.on_test_finish(self, result)
         @test_script_path = nil
         @test_name = nil
       end
@@ -571,6 +583,10 @@ module Grntest
         collect_count(:n_leaked_tests)
       end
 
+      def n_omitted_tests
+        collect_count(:n_omitted_tests)
+      end
+
       def n_not_checked_tests
         collect_count(:n_not_checked_tests)
       end
@@ -597,7 +613,7 @@ module Grntest
         @result.measure do
           succeeded = run_test_suites(test_suites)
         end
-        @reporter.finish(@result)
+        @reporter.on_finish(@result)
 
         succeeded
       end
@@ -623,7 +639,7 @@ module Grntest
           workers << Worker.new(i, @tester, @result, @reporter)
         end
         @result.workers = workers
-        @reporter.start(@result)
+        @reporter.on_start(@result)
 
         succeeded = true
         worker_threads = []
@@ -660,6 +676,7 @@ module Grntest
     class TestResult < Result
       attr_accessor :worker_id, :test_name
       attr_accessor :expected, :actual, :n_leaked_objects
+      attr_writer :omitted
       def initialize(worker)
         super()
         @worker_id = worker.id
@@ -667,9 +684,12 @@ module Grntest
         @actual = nil
         @expected = nil
         @n_leaked_objects = 0
+        @omitted = false
       end
 
       def status
+        return :omitted if omitted?
+
         if @expected
           if @actual == @expected
             if @n_leaked_objects.zero?
@@ -688,6 +708,51 @@ module Grntest
           end
         end
       end
+
+      def omitted?
+        @omitted
+      end
+    end
+
+    class ResponseParser
+      class << self
+        def parse(content, type)
+          parser = new(type)
+          parser.parse(content)
+        end
+      end
+
+      def initialize(type)
+        @type = type
+      end
+
+      def parse(content)
+        case @type
+        when "json", "msgpack"
+          parse_result(content.chomp)
+        else
+          content
+        end
+      end
+
+      def parse_result(result)
+        case @type
+        when "json"
+          begin
+            JSON.parse(result)
+          rescue JSON::ParserError
+            raise ParseError.new(@type, result, $!.message)
+          end
+        when "msgpack"
+          begin
+            MessagePack.unpack(result.chomp)
+          rescue MessagePack::UnpackError, NoMemoryError
+            raise ParseError.new(@type, result, $!.message)
+          end
+        else
+          raise ParseError.new(@type, result, "unknown type")
+        end
+      end
     end
 
     class TestRunner
@@ -703,35 +768,37 @@ module Grntest
       def run
         succeeded = true
 
-        @worker.start_test
+        @worker.on_test_start
         result = TestResult.new(@worker)
         result.measure do
-          result.actual = execute_groonga_script
+          execute_groonga_script(result)
         end
         normalize_actual_result(result)
         result.expected = read_expected_result
         case result.status
         when :success
-          @worker.pass_test(result)
+          @worker.on_test_success(result)
           remove_reject_file
         when :failure
-          @worker.fail_test(result)
+          @worker.on_test_failure(result)
           output_reject_file(result.actual)
           succeeded = false
         when :leaked
-          @worker.leaked_test(result)
+          @worker.on_test_leak(result)
           succeeded = false
+        when :omitted
+          @worker.on_test_omission(result)
         else
-          @worker.not_checked_test(result)
+          @worker.on_test_no_check(result)
           output_actual_file(result.actual)
         end
-        @worker.finish_test(result)
+        @worker.on_test_finish(result)
 
         succeeded
       end
 
       private
-      def execute_groonga_script
+      def execute_groonga_script(result)
         create_temporary_directory do |directory_path|
           if @tester.database_path
             db_path = Pathname(@tester.database_path).expand_path
@@ -751,7 +818,8 @@ module Grntest
             executor.execute(test_script_path)
           end
           check_memory_leak(context)
-          context.result
+          result.omitted = context.omitted?
+          result.actual = context.result
         end
       end
 
@@ -781,11 +849,14 @@ module Grntest
           create_empty_database(context.db_path.to_s)
         end
 
-        case @tester.interface
-        when :stdio
-          run_groonga_stdio(context, &block)
-        when :http
-          run_groonga_http(context, &block)
+        catch do |tag|
+          context.abort_tag = tag
+          case @tester.interface
+          when :stdio
+            run_groonga_stdio(context, &block)
+          when :http
+            run_groonga_http(context, &block)
+          end
         end
       end
 
@@ -1022,7 +1093,7 @@ EOF
           status = nil
           values = nil
           begin
-            status, *values = parse_result(content.chomp, type)
+            status, *values = ResponseParser.parse(content.chomp, type)
           rescue ParseError
             return $!.message
           end
@@ -1038,25 +1109,6 @@ EOF
         end
       end
 
-      def parse_result(result, type)
-        case type
-        when "json"
-          begin
-            JSON.parse(result)
-          rescue JSON::ParserError
-            raise ParseError.new(type, result, $!.message)
-          end
-        when "msgpack"
-          begin
-            MessagePack.unpack(result.chomp)
-          rescue MessagePack::UnpackError, NoMemoryError
-            raise ParseError.new(type, result, $!.message)
-          end
-        else
-          raise ParseError.new(type, result, "unknown type")
-        end
-      end
-
       def normalize_status(status)
         return_code, started_time, elapsed_time, *rest = status
         _ = started_time = elapsed_time # for suppress warnings
@@ -1135,6 +1187,8 @@ EOF
         attr_accessor :groonga_suggest_create_dataset
         attr_accessor :result
         attr_accessor :output_type
+        attr_accessor :on_error
+        attr_accessor :abort_tag
         def initialize
           @logging = true
           @base_directory = Pathname(".")
@@ -1145,6 +1199,9 @@ EOF
           @result = []
           @output_type = "json"
           @log = nil
+          @on_error = :default
+          @abort_tag = nil
+          @omitted = false
         end
 
         def logging?
@@ -1173,6 +1230,30 @@ EOF
         def relative_db_path
           @db_path.relative_path_from(@temporary_directory_path)
         end
+
+        def omitted?
+          @omitted
+        end
+
+        def error
+          case @on_error
+          when :omit
+            omit
+          end
+        end
+
+        def omit
+          @omitted = true
+          abort
+        end
+
+        def abort
+          throw @abort_tag
+        end
+      end
+
+      module ReturnCode
+        SUCCESS = 0
       end
 
       attr_reader :context
@@ -1182,6 +1263,7 @@ EOF
         @pending_load_command = nil
         @current_command_name = nil
         @output_type = nil
+        @long_timeout = default_long_timeout
         @context = context || Context.new
       end
 
@@ -1192,17 +1274,19 @@ EOF
 
         @context.execute do
           script_path.open("r:ascii-8bit") do |script_file|
+            parser = create_parser
             script_file.each_line do |line|
               begin
-                if @loading
-                  execute_line_on_loading(line)
-                else
-                  execute_line_with_continuation_line_support(line)
-                end
-              rescue Error
+                parser << line
+              rescue Error, Groonga::Command::ParseError
                 line_info = "#{script_path}:#{script_file.lineno}:#{line.chomp}"
                 log_error("#{line_info}: #{$!.message}")
-                raise unless @context.top_level?
+                if $!.is_a?(Groonga::Command::ParseError)
+                  @context.abort
+                else
+                  log_error("#{line_info}: #{$!.message}")
+                  raise unless @context.top_level?
+                end
               end
             end
           end
@@ -1212,42 +1296,21 @@ EOF
       end
 
       private
-      def execute_line_on_loading(line)
-        log_input(line)
-        @pending_load_command << line
-        if line == "]\n"
-          execute_command(@pending_load_command)
-          @pending_load_command = nil
-          @loading = false
-        end
-      end
-
-      def execute_line_with_continuation_line_support(line)
-        if /\\$/ =~ line
-          @pending_command << $PREMATCH
-        else
-          if @pending_command.empty?
-            execute_line(line)
-          else
-            @pending_command << line
-            execute_line(@pending_command)
-            @pending_command = ""
+      def create_parser
+        parser = Groonga::Command::Parser.new
+        parser.on_command do |command|
+          execute_command(command)
+        end
+        parser.on_load_complete do |command|
+          execute_command(command)
+        end
+        parser.on_comment do |comment|
+          if /\A@/ =~ comment
+            directive_content = $POSTMATCH
+            execute_directive("\##{comment}", directive_content)
           end
         end
-      end
-
-      def execute_line(line)
-        case line
-        when /\A\#@/
-          directive_content = $POSTMATCH
-          execute_directive(line, directive_content)
-        when /\A\s*\z/
-          # do nothing
-        when /\A\s*\#/
-          # ignore comment
-        else
-          execute_command_line(line)
-        end
+        parser
       end
 
       def resolve_path(path)
@@ -1295,6 +1358,54 @@ EOF
         FileUtils.cp_r(source.to_s, destination.to_s)
       end
 
+      def execute_directive_long_timeout(line, content, options)
+        long_timeout, = options
+        invalid_value_p = false
+        case long_timeout
+        when "default"
+          @long_timeout = default_long_timeout
+        when nil
+          invalid_value_p = true
+        else
+          begin
+            @long_timeout = Float(long_timeout)
+          rescue ArgumentError
+            invalid_value_p = true
+          end
+        end
+
+        if invalid_value_p
+          log_input(line)
+          message = "long-timeout must be number or 'default': <#{long_timeout}>"
+          log_error("#|e| [long-timeout] #{message}")
+        end
+      end
+
+      def execute_directive_on_error(line, content, options)
+        action, = options
+        invalid_value_p = false
+        valid_actions = ["default", "omit"]
+        if valid_actions.include?(action)
+          @context.on_error = action.to_sym
+        else
+          invalid_value_p = true
+        end
+
+        if invalid_value_p
+          log_input(line)
+          valid_actions_label = "[#{valid_actions.join(', ')}]"
+          message = "on-error must be one of #{valid_actions_label}"
+          log_error("#|e| [on-error] #{message}: <#{action}>")
+        end
+      end
+
+      def execute_directive_omit(line, content, options)
+        reason, = options
+        @output_type = "raw"
+        log_output("omit: #{reason}")
+        @context.omit
+      end
+
       def execute_directive(line, content)
         command, *options = Shellwords.split(content)
         case command
@@ -1308,6 +1419,12 @@ EOF
           execute_directive_include(line, content, options)
         when "copy-path"
           execute_directive_copy_path(line, content, options)
+        when "long-timeout"
+          execute_directive_long_timeout(line, content, options)
+        when "on-error"
+          execute_directive_on_error(line, content, options)
+        when "omit"
+          execute_directive_omit(line, content, options)
         else
           log_input(line)
           log_error("#|e| unknown directive: <#{command}>")
@@ -1335,46 +1452,24 @@ EOF
         executor.execute(resolve_path(script_path))
       end
 
-      def execute_command_line(command_line)
-        extract_command_info(command_line)
-        log_input(command_line)
-        if multiline_load_command?
-          @loading = true
-          @pending_load_command = command_line.dup
-        else
-          execute_command(command_line)
-        end
-      end
-
-      def extract_command_info(command_line)
-        @current_command, *@current_arguments = Shellwords.split(command_line)
-        if @current_command == "dump"
+      def extract_command_info(command)
+        @current_command = command
+        if @current_command.name == "dump"
           @output_type = "groonga-command"
         else
-          @output_type = @context.output_type
-          @current_arguments.each_with_index do |word, i|
-            if /\A--output_type(?:=(.+))?\z/ =~ word
-              @output_type = $1 || words[i + 1]
-              break
-            end
-          end
-        end
-      end
-
-      def have_output_type_argument?
-        @current_arguments.any? do |argument|
-          /\A--output_type(?:=.+)?\z/ =~ argument
+          @output_type = @current_command[:output_type] || @context.output_type
         end
       end
 
-      def multiline_load_command?
-        @current_command == "load" and
-          not @current_arguments.include?("--values")
-      end
-
       def execute_command(command)
-        log_output(send_command(command))
+        extract_command_info(command)
+        log_input("#{command.original_source}\n")
+        response = send_command(command)
+        type = @output_type
+        log_output(response)
         log_error(read_error_log)
+
+        @context.error if error_response?(response, type)
       end
 
       def read_error_log
@@ -1396,8 +1491,10 @@ EOF
         timeout = first_timeout
         while IO.select([output], [], [], timeout)
           break if output.eof?
-          content << output.readpartial(65535)
-          timeout = 0
+          request_bytes = 1024
+          read_content = output.readpartial(request_bytes)
+          content << read_content
+          timeout = 0 if read_content.bytesize < request_bytes
         end
         content
       end
@@ -1410,6 +1507,18 @@ EOF
         message.start_with?("/")
       end
 
+      def error_response?(response, type)
+        status = nil
+        begin
+          status, = ResponseParser.parse(response, type)
+        rescue ParseError
+          return false
+        end
+
+        return_code, = status
+        return_code != ReturnCode::SUCCESS
+      end
+
       def log(tag, content, options={})
         return unless @context.logging?
         log_force(tag, content, options)
@@ -1435,6 +1544,10 @@ EOF
       def log_error(content)
         log_force(:error, content, {})
       end
+
+      def default_long_timeout
+        180
+      end
     end
 
     class StandardIOExecutor < Executor
@@ -1444,12 +1557,14 @@ EOF
         @output = output
       end
 
-      def send_command(command_line)
-        unless have_output_type_argument?
+      def send_command(command)
+        command_line = @current_command.original_source
+        unless @current_command.has_key?(:output_type)
           command_line = command_line.sub(/$/, " --output_type #{@output_type}")
         end
         begin
           @input.print(command_line)
+          @input.print("\n")
           @input.flush
         rescue SystemCallError
           message = "failed to write to groonga: <#{command_line}>: #{$!}"
@@ -1470,7 +1585,17 @@ EOF
 
       private
       def read_output
-        read_all_readable_content(@output)
+        options = {}
+        options[:first_timeout] = @long_timeout if may_slow_command?
+        read_all_readable_content(@output, options)
+      end
+
+      MAY_SLOW_COMMANDS = [
+        "column_create",
+        "register",
+      ]
+      def may_slow_command?
+        MAY_SLOW_COMMANDS.include?(@current_command)
       end
     end
 
@@ -1517,84 +1642,8 @@ EOF
       end
 
       def to_url
-        command = nil
-        arguments = nil
-        load_values = ""
-        @gqtp_command.each_line.with_index do |line, i|
-          if i.zero?
-            command, *arguments = Shellwords.split(line)
-          else
-            load_values << line
-          end
-        end
-        arguments.concat(["--values", load_values]) unless load_values.empty?
-
-        named_arguments = convert_to_named_arguments(command, arguments)
-        build_url(command, named_arguments)
-      end
-
-      private
-      def convert_to_named_arguments(command, arguments)
-        named_arguments = {}
-
-        last_argument_name = nil
-        n_non_named_arguments = 0
-        arguments.each do |argument|
-          if /\A--/ =~ argument
-            last_argument_name = $POSTMATCH
-            next
-          end
-
-          if last_argument_name.nil?
-            argument_name = arguments_name(command)[n_non_named_arguments]
-            n_non_named_arguments += 1
-          else
-            argument_name = last_argument_name
-            last_argument_name = nil
-          end
-
-          named_arguments[argument_name] = argument
-        end
-
-        named_arguments
-      end
-
-      def arguments_name(command)
-        case command
-        when "table_create"
-          ["name", "flags", "key_type", "value_type", "default_tokenizer"]
-        when "column_create"
-          ["table", "name", "flags", "type", "source"]
-        when "load"
-          ["values", "table", "columns", "ifexists", "input_type"]
-        when "select"
-          ["table"]
-        when "suggest"
-          [
-            "types", "table", "column", "query", "sortby",
-            "output_columns", "offset", "limit", "frequency_threshold",
-            "conditional_probability_threshold", "prefix_search"
-          ]
-        when "truncate"
-          ["table"]
-        when "get"
-          ["table", "key", "output_columns", "id"]
-        else
-          nil
-        end
-      end
-
-      def build_url(command, named_arguments)
-        url = "/d/#{command}"
-        query_parameters = []
-        named_arguments.each do |name, argument|
-          query_parameters << "#{CGI.escape(name)}=#{CGI.escape(argument)}"
-        end
-        unless query_parameters.empty?
-          url << "?"
-          url << query_parameters.join("&")
-        end
-        url
+        command = Groonga::Command::Parser.parse(@gqtp_command)
+        command.to_uri_format
       end
     end
 
@@ -1623,27 +1672,30 @@ EOF
         puts(colorize(summary, result))
       end
 
-      def statistics_header
-        items = [
-          "tests/sec",
-          "tests",
-          "passes",
-          "failures",
-          "leaked",
-          "!checked",
+      def columns
+        [
+          # label,      format value
+          ["tests/sec", lambda {|result| "%9.2f" % throughput(result)}],
+          ["   tests",  lambda {|result| "%8d"   % result.n_tests}],
+          ["  passes",  lambda {|result| "%8d"   % result.n_passed_tests}],
+          ["failures",  lambda {|result| "%8d"   % result.n_failed_tests}],
+          ["  leaked",  lambda {|result| "%8d"   % result.n_leaked_tests}],
+          [" omitted",  lambda {|result| "%8d"   % result.n_omitted_tests}],
+          ["!checked",  lambda {|result| "%8d"   % result.n_not_checked_tests}],
         ]
-        "  " + ((["%-9s"] * items.size).join(" | ") % items) + " |"
+      end
+
+      def statistics_header
+        labels = columns.collect do |label, format_value|
+          label
+        end
+        "  " + labels.join(" | ") + " |"
       end
 
       def statistics(result)
-        items = [
-          "%9.2f" % throughput(result),
-          "%9d" % result.n_tests,
-          "%9d" % result.n_passed_tests,
-          "%9d" % result.n_failed_tests,
-          "%9d" % result.n_leaked_tests,
-          "%9d" % result.n_not_checked_tests,
-        ]
+        items = columns.collect do |label, format_value|
+          format_value.call(result)
+        end
         "  " + items.join(" | ") + " |"
       end
 
@@ -1764,7 +1816,9 @@ EOF
       end
 
       def guess_term_width_from_stty
-        case `stty -a`
+        return nil unless STDIN.tty?
+
+        case tty_info
         when /(\d+) columns/
           $1
         when /columns (\d+)/
@@ -1772,8 +1826,14 @@ EOF
         else
           nil
         end
-      rescue SystemCallError
-        nil
+      end
+
+      def tty_info
+        begin
+          `stty -a`
+        rescue SystemCallError
+          nil
+        end
       end
 
       def string_width(string)
@@ -1788,6 +1848,8 @@ EOF
             :failure
           elsif result.n_leaked_tests > 0
             :leaked
+          elsif result.n_omitted_tests > 0
+            :omitted
           elsif result.n_not_checked_tests > 0
             :not_checked
           else
@@ -1810,6 +1872,8 @@ EOF
           "%s%s%s" % [failure_color, message, reset_color]
         when :leaked
           "%s%s%s" % [leaked_color, message, reset_color]
+        when :omitted
+          "%s%s%s" % [omitted_color, message, reset_color]
         when :not_checked
           "%s%s%s" % [not_checked_color, message, reset_color]
         else
@@ -1856,6 +1920,19 @@ EOF
                         })
       end
 
+      def omitted_color
+        escape_sequence({
+                          :color => :blue,
+                          :color_256 => [0, 0, 1],
+                          :background => true,
+                        },
+                        {
+                          :color => :white,
+                          :color_256 => [5, 5, 5],
+                          :bold => true,
+                        })
+      end
+
       def not_checked_color
         escape_sequence({
                           :color => :cyan,
@@ -1930,25 +2007,25 @@ EOF
         super
       end
 
-      def start(result)
+      def on_start(result)
       end
 
-      def start_worker(worker)
+      def on_worker_start(worker)
       end
 
-      def start_suite(worker)
+      def on_suite_start(worker)
       end
 
-      def start_test(worker)
+      def on_test_start(worker)
       end
 
-      def pass_test(worker, result)
+      def on_test_success(worker, result)
         synchronize do
           report_test_result_mark(".", result)
         end
       end
 
-      def fail_test(worker, result)
+      def on_test_failure(worker, result)
         synchronize do
           report_test_result_mark("F", result)
           puts
@@ -1957,13 +2034,22 @@ EOF
         end
       end
 
-      def leaked_test(worker, result)
+      def on_test_leak(worker, result)
         synchronize do
           report_test_result_mark("L(#{result.n_leaked_objects})", result)
         end
       end
 
-      def not_checked_test(worker, result)
+      def on_test_omission(worker, result)
+        synchronize do
+          report_test_result_mark("O", result)
+          puts
+          report_test(worker, result)
+          report_actual(result)
+        end
+      end
+
+      def on_test_no_check(worker, result)
         synchronize do
           report_test_result_mark("N", result)
           puts
@@ -1972,16 +2058,16 @@ EOF
         end
       end
 
-      def finish_test(worker, result)
+      def on_test_finish(worker, result)
       end
 
-      def finish_suite(worker)
+      def on_suite_finish(worker)
       end
 
-      def finish_worker(worker_id)
+      def on_worker_finish(worker_id)
       end
 
-      def finish(result)
+      def on_finish(result)
         puts
         puts
         report_summary(result)
@@ -2006,13 +2092,13 @@ EOF
         super
       end
 
-      def start(result)
+      def on_start(result)
       end
 
-      def start_worker(worker)
+      def on_worker_start(worker)
       end
 
-      def start_suite(worker)
+      def on_suite_start(worker)
         if worker.suite_name.bytesize <= @term_width
           puts(worker.suite_name)
         else
@@ -2021,39 +2107,44 @@ EOF
         @output.flush
       end
 
-      def start_test(worker)
+      def on_test_start(worker)
         print("  #{worker.test_name}")
         @output.flush
       end
 
-      def pass_test(worker, result)
+      def on_test_success(worker, result)
         report_test_result(result, worker.status)
       end
 
-      def fail_test(worker, result)
+      def on_test_failure(worker, result)
         report_test_result(result, worker.status)
         report_failure(result)
       end
 
-      def leaked_test(worker, result)
+      def on_test_leak(worker, result)
+        report_test_result(result, worker.status)
+      end
+
+      def on_test_omission(worker, result)
         report_test_result(result, worker.status)
+        report_actual(result)
       end
 
-      def not_checked_test(worker, result)
+      def on_test_no_check(worker, result)
         report_test_result(result, worker.status)
         report_actual(result)
       end
 
-      def finish_test(worker, result)
+      def on_test_finish(worker, result)
       end
 
-      def finish_suite(worker)
+      def on_suite_finish(worker)
       end
 
-      def finish_worker(worker_id)
+      def on_worker_finish(worker_id)
       end
 
-      def finish(result)
+      def on_finish(result)
         puts
         report_summary(result)
       end
@@ -2066,59 +2157,66 @@ EOF
         @minimum_redraw_interval = 0.1
       end
 
-      def start(result)
+      def on_start(result)
         @test_suites_result = result
       end
 
-      def start_worker(worker)
+      def on_worker_start(worker)
       end
 
-      def start_suite(worker)
+      def on_suite_start(worker)
         redraw
       end
 
-      def start_test(worker)
+      def on_test_start(worker)
         redraw
       end
 
-      def pass_test(worker, result)
+      def on_test_success(worker, result)
         redraw
       end
 
-      def fail_test(worker, result)
+      def on_test_failure(worker, result)
         redraw do
           report_test(worker, result)
           report_failure(result)
         end
       end
 
-      def leaked_test(worker, result)
+      def on_test_leak(worker, result)
         redraw do
           report_test(worker, result)
           report_marker(result)
         end
       end
 
-      def not_checked_test(worker, result)
+      def on_test_omission(worker, result)
+        redraw do
+          report_test(worker, result)
+          report_actual(result)
+        end
+      end
+
+      def on_test_no_check(worker, result)
         redraw do
           report_test(worker, result)
           report_actual(result)
         end
       end
 
-      def finish_test(worker, result)
+      def on_test_finish(worker, result)
         redraw
       end
 
-      def finish_suite(worker)
+      def on_suite_finish(worker)
         redraw
       end
 
-      def finish_worker(worker)
+      def on_worker_finish(worker)
         redraw
       end
 
-      def finish(result)
+      def on_finish(result)
         draw
         puts
         report_summary(result)