groonga-query-log 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bb623843ad5665d8efc011ac13bc1e3a2b5b57deeef9c2af2f8de81e4a5a06c
-  data.tar.gz: 2cd63a89d51337d68d449f77ea0dbcf8698fa395c88a37707ce0b95a65c25bab
+  metadata.gz: 0f93f3372ace5058cc9f8b7eb9f4799ad841862ca62bb7a7045564dd509b700c
+  data.tar.gz: 274f551095b12c0d7ce61f8f3c7be8d3b55531fcf7acf06df74fedc034f918ec
 SHA512:
-  metadata.gz: a965a269d6b3f4562e55af72df38b0aaf1354fcdb27c068f9ca6c867997a130811c5386e919abb9410d3ed9895329f3a10551c5ebe01bb90845c3c9eb2cc9a73
-  data.tar.gz: dc717453f8f8f7f122eb6202c4825e543102dfd544d1f06a2c722d078e81aefa9a3949f120788f2f91bc469a98637c864a344d5acb348ecb87812509658ca4a9
+  metadata.gz: 927ce37d21309f8def6a273c01b6b16a2c21d125a4db976f35bc16df211f81393a14cef1148ff9ac79d6488aa84ea3fdcdba26a69744ec32d605c66726bf3266
+  data.tar.gz: e509b9cfa830dcaf232ab4bf6692741afc44acc03b0fbe78c0135e52dc19a8911e12a18e61581925eb2d448790226ea93dc0c5b6821d06459176d6b7a8ae1e83

data/doc/text/news.md

@@ -1,5 +1,36 @@
 # News
 
+## 1.3.1: 2018-06-18
+
+### Improvements
+
+  * `groonga-query-log-check-crash`:
+
+    * Added more crash detection patterns.
+
+  * `groonga-query-log-run-regression-test`:
+
+    * Added support for floating number accuracy difference since
+      Groonga 6.0.4.
+
+    * Added support for `sort_keys` parameter.
+
+    * Added support for drilldown.
+
+    * Added `--ignore-drilldown-key` option.
+
+    * Changed to return non-zero on failure.
+
+    * Added `--stop-on-failure` option.
+
+  * `groonga-query-log-verify-server`:
+
+    * Added `--ignore-drilldown-key` option.
+
+    * Changed to return non-zero on failure.
+
+    * Added `--stop-on-failure` option.
+
 ## 1.3.0: 2018-06-11
 
 ### Improvements

data/lib/groonga-query-log/command/check-crash.rb

@@ -147,7 +147,7 @@ module GroongaQueryLog
               end
             end
             unless @unflushed_statistics.empty?
-              puts("Unflushed statistics in #{start.iso8601}/#{last.iso8601}")
+              puts("Unflushed commands in #{start.iso8601}/#{last.iso8601}")
               @unflushed_statistics.each do |statistic|
                 puts("#{statistic.start_time.iso8601}: #{statistic.raw_command}")
               end
@@ -176,13 +176,19 @@ module GroongaQueryLog
           when "load"
             @flushed = false
             @unflushed_statistics << statistic
+          when "delete"
+            @flushed = false
+            @unflushed_statistics << statistic
           when "io_flush"
+            # TODO: Improve flushed target detection.
             @flushed = true
             @unflushed_statistics.clear
           when "database_unmap"
             @unflushed_statistics.reject! do |statistic|
               statistic.command.name == "load"
             end
+          when "table_list", "column_list"
+            # ignore
           when /\Atable_/
             @flushed = false
             @unflushed_statistics << statistic

data/lib/groonga-query-log/command/run-regression-test.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2017  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2014-2018  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -25,408 +25,433 @@ require "groonga-query-log"
 require "groonga-query-log/command/verify-server"
 
 module GroongaQueryLog
-    module Command
-      class RunRegressionTest
-        def initialize
-          @input_directory = Pathname.new(".")
-          @working_directory = Pathname.new(".")
-
-          @old_groonga = "groonga"
-          @old_database = "db.old/db"
-          @old_groonga_options = []
-
-          @new_groonga = "groonga"
-          @new_database = "db.new/db"
-          @new_groonga_options = []
-
-          @recreate_database = false
-          @load_data = true
-          @run_queries = true
-          @skip_finished_queries = false
-          @output_query_log = false
-          @care_order = true
-          @verify_cachehit_mode = false
-        end
-
-        def run(command_line)
-          option_parser = create_option_parser
-          begin
-            option_parser.parse!(command_line)
-          rescue OptionParser::ParseError => error
-            $stderr.puts(error.message)
-            return false
-          end
+  module Command
+    class RunRegressionTest
+      def initialize
+        @input_directory = Pathname.new(".")
+        @working_directory = Pathname.new(".")
+
+        @old_groonga = "groonga"
+        @old_database = "db.old/db"
+        @old_groonga_options = []
+
+        @new_groonga = "groonga"
+        @new_database = "db.new/db"
+        @new_groonga_options = []
+
+        @recreate_database = false
+        @load_data = true
+        @run_queries = true
+        @skip_finished_queries = false
+        @output_query_log = false
+        @care_order = true
+        @ignored_drilldown_keys = []
+        @stop_on_failure = false
+      end
 
-          tester = Tester.new(old_groonga_server,
-                              new_groonga_server,
-                              tester_options)
-          tester.run
+      def run(command_line)
+        option_parser = create_option_parser
+        begin
+          option_parser.parse!(command_line)
+        rescue OptionParser::ParseError => error
+          $stderr.puts(error.message)
+          return false
         end
 
-        private
-        def create_option_parser
-          parser = OptionParser.new
-          parser.version = VERSION
-
-          parser.separator("")
-          parser.separator("Path:")
-          parser.on("--input-directory=DIRECTORY",
-                    "Load schema and data from DIRECTORY.",
-                    "(#{@input_directory})") do |directory|
-            @input_directory = Pathname.new(directory)
-          end
-          parser.on("--working-directory=DIRECTORY",
-                    "Use DIRECTORY as working directory.",
-                    "(#{@working_directory})") do |directory|
-            @working_directory = Pathname.new(directory)
-          end
-
-          parser.separator("")
-          parser.separator("Throughput:")
-          parser.on("--n-clients=N", Integer,
-                    "Use N clients concurrently.",
-                    "(#{@n_clients})") do |n|
-            @n_clients = n
-          end
-
-          parser.separator("")
-          parser.separator("Old Groonga:")
-          parser.on("--old-groonga=GROONGA",
-                    "Old groonga command",
-                    "(#{@old_groonga})") do |groonga|
-            @old_groonga = groonga
-          end
-
-          parser.on("--old-groonga-option=OPTION",
-                    "Add an additional old groonga option",
-                    "You can specify this option multiple times to specify multiple groonga options",
-                    "(no options)") do |groonga_option|
-            @old_groonga_options << groonga_option
-          end
-
-          parser.separator("")
-          parser.separator("New Groonga:")
-          parser.on("--new-groonga=GROONGA",
-                    "New groonga command",
-                    "(#{@new_groonga})") do |groonga|
-            @new_groonga = groonga
-          end
-
-          parser.on("--new-groonga-option=OPTION",
-                    "Add an additional new groonga option",
-                    "You can specify this option multiple times to specify multiple groonga options",
-                    "(no options)") do |groonga_option|
-            @new_groonga_options << groonga_option
-          end
+        tester = Tester.new(old_groonga_server,
+                            new_groonga_server,
+                            tester_options)
+        tester.run
+      end
 
-          parser.separator("")
-          parser.separator("Operations:")
-          parser.on("--recreate-database",
-                    "Always recreate Groonga database") do
-            @recreate_database = true
-          end
-          parser.on("--no-load-data",
-                    "Don't load data. Just loads schema to Groonga database") do
-            @load_data = false
-          end
-          parser.on("--no-run-queries",
-                    "Don't run queries. Just creates Groonga database") do
-            @run_queries = false
-          end
-          parser.on("--skip-finished-queries",
-                    "Don't run finished query logs.") do
-            @skip_finished_queries = true
-          end
-          parser.on("--output-query-log",
-                    "Output query log in verified target Groonga servers") do
-            @output_query_log = true
-          end
-          parser.on("--no-care-order",
-                    "Don't care order of select response records") do
-            @care_order = false
-          end
+      private
+      def create_option_parser
+        parser = OptionParser.new
+        parser.version = VERSION
+
+        parser.separator("")
+        parser.separator("Path:")
+        parser.on("--input-directory=DIRECTORY",
+                  "Load schema and data from DIRECTORY.",
+                  "(#{@input_directory})") do |directory|
+          @input_directory = Pathname.new(directory)
+        end
+        parser.on("--working-directory=DIRECTORY",
+                  "Use DIRECTORY as working directory.",
+                  "(#{@working_directory})") do |directory|
+          @working_directory = Pathname.new(directory)
+        end
 
-          parser
+        parser.separator("")
+        parser.separator("Throughput:")
+        parser.on("--n-clients=N", Integer,
+                  "Use N clients concurrently.",
+                  "(#{@n_clients})") do |n|
+          @n_clients = n
         end
 
-        def directory_options
-          {
-            :input_directory   => @input_directory,
-            :working_directory => @working_directory,
-          }
+        parser.separator("")
+        parser.separator("Old Groonga:")
+        parser.on("--old-groonga=GROONGA",
+                  "Old groonga command",
+                  "(#{@old_groonga})") do |groonga|
+          @old_groonga = groonga
         end
 
-        def server_options
-          options = {
-            :load_data             => @load_data,
-            :run_queries           => @run_queries,
-            :recreate_database     => @recreate_database,
-            :output_query_log      => @output_query_log,
-          }
-          directory_options.merge(options)
+        parser.on("--old-groonga-option=OPTION",
+                  "Add an additional old groonga option",
+                  "You can specify this option multiple times to specify multiple groonga options",
+                  "(no options)") do |groonga_option|
+          @old_groonga_options << groonga_option
         end
 
-        def tester_options
-          options = {
-            :n_clients  => @n_clients,
-            :care_order => @care_order,
-            :skip_finished_queries => @skip_finished_queries,
-          }
-          directory_options.merge(options)
+        parser.separator("")
+        parser.separator("New Groonga:")
+        parser.on("--new-groonga=GROONGA",
+                  "New groonga command",
+                  "(#{@new_groonga})") do |groonga|
+          @new_groonga = groonga
         end
 
-        def old_groonga_server
-          GroongaServer.new(@old_groonga,
-                            @old_groonga_options,
-                            @old_database,
-                            server_options)
+        parser.on("--new-groonga-option=OPTION",
+                  "Add an additional new groonga option",
+                  "You can specify this option multiple times to specify multiple groonga options",
+                  "(no options)") do |groonga_option|
+          @new_groonga_options << groonga_option
         end
 
-        def new_groonga_server
-          GroongaServer.new(@new_groonga,
-                            @new_groonga_options,
-                            @new_database,
-                            server_options)
+        parser.separator("")
+        parser.separator("Operations:")
+        parser.on("--recreate-database",
+                  "Always recreate Groonga database") do
+          @recreate_database = true
+        end
+        parser.on("--no-load-data",
+                  "Don't load data. Just loads schema to Groonga database") do
+          @load_data = false
+        end
+        parser.on("--no-run-queries",
+                  "Don't run queries. Just creates Groonga database") do
+          @run_queries = false
+        end
+        parser.on("--skip-finished-queries",
+                  "Don't run finished query logs.") do
+          @skip_finished_queries = true
+        end
+        parser.on("--output-query-log",
+                  "Output query log in verified target Groonga servers") do
+          @output_query_log = true
+        end
+        parser.on("--no-care-order",
+                  "Don't care order of select response records") do
+          @care_order = false
+        end
+        parser.on("--ignore-drilldown-key=KEY",
+                  "Don't compare drilldown result for KEY",
+                  "You can specify multiple drilldown keys by",
+                  "specifying this option multiple times") do |key|
+          @ignored_drilldown_keys << key
+        end
+        parser.on("--[no-]stop-on-failure",
+                  "Stop execution on the first failure",
+                  "(#{@stop_on_failure})") do |boolean|
+          @stop_on_failure = boolean
         end
 
-        class GroongaServer
-          attr_reader :host, :port
-          def initialize(groonga, groonga_options, database_path, options)
-            @input_directory = options[:input_directory] || Pathname.new(".")
-            @working_directory = options[:working_directory] || Pathname.new(".")
-            @groonga = groonga
-            @groonga_options = groonga_options
-            @database_path = @working_directory + database_path
-            @host = "127.0.0.1"
-            @port = find_unused_port
-            @options = options
-          end
+        parser
+      end
 
-          def run
-            return unless @options[:run_queries]
+      def directory_options
+        {
+          :input_directory   => @input_directory,
+          :working_directory => @working_directory,
+        }
+      end
 
-            arguments = @groonga_options.dup
-            arguments.concat(["--bind-address", @host])
-            arguments.concat(["--port", @port.to_s])
-            arguments.concat(["--protocol", "http"])
-            arguments.concat(["--log-path", log_path.to_s])
-            if @options[:output_query_log]
-              arguments.concat(["--query-log-path", query_log_path.to_s])
-            end
-            arguments << "-s"
-            arguments << @database_path.to_s
-            @pid = spawn(@groonga, *arguments)
+      def server_options
+        options = {
+          :load_data             => @load_data,
+          :run_queries           => @run_queries,
+          :recreate_database     => @recreate_database,
+          :output_query_log      => @output_query_log,
+        }
+        directory_options.merge(options)
+      end
 
-            n_retries = 10
-            begin
-              send_command("status")
-            rescue SystemCallError
-              sleep(1)
-              n_retries -= 1
-              raise if n_retries.zero?
-              retry
-            end
+      def tester_options
+        options = {
+          :n_clients  => @n_clients,
+          :care_order => @care_order,
+          :skip_finished_queries => @skip_finished_queries,
+          :ignored_drilldown_keys => @ignored_drilldown_keys,
+          :stop_on_failure => @stop_on_failure,
+        }
+        directory_options.merge(options)
+      end
 
-            yield if block_given?
-          end
+      def old_groonga_server
+        GroongaServer.new(@old_groonga,
+                          @old_groonga_options,
+                          @old_database,
+                          server_options)
+      end
 
-          def ensure_database
-            if @options[:recreate_database]
-              FileUtils.rm_rf(@database_path.dirname.to_s)
-            end
+      def new_groonga_server
+        GroongaServer.new(@new_groonga,
+                          @new_groonga_options,
+                          @new_database,
+                          server_options)
+      end
 
-            return if @database_path.exist?
-            FileUtils.mkdir_p(@database_path.dirname.to_s)
-            system(@groonga, "-n", @database_path.to_s, "quit")
-            grn_files.each do |grn_file|
-              command = [
-                @groonga,
-                "--log-path", log_path.to_s,
-                "--file", grn_file.to_s,
-                @database_path.to_s,
-              ]
-              command_line = command.join(" ")
-              puts("Running...: #{command_line}")
-              pid = spawn(*command)
-              begin
-                pid, status = Process.waitpid2(pid)
-              rescue Interrupt
-                Process.kill(:TERM, pid)
-                pid, status = Process.waitpid2(pid)
-              end
-              unless status.success?
-                raise "Failed to run: #{command_line}"
-              end
-            end
+      class GroongaServer
+        attr_reader :host, :port
+        def initialize(groonga, groonga_options, database_path, options)
+          @input_directory = options[:input_directory] || Pathname.new(".")
+          @working_directory = options[:working_directory] || Pathname.new(".")
+          @groonga = groonga
+          @groonga_options = groonga_options
+          @database_path = @working_directory + database_path
+          @host = "127.0.0.1"
+          @port = find_unused_port
+          @options = options
+        end
+
+        def run
+          return unless @options[:run_queries]
+
+          arguments = @groonga_options.dup
+          arguments.concat(["--bind-address", @host])
+          arguments.concat(["--port", @port.to_s])
+          arguments.concat(["--protocol", "http"])
+          arguments.concat(["--log-path", log_path.to_s])
+          if @options[:output_query_log]
+            arguments.concat(["--query-log-path", query_log_path.to_s])
           end
+          arguments << "-s"
+          arguments << @database_path.to_s
+          @pid = spawn(@groonga, *arguments)
 
-          def use_persistent_cache?
-            @groonga_options.include?("--cache-base-path")
+          n_retries = 10
+          begin
+            send_command("status")
+          rescue SystemCallError
+            sleep(1)
+            n_retries -= 1
+            raise if n_retries.zero?
+            retry
           end
 
-          def shutdown
-            begin
-              send_command("shutdown")
-            rescue SystemCallError
-            end
-            Process.waitpid(@pid)
+          yield if block_given?
+        end
+
+        def ensure_database
+          if @options[:recreate_database]
+            FileUtils.rm_rf(@database_path.dirname.to_s)
           end
 
-          private
-          def find_unused_port
-            server = TCPServer.new(@host, 0)
+          return if @database_path.exist?
+          FileUtils.mkdir_p(@database_path.dirname.to_s)
+          system(@groonga, "-n", @database_path.to_s, "quit")
+          grn_files.each do |grn_file|
+            command = [
+              @groonga,
+              "--log-path", log_path.to_s,
+              "--file", grn_file.to_s,
+              @database_path.to_s,
+            ]
+            command_line = command.join(" ")
+            puts("Running...: #{command_line}")
+            pid = spawn(*command)
             begin
-              server.addr[1]
-            ensure
-              server.close
+              pid, status = Process.waitpid2(pid)
+            rescue Interrupt
+              Process.kill(:TERM, pid)
+              pid, status = Process.waitpid2(pid)
+            end
+            unless status.success?
+              raise "Failed to run: #{command_line}"
             end
           end
+        end
 
-          def log_path
-            @database_path.dirname + "groonga.log"
-          end
+        def use_persistent_cache?
+          @groonga_options.include?("--cache-base-path")
+        end
 
-          def query_log_path
-            @database_path.dirname + "query.log"
+        def shutdown
+          begin
+            send_command("shutdown")
+          rescue SystemCallError
           end
+          Process.waitpid(@pid)
+        end
 
-          def send_command(name)
-            Net::HTTP.start(@host, @port) do |http|
-              response = http.get("/d/#{name}")
-              response.body
-            end
+        private
+        def find_unused_port
+          server = TCPServer.new(@host, 0)
+          begin
+            server.addr[1]
+          ensure
+            server.close
           end
+        end
 
-          def grn_files
-            files = schema_files
-            files += data_files if @options[:load_data]
-            files += index_files
-            files
-          end
+        def log_path
+          @database_path.dirname + "groonga.log"
+        end
 
-          def schema_files
-            Pathname.glob("#{@input_directory}/schema/**/*.grn").sort
-          end
+        def query_log_path
+          @database_path.dirname + "query.log"
+        end
 
-          def index_files
-            Pathname.glob("#{@input_directory}/indexes/**/*.grn").sort
+        def send_command(name)
+          Net::HTTP.start(@host, @port) do |http|
+            response = http.get("/d/#{name}")
+            response.body
           end
+        end
 
-          def data_files
-            Pathname.glob("#{@input_directory}/data/**/*.grn").sort
-          end
+        def grn_files
+          files = schema_files
+          files += data_files if @options[:load_data]
+          files += index_files
+          files
         end
 
-        class Tester
-          def initialize(old, new, options)
-            @old = old
-            @new = new
-            @input_directory = options[:input_directory] || Pathname.new(".")
-            @working_directory = options[:working_directory] || Pathname.new(".")
-            @n_clients = options[:n_clients] || 1
-            @options = options
-            @n_ready_waits = 2
-          end
+        def schema_files
+          Pathname.glob("#{@input_directory}/schema/**/*.grn").sort
+        end
 
-          def run
-            @old.ensure_database
-            @new.ensure_database
+        def index_files
+          Pathname.glob("#{@input_directory}/indexes/**/*.grn").sort
+        end
 
-            old_thread = Thread.new do
-              @old.run do
-                run_test
-              end
-            end
-            new_thread = Thread.new do
-              @new.run do
-                run_test
-              end
-            end
+        def data_files
+          Pathname.glob("#{@input_directory}/data/**/*.grn").sort
+        end
+      end
 
-            old_thread_success = old_thread.value
-            new_thread_success = new_thread.value
+      class Tester
+        def initialize(old, new, options)
+          @old = old
+          @new = new
+          @input_directory = options[:input_directory] || Pathname.new(".")
+          @working_directory = options[:working_directory] || Pathname.new(".")
+          @n_clients = options[:n_clients] || 1
+          @stop_on_failure = options[:stop_on_failure]
+          @options = options
+          @n_ready_waits = 2
+        end
+
+        def run
+          @old.ensure_database
+          @new.ensure_database
 
-            old_thread_success and new_thread_success
+          old_thread = Thread.new do
+            @old.run do
+              run_test
+            end
+          end
+          new_thread = Thread.new do
+            @new.run do
+              run_test
+            end
           end
 
-          private
-          def run_test
-            @n_ready_waits -= 1
-            return true unless @n_ready_waits.zero?
+          old_thread_success = old_thread.value
+          new_thread_success = new_thread.value
 
-            query_log_paths.each do |query_log_path|
-              log_path = test_log_path(query_log_path)
-              if @options[:skip_finished_queries] and log_path.exist?
-                puts("Skip query log: #{query_log_path}")
-                next
-              else
-                puts("Running test against query log...: #{query_log_path}")
-              end
-              begin
-                if use_persistent_cache?
-                  callback = lambda do
-                    if @old.use_persistent_cache?
-                      @old.shutdown
-                      @old.run
-                    end
-                    if @new.use_persistent_cache?
-                      @new.shutdown
-                      @new.run
-                    end
+          old_thread_success and new_thread_success
+        end
+
+        private
+        def run_test
+          @n_ready_waits -= 1
+          return true unless @n_ready_waits.zero?
+
+          same = true
+          query_log_paths.each do |query_log_path|
+            log_path = test_log_path(query_log_path)
+            if @options[:skip_finished_queries] and log_path.exist?
+              puts("Skip query log: #{query_log_path}")
+              next
+            else
+              puts("Running test against query log...: #{query_log_path}")
+            end
+            begin
+              if use_persistent_cache?
+                callback = lambda do
+                  if @old.use_persistent_cache?
+                    @old.shutdown
+                    @old.run
+                  end
+                  if @new.use_persistent_cache?
+                    @new.shutdown
+                    @new.run
                   end
-                else
-                  callback = nil
                 end
-                verify_server(log_path, query_log_path, &callback)
-              rescue Interrupt
-                puts("Interrupt: #{query_log_path}")
+              else
+                callback = nil
               end
+              unless verify_server(log_path, query_log_path, &callback)
+                same = false
+                break if @stop_on_failure
+              end
+            rescue Interrupt
+              puts("Interrupt: #{query_log_path}")
             end
-
-            old_thread = Thread.new do
-              @old.shutdown
-            end
-            new_thread = Thread.new do
-              @new.shutdown
-            end
-            old_thread.join
-            new_thread.join
-
-            true
           end
 
-          def verify_server(test_log_path, query_log_path, &callback)
-            command_line = [
-              "--n-clients=#{@n_clients}",
-              "--groonga1-host=#{@old.host}",
-              "--groonga1-port=#{@old.port}",
-              "--groonga1-protocol=http",
-              "--groonga2-host=#{@new.host}",
-              "--groonga2-port=#{@new.port}",
-              "--groonga2-protocol=http",
-              "--output", test_log_path.to_s,
-            ]
-            command_line << "--no-care-order" if @options[:care_order] == false
-            command_line << query_log_path.to_s
-            if use_persistent_cache?
-              command_line << "--verify-cache"
-            end
-            verify_server = VerifyServer.new
-            verify_server.run(command_line, &callback)
+          old_thread = Thread.new do
+            @old.shutdown
           end
-
-          def query_log_paths
-            Pathname.glob("#{@input_directory}/query-logs/**/*.log").sort
+          new_thread = Thread.new do
+            @new.shutdown
           end
+          old_thread.join
+          new_thread.join
 
-          def test_log_path(query_log_path)
-            @working_directory + "results" + query_log_path.basename
-          end
+          same
+        end
 
-          def use_persistent_cache?
-            @old.use_persistent_cache? or @new.use_persistent_cache?
-          end
+        def verify_server(test_log_path, query_log_path, &callback)
+          command_line = [
+            "--n-clients=#{@n_clients}",
+            "--groonga1-host=#{@old.host}",
+            "--groonga1-port=#{@old.port}",
+            "--groonga1-protocol=http",
+            "--groonga2-host=#{@new.host}",
+            "--groonga2-port=#{@new.port}",
+            "--groonga2-protocol=http",
+            "--output", test_log_path.to_s,
+          ]
+          command_line << "--no-care-order" if @options[:care_order] == false
+          @options[:ignored_drilldown_keys].each do |key|
+            command_line.concat(["--ignore-drilldown-key", key])
+          end
+          command_line << query_log_path.to_s
+          if use_persistent_cache?
+            command_line << "--verify-cache"
+          end
+          if @stop_on_failure
+            command_line << "--stop-on-failure"
+          end
+          verify_server = VerifyServer.new
+          verify_server.run(command_line, &callback)
+        end
+
+        def query_log_paths
+          Pathname.glob("#{@input_directory}/query-logs/**/*.log").sort
+        end
+
+        def test_log_path(query_log_path)
+          @working_directory + "results" + query_log_path.basename
+        end
+
+        def use_persistent_cache?
+          @old.use_persistent_cache? or @new.use_persistent_cache?
         end
       end
     end
+  end
 end