# coding: utf-8
require 'spec_helper'
require 'open3'
require 'mysql2'
require 'flydata/command/sync'
require 'flydata/source_mysql/parser/dump_parser'
require 'flydata-core/mysql/binlog_pos'

module Flydata
  module SourceMysql
    module Parser
      context "Test Dump Generators" do
        let(:stdin) do
          s = double(:stdin)
          allow(s).to receive(:close_write)
          s
        end
        let(:stdout) do
          s = double(:stdout)
          allow(s).to receive(:set_encoding)
          allow(s).to receive(:wait_readable)
          allow(s).to receive(:each_line).and_yield("another line")
          s
        end
        let(:file_path) { File.join('/tmp', "flydata_sync_spec_mysqldump_#{Time.now.to_i}") }
        let(:default_conf) do
          {
            'host' => 'localhost', 'port' => 3306, 'username' => 'admin',
            'password' => 'pass', 'database' => 'dev', 'tables' => ['users','groups'],
          }
        end

        describe MysqlDumpGeneratorNoMasterData do
          let(:subject_object) { described_class.new(default_conf) }

          let(:stderr) { double(:stderr) }
          let(:wait_thr) { double(:wait_thr) }

          let(:default_dump_generator) { subject_object }
          let(:binlog_pos) { { binfile: 'mysql-bin.000451', pos: 89872 } }
          let(:mysql_client) do
            m = double(:mysql_client)
            allow(m).to receive(:query).with(/TABLES/)
            allow(m).to receive(:query).with("SHOW VARIABLES LIKE 'version'").
                        and_return([{'Value' => '5.1.40-0ubuntu0.12.04.1-log'}])
            allow(m).to receive(:query).with("FLUSH TABLES  WITH READ LOCK;", {retry_count:-1, retry_interval:1})
            allow(m).to receive(:query).with("SHOW MASTER STATUS;").
                        and_return([{'File' => 'mysql-bin.000451', 'Position' => 89872}])
            allow(m).to receive(:thread_id).and_return(1191)
            allow(m).to receive(:close)
            m
          end

          describe '#dump' do
            before do
              expect(Mysql2::Client).to receive(:new).and_return(mysql_client)
              expect(Open3).to receive(:popen3).and_yield(stdin, stdout, stderr, wait_thr)
              allow(File).to receive(:size?).and_return true
            end
            context "when mysqldump exits with status 0" do
              it do
                expect(wait_thr).to receive(:value).and_return(0)
                expect(stderr).to receive(:each_line).and_yield("")
                expect(default_dump_generator.dump(file_path)).to eq(binlog_pos)
              end
            end
            context "when mysqldump exits with status 1" do
              it do
                expect(wait_thr).to receive(:value).and_return(1)
                expect(stderr).to receive(:each_line).and_yield("")
                expect{ default_dump_generator.dump(file_path) }.to raise_error
              end
            end
            context "when mysqldump exits with status 0, but there are error in stderr" do
              it do
                expect(wait_thr).to receive(:value).and_return(0)
                expect(stderr).to receive(:each_line).and_yield("mysqldump error")
                expect{ default_dump_generator.dump(file_path) }.to raise_error
              end
            end
            after :each do
              File.delete(file_path) if File.exists?(file_path)
            end
          end

          describe '#flush_tables_with_read_lock_query' do
            subject { subject_object.send(:flush_tables_with_read_lock_query,
                      client, database, tbls) }

            let(:client) { double('client') }
            let(:database) { "db1" }
            let(:tbls) { ['table1'] }

            before do
              allow(subject_object).to receive(:mysql_server_version).
               and_return(version)
            end

            let(:flush_tables_with_tables) { <<EOS.strip }
FLUSH TABLES `db1`.`table1` WITH READ LOCK;
EOS
            let(:flush_tables_without_table) { <<EOS.strip }
FLUSH TABLES  WITH READ LOCK;
EOS

            context 'with MySQL 5.1' do
              let(:version) { "5.1.67-log" }
              it 'returns flush command without table because the syntax is only supported by MySQL 5.5 or later' do
                is_expected.to eq(flush_tables_without_table)
              end
            end
            context 'with Debian MySQL 5.5' do
              let(:version) { "5.5.24-2+deb.sury.org~precise+2-log" }
              it { is_expected.to eq(flush_tables_with_tables) }
            end
            context 'with Amazon RDS MySQL 5.6' do
              let(:version) { "5.6.19-log" }
              it { is_expected.to eq(flush_tables_with_tables) }
            end
            context 'with MariaDB 10.0' do
              let(:version) { "10.0.24-MariaDB" }
              it 'returns flush command with tables because MariaDB 10.0 is compatible with MySQL 5.6' do
                is_expected.to eq(flush_tables_with_tables)
              end
            end
            context 'with Amazon Aurora' do
              let(:version) { "5.6.10" }
              it do
                is_expected.to eq(flush_tables_with_tables)
              end
            end
          end
        end
      end

      describe FlydataMysqlClient do
        let(:db_opts) do
          {
            host: 'localhost',
            port:  3306,
            username: 'admin',
            password: 'pass',
            database: 'dev'
          }
        end
        describe '#query' do
          module DummyMysqlClient
            def initialize(opts = {})
            end
            def query(sql, opts = {})
              raise Mysql2::Error.new("Timeout waiting for a response from the last query. (waited 600 seconds)")
            end
          end
          it 'raises a timeout error as is' do
            described_class.instance_eval { include DummyMysqlClient }
            sql = "FLUSH LOCAL TABLES"
            test_client = described_class.new(db_opts)
            expect{test_client.query(sql)}.to raise_error(Mysql2::Error, "Timeout waiting for a response from the last query. (waited 600 seconds)")
            expect(test_client.last_query).to eq(sql)
          end
        end
      end

      describe MysqlDumpParser do
        let(:file_path) { File.join('/tmp', "flydata_sync_spec_mysqldump_parse_#{Time.now.to_i}") }
        let(:dump_io) { File.open(file_path, 'r', encoding: "utf-8") }
        let(:default_parser) { MysqlDumpParser.new(binlog_pos: default_binlog_pos) }

        def generate_dump_file(content)
          File.open(file_path, 'w') {|f| f.write(content)}
        end

        after do
          File.delete(file_path) if File.exists?(file_path)
        end

        describe '#parse' do
          DUMP_HEADER = <<EOT
-- MySQL dump 10.13  Distrib 5.6.13, for osx10.9 (x86_64)
--
-- Host: localhost    Database: sync_test
-- ------------------------------------------------------
-- Server version>--5.6.13-log

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

--
-- Position to start replication or point-in-time recovery from
--

-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000267', MASTER_LOG_POS=120;
EOT

          def index_after(content, string)
            content[0...content.index(string)].bytesize + string.bytesize + 1
          end

          let(:default_parser) { MysqlDumpParser.new(source_pos: default_binlog_pos_object) }
          let(:default_binlog_pos) { {binfile: 'mysql-bin.000267', pos: 120 } }
          let(:default_binlog_pos_object) { FlydataCore::Mysql::BinlogPos.new(default_binlog_pos) }
          let(:dump_pos_after_binlog_pos) { index_after(DUMP_HEADER, '5.6.13-log') }

          let(:create_table_block) { double('create_table_block') }
          let(:insert_record_block) { double('insert_record_block') }
          let(:check_point_block) { double('check_point_block') }

          before do
            generate_dump_file('')
          end

          context 'when dump contains only binlog pos' do
            before { generate_dump_file(<<EOT
#{DUMP_HEADER}
EOT
                                       ) }
            it do
              expect(create_table_block).to receive(:call).never
              expect(insert_record_block).to receive(:call).never
              expect(check_point_block).to receive(:call).once
              binlog_pos = default_parser.parse(
                dump_io, create_table_block, insert_record_block, check_point_block
              )
              expect(binlog_pos).to eq(default_binlog_pos)
            end
          end

          shared_examples 'dump contains create table without records' do
            let(:dump_content) { <<EOT
#{DUMP_HEADER}

DROP TABLE IF EXISTS `users_login`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `users_login` (
  `#{col_name}` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
  `create_time` datetime NOT NULL COMMENT 'create time',
  `update_time` datetime NOT NULL COMMENT 'update time',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='';
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `users_login`
--

LOCK TABLES `users_login` WRITE;
/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
UNLOCK TABLES;

EOT
            }
            before { generate_dump_file(dump_content) }
            it do
              expect(create_table_block).to receive(:call) { |source_table|
                expect(source_table.table_name).to eq('users_login')
              }.once
              expect(insert_record_block).to receive(:call).never
              expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
                expect(source_table).to be_nil
                expect(last_pos).to eq(dump_pos_after_binlog_pos)
                expect(binlog_pos).to eq(default_binlog_pos)
                expect(state).to eq(Flydata::Parser::State::CREATE_TABLE)
                expect(substate).to be_nil
              }
              expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
                expect(source_table.table_name).to eq('users_login')
                expect(source_table.instance_variable_get(:@columns).keys).to eq([col_name, 'login_count', 'create_time', 'update_time'])
                expect(last_pos).to eq(index_after(dump_content, 'ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT=\'\';'))
                expect(binlog_pos).to eq(default_binlog_pos)
                expect(state).to eq(Flydata::Parser::State::INSERT_RECORD)
                expect(substate).to be_nil
              }
              expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
                expect(source_table.table_name).to eq('users_login')
                expect(last_pos).to eq(index_after(dump_content, 'UNLOCK TABLES;'))
                expect(binlog_pos).to eq(default_binlog_pos)
                expect(state).to eq(Flydata::Parser::State::CREATE_TABLE)
                expect(substate).to be_nil
              }
              expect(check_point_block).to receive(:call).never

              binlog_pos = default_parser.parse(
                dump_io, create_table_block, insert_record_block, check_point_block
              )
              expect(binlog_pos).to eq(default_binlog_pos)
            end
          end

          context 'when dump contains create table without records' do
            context 'when one of the column name has space' do
              let(:col_name) { "user id" }
              include_examples 'dump contains create table without records'
            end
            context 'when the column name does not have space' do
              let(:col_name) { "user_id" }
              include_examples 'dump contains create table without records'
            end
            context 'when the column name is non-ascii' do
              let(:col_name) { "行列" }
              include_examples 'dump contains create table without records'
            end
            context 'when the column name includes special characters' do
              let(:col_name) { %q| !"#$%&'()*+,-/:;<=>?@[\\]^_{\|}~| }
              include_examples 'dump contains create table without records'
            end
            context 'when the column name includes a dot' do
              let(:col_name) { %q|my.column| }
              include_examples 'dump contains create table without records'
            end
          end

          context 'when dump contains create table with multi inserts and invalid utf8 byte sequences' do
            let(:dump_content) { <<EOT
#{DUMP_HEADER}

DROP TABLE IF EXISTS `users_login`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `users_login` (
  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
  `comment` varchar(255) DEFAULT NULL COMMENT 'comment\xED\xB1\x22end',
  `create_time` datetime NOT NULL COMMENT 'create time',
  `update_time` datetime NOT NULL COMMENT 'update time',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `users_login`
--

LOCK TABLES `users_login` WRITE;
/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
INSERT INTO `users_login` VALUES (15,46,'moodier\xED\xB1\x22','2001-10-02 08:18:08','1986-06-11 22:50:10'),(35,6,'missあいうえおteer','1991-10-15 19:38:07','1970-10-01 22:03:10'),(52,33,'sub\\\\field','1972-08-23 20:16:08','1974-10-10 23:28:11');
INSERT INTO `users_login` VALUES (373,31,'out\\'swearing','1979-10-07 08:10:08','2006-02-22 16:26:04'),(493,8,'schizophrenic','1979-07-06 07:34:07','1970-08-09 01:21:01');
/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;

EOT
            }
            before { generate_dump_file(dump_content) }
            it do
              # create_table_block
              expect(create_table_block).to receive(:call) { |source_table|
                expect(source_table.table_name).to eq('users_login')
                expect(source_table.instance_variable_get(:@columns).keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
              }.once
              expect(create_table_block).to receive(:call).never

              # insert_record_block
              [
                [ %W(15 46 moodier\uFFFD\uFFFD\uFFFD 2001-10-02\ 08:18:08 1986-06-11\ 22:50:10),
                  %w(35 6 missあいうえおteer  1991-10-15\ 19:38:07 1970-10-01\ 22:03:10),
                  %w(52 33 sub\\field 1972-08-23\ 20:16:08 1974-10-10\ 23:28:11),],
                [ %w(373 31 out'swearing 1979-10-07\ 08:10:08 2006-02-22\ 16:26:04),
                  %w(493 8 schizophrenic 1979-07-06\ 07:34:07 1970-08-09\ 01:21:01),]
              ].each do |expected_values|
                expect(insert_record_block).to receive(:call) { |source_table, values_set|
                  expect(source_table.table_name).to eq('users_login')
                  expect(values_set).to eq(expected_values)
                  nil
=begin
# Use this when _parse2 is used
                }.once
=end
# =begin
# Use this when _parse is used
                }.never
# =end
              end
              expect(insert_record_block).to receive(:call).never

              # check_point_block
              [
                {state: Flydata::Parser::State::CREATE_TABLE},
                {state: Flydata::Parser::State::INSERT_RECORD},
=begin
# Use this when _parse2 is used
                {state: Flydata::Parser::State::CREATE_TABLE,
                 last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
=end
# =begin
# Use this when _parse is used
# =end
              ].each do |expected_params|
                expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
                  expect(source_table.table_name).to eq('users_login') if source_table
                  expect(state).to eq(expected_params[:state])
                  if expected_params[:last_pos]
                    expect(last_pos).to eq(expected_params[:last_pos])
                  end
                  expect(binlog_pos).to eq(default_binlog_pos)
                  expect(substate).to eq(expected_params[:substate])
                  expected_params[:result]
                }.once
              end
              expect(check_point_block).to receive(:call).never

=begin
# Use this when _parse2 is used
              binlog_pos = default_parser.parse(
                dump_io, create_table_block, insert_record_block, check_point_block
              )
              expect(binlog_pos).to eq(default_binlog_pos)
=end
# =begin
# Use this when _parse is used
              expect {
                binlog_pos = default_parser.parse(
                  dump_io, create_table_block, insert_record_block,
                  check_point_block)
              }.to raise_error(DumpParseError)
# =end
            end
          end

          context 'when dump contains create table with records' do
            let(:dump_content) { <<EOT
#{DUMP_HEADER}

DROP TABLE IF EXISTS `users_login`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `users_login` (
  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
  `comment` varchar(255) DEFAULT NULL COMMENT 'comment',
  `create_time` datetime NOT NULL COMMENT 'create time',
  `update_time` datetime NOT NULL COMMENT 'update time',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `users_login`
--

LOCK TABLES `users_login` WRITE;
/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
INSERT INTO `users_login` VALUES (15,46,'moodier','2001-10-02 08:18:08','1986-06-11 22:50:10'),(35,6,NULL,'1991-10-15 19:38:07','1970-10-01 22:03:10'),(52,33,'subfield','1972-08-23 20:16:08','1974-10-10 23:28:11');
/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;

EOT
            }
            before { generate_dump_file(dump_content) }
            it do
              # create_table_block
              expect(create_table_block).to receive(:call) { |source_table|
                expect(source_table.table_name).to eq('users_login')
                expect(source_table.instance_variable_get(:@columns).keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
              }.once
              expect(create_table_block).to receive(:call).never

              # insert_record_block
              [
                [ %w(15 46 moodier 2001-10-02\ 08:18:08 1986-06-11\ 22:50:10),
                  ['35', '6', nil, '1991-10-15 19:38:07', '1970-10-01 22:03:10'],
                  %w(52 33 subfield 1972-08-23\ 20:16:08 1974-10-10\ 23:28:11),],
              ].each do |expected_values|
                expect(insert_record_block).to receive(:call) { |source_table, values_set|
                  expect(source_table.table_name).to eq('users_login')
                  expect(values_set).to eq(expected_values)
                  nil
                }.once
              end
              expect(insert_record_block).to receive(:call).never

              # insert_record_block
              [
                {state: Flydata::Parser::State::CREATE_TABLE},
                {state: Flydata::Parser::State::INSERT_RECORD},
                {state: Flydata::Parser::State::CREATE_TABLE,
                 last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
              ].each do |expected_params|
                expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
                  expect(source_table.table_name).to eq('users_login') if source_table
                  expect(state).to eq(expected_params[:state])
                  if expected_params[:last_pos]
                    expect(last_pos).to eq(expected_params[:last_pos])
                  end
                  expect(binlog_pos).to eq(default_binlog_pos)
                  expect(substate).to eq(expected_params[:substate])
                  expected_params[:result]
                }.once
              end
              expect(check_point_block).to receive(:call).never

              binlog_pos = default_parser.parse(
                dump_io, create_table_block, insert_record_block, check_point_block
              )
              expect(binlog_pos).to eq(default_binlog_pos)
            end
          end

          context 'with resume after creating table' do
            let(:dump_content_head) { <<EOT
#{DUMP_HEADER}

DROP TABLE IF EXISTS `users_login`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `users_login` (
  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
  `comment` varchar(255) DEFAULT NULL COMMENT 'comment',
  `create_time` datetime NOT NULL COMMENT 'create time',
  `update_time` datetime NOT NULL COMMENT 'update time',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;

EOT
            }
            let(:dump_content_all) { <<EOT
                                     #{dump_content_head}
--
-- Dumping data for table `users_login`
--

LOCK TABLES `users_login` WRITE;
/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
INSERT INTO `users_login` VALUES (15,46,'moodier','2001-10-02 08:18:08','1986-06-11 22:50:10'),(35,6,'missteer','1991-10-15 19:38:07','1970-10-01 22:03:10'),(52,33,'subfield','1972-08-23 20:16:08','1974-10-10 23:28:11');
/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
EOT
            }
            before do
              generate_dump_file(dump_content_head)
              default_parser.parse(
                dump_io,
                Proc.new{},
                Proc.new{
                  raise "Should not be called"
                },
                Proc.new{ |source_table, last_pos, bytesize, binlog_pos, state, substate|
                  if source_table
                    @source_table = source_table
                    @option = { status: Flydata::Command::Sync::STATUS_PARSING,
                                table_name: source_table.table_name,
                                last_pos: last_pos,
                                binlog_pos: binlog_pos,
                                state: state,
                                substate: substate,
                                source_table: source_table }
                  end
                }
              )
              expect(@option).to eq({
                status: Flydata::Command::Sync::STATUS_PARSING,
                table_name: 'users_login',
                last_pos: index_after(dump_content_head, 'ENGINE=InnoDB DEFAULT CHARSET=utf8;'),
                binlog_pos: default_binlog_pos,
                state: Flydata::Parser::State::INSERT_RECORD,
                substate: nil,
                source_table: @source_table
              })
            end
            it do
              generate_dump_file(dump_content_all)
              @option.delete(:binlog_pos)
              @option.merge!( {source_pos: default_binlog_pos_object} )
              parser_for_resume = MysqlDumpParser.new(@option)
              # create_table_block
              expect(create_table_block).to receive(:call).never

              # insert_record_block
              [
                [ %w(15 46 moodier 2001-10-02\ 08:18:08 1986-06-11\ 22:50:10),
                  %w(35 6 missteer  1991-10-15\ 19:38:07 1970-10-01\ 22:03:10),
                  %w(52 33 subfield 1972-08-23\ 20:16:08 1974-10-10\ 23:28:11),],
              ].each do |expected_values|
                expect(insert_record_block).to receive(:call) { |source_table, values|
                  expect(source_table.table_name).to eq('users_login')
                  expect(values).to eq(expected_values)
                  nil
                }.once
              end
              expect(insert_record_block).to receive(:call).never

              # check_point_block
              [
                {state: Flydata::Parser::State::CREATE_TABLE,
                 last_pos: index_after(dump_content_all, 'UNLOCK TABLES;')}
              ].each do |expected_params|
                expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
                  expect(source_table.table_name).to eq('users_login') if source_table
                  expect(state).to eq(expected_params[:state])
                  if expected_params[:last_pos]
                    expect(last_pos).to eq(expected_params[:last_pos])
                  end
                  expect(binlog_pos).to eq(default_binlog_pos)
                  expect(substate).to eq(expected_params[:substate])
                  expected_params[:result]
                }.once
              end
              expect(check_point_block).to receive(:call).never

              binlog_pos = parser_for_resume.parse(
                dump_io, create_table_block, insert_record_block, check_point_block
              )
              expect(binlog_pos).to eq(default_binlog_pos)
            end
          end

          context 'with resume during insert records' do
            let(:dump_content) { <<EOT
#{DUMP_HEADER}

DROP TABLE IF EXISTS `users_login`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `users_login` (
  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
  `comment` varchar(255) DEFAULT NULL COMMENT 'comment',
  `create_time` datetime NOT NULL COMMENT 'create time',
  `update_time` datetime NOT NULL COMMENT 'update time',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `users_login`
--

LOCK TABLES `users_login` WRITE;
/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
INSERT INTO `users_login` VALUES (15,46,'moodier','2001-10-02 08:18:08','1986-06-11 22:50:10'),(35,6,'missteer','1991-10-15 19:38:07','1970-10-01 22:03:10'),(52,33,'subfield','1972-08-23 20:16:08','1974-10-10 23:28:11');
INSERT INTO `users_login` VALUES (194,11,'pandemonium','2008-01-22 22:15:10','1991-04-04 17:30:05'),(230,7,'cloudburst','2010-12-28 11:46:11','1971-06-22 13:08:01');
/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
EOT
            }
            before do
              generate_dump_file(dump_content)

              insert_record_block_for_resume = double('insert_record_block_for_resume')
              expect(insert_record_block_for_resume).to receive(:call) { true }.once
              expect(insert_record_block_for_resume).to receive(:call) { false }.once

              default_parser.parse(
                dump_io,
                Proc.new{},
                insert_record_block_for_resume,
                Proc.new{ |source_table, last_pos, bytesize, binlog_pos, state, substate|
                  if last_pos == index_after(dump_content, "'1972-08-23 20:16:08','1974-10-10 23:28:11');")
                    @source_table = source_table
                    @option = { status: Flydata::Command::Sync::STATUS_PARSING,
                                table_name: source_table.table_name,
                                last_pos: last_pos,
                                binlog_pos: binlog_pos,
                                state: state,
                                substate: substate,
                                source_table: source_table }
                  end
                }
              )
              expect(@option).to eq({
                status: Flydata::Command::Sync::STATUS_PARSING,
                table_name: 'users_login',
                last_pos: index_after(dump_content, "'1972-08-23 20:16:08','1974-10-10 23:28:11');"),
                binlog_pos: default_binlog_pos,
                state: Flydata::Parser::State::INSERT_RECORD,
                substate: nil,
                source_table: @source_table
              })
            end
            it do
              generate_dump_file(dump_content)
              @option.delete(:binlog_pos)
              @option.merge!({source_pos: default_binlog_pos_object})
              parser_for_resume = MysqlDumpParser.new(@option)

              # create_table_block
              expect(create_table_block).to receive(:call).never

              # insert_record_block
              [
                [ %w(194 11 pandemonium 2008-01-22\ 22:15:10 1991-04-04\ 17:30:05),
                  %w(230 7 cloudburst 2010-12-28\ 11:46:11 1971-06-22\ 13:08:01),],
              ].each do |expected_values|
                expect(insert_record_block).to receive(:call) { |source_table, values_set|
                  expect(source_table.table_name).to eq('users_login')
                  expect(values_set).to eq(expected_values)
                  nil
                }.once
              end
              expect(insert_record_block).to receive(:call).never

              # check_point_block
              [
                {state: Flydata::Parser::State::CREATE_TABLE,
                 last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
              ].each do |expected_params|
                expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
                  expect(source_table.table_name).to eq('users_login') if source_table
                  expect(state).to eq(expected_params[:state])
                  if expected_params[:last_pos]
                    expect(last_pos).to eq(expected_params[:last_pos])
                  end
                  expect(binlog_pos).to eq(default_binlog_pos)
                  expect(substate).to eq(expected_params[:substate])
                  expected_params[:result]
                }.once
              end
              expect(check_point_block).to receive(:call).never

              binlog_pos = parser_for_resume.parse(
                dump_io, create_table_block, insert_record_block, check_point_block
              )
              expect(binlog_pos).to eq(default_binlog_pos)
            end
          end

          context 'when dump contains contain escape characters' do
            let(:dump_content) { <<EOT
#{DUMP_HEADER}

DROP TABLE IF EXISTS `users_login`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `users_login` (
  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
  `comment` varchar(255) DEFAULT NULL COMMENT 'comment',
  `create_time` datetime NOT NULL COMMENT 'create time',
  `update_time` datetime NOT NULL COMMENT 'update time',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `users_login`
--

LOCK TABLES `users_login` WRITE;
/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
INSERT INTO `users_login` VALUES (15,46,'moodier)','2001-10-02 08:18:08','1986-06-11 22:50:10'),(35,6,'miss,teer','1991-10-15 19:38:07','1970-10-01 22:03:10'),(52,33,'subfield\\'','1972-08-23 20:16:08','1974-10-10 23:28:11');
INSERT INTO `users_login` VALUES (373,31,'outs\\nwearing','1979-10-07 08:10:08','2006-02-22 16:26:04'),(493,8,'schiz\tophrenic','1979-07-06 07:34:07\\'),','1970-08-09,01:21:01,\\')');
/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;

EOT
            }
            before { generate_dump_file(dump_content) }
            it do
              # create_table_block
              expect(create_table_block).to receive(:call) { |source_table|
                expect(source_table.table_name).to eq('users_login')
                expect(source_table.instance_variable_get(:@columns).keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
              }.once
              expect(create_table_block).to receive(:call).never

              # insert_record_block
              [
                [ %w(15 46 moodier\) 2001-10-02\ 08:18:08 1986-06-11\ 22:50:10),
                  %w(35 6 miss,teer  1991-10-15\ 19:38:07 1970-10-01\ 22:03:10),
                  %w(52 33 subfield' 1972-08-23\ 20:16:08 1974-10-10\ 23:28:11),],
                [ ['373','31',"outs\nwearing",'1979-10-07 08:10:08','2006-02-22 16:26:04'],
                  ['493','8',"schiz\tophrenic",'1979-07-06 07:34:07\'),','1970-08-09,01:21:01,\')'] ]
              ].each do |expected_values|
                expect(insert_record_block).to receive(:call) { |source_table, values_set|
                  expect(source_table.table_name).to eq('users_login')
                  expect(values_set).to eq(expected_values)
                  nil
                }.once
              end
              expect(insert_record_block).to receive(:call).never

              # insert_record_block
              [
                {state: Flydata::Parser::State::CREATE_TABLE},
                {state: Flydata::Parser::State::INSERT_RECORD},
                {state: Flydata::Parser::State::CREATE_TABLE,
                 last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
              ].each do |expected_params|
                expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
                  expect(source_table.table_name).to eq('users_login') if source_table
                  expect(state).to eq(expected_params[:state])
                  if expected_params[:last_pos]
                    expect(last_pos).to eq(expected_params[:last_pos])
                  end
                  expect(binlog_pos).to eq(default_binlog_pos)
                  expect(substate).to eq(expected_params[:substate])
                  expected_params[:result]
                }.once
              end
              expect(check_point_block).to receive(:call).never

              binlog_pos = default_parser.parse(
                dump_io, create_table_block, insert_record_block, check_point_block
              )
              expect(binlog_pos).to eq(default_binlog_pos)
            end
          end
        end
      end
      describe MysqlDumpParser::InsertParser do
        describe '#parse' do
          let(:target_line) { '' }
          let(:parser) { MysqlDumpParser::InsertParser.new }
          subject { parser.parse(target_line) }

          context 'when single record' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'hogehoge','2014-04-15 13:49:14');" }
            it 'should return one element array' do
              expect(subject).to eq([['1','hogehoge','2014-04-15 13:49:14']])
            end
          end

          context 'when 2 records' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'foo','2014-04-15 13:49:14'),(2,'var','2014-04-15 14:21:05');" }
            it 'should return two element array' do
              expect(subject).to eq([['1','foo','2014-04-15 13:49:14'],['2','var','2014-04-15 14:21:05']])
            end
          end

          context 'when data includes carriage return' do
            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'abcd\refgh','2014-04-15 13:49:14');| }
            it 'should escape return carriage' do
              expect(subject).to eq([['1',"abcd\refgh",'2014-04-15 13:49:14']])
            end
          end

          context 'when data includes new line' do
            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'abcd\nefgh','2014-04-15 13:49:14');| }
            it 'should escape new line' do
              expect(subject).to eq([['1',"abcd\nefgh",'2014-04-15 13:49:14']])
            end
          end

          context 'when data includes escaped single quotation' do
            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'abcd\',\'efgh','2014-04-15 13:49:14');| }
            it 'should escape single quotation' do
              expect(subject).to eq([['1',"abcd','efgh",'2014-04-15 13:49:14']])
            end
          end

          context 'when data includes back slash' do
            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'abcd\\efgh','2014-04-15 13:49:14');| }
            it 'should escape back slash' do
              expect(subject).to eq([['1',"abcd\\efgh",'2014-04-15 13:49:14']])
            end
          end

          context 'when data includes back slash with double quote' do
            # \"\'\' value on insert query shoulde be "''
            let(:target_line) { %q|INSERT INTO `tast_table` VALUES (1,'\"\'\'','2014-04-15 13:49:14');| }
            it 'should escape back slash' do
              expect(subject).to eq([['1',%q|"''| ,'2014-04-15 13:49:14']])
            end
          end

          context 'when data includes back slash with double quote another case' do
            # \"\"\"\"\"''\"'' value on insert query shoulde be """""''"''
            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'\"\"\"\"\"\'\'\"\'\'','2014-04-15 13:49:14');| }
            it 'should escape back slash' do
              expect(subject).to eq([['1',%q|"""""''"''|,'2014-04-15 13:49:14']])
            end
          end

          context 'when data includes mixed escaped characters' do
            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'ab\rcd\\e\nf\',\'gh','2014-04-15 13:49:14');| }
            it 'should escape all' do
              expect(subject).to eq([['1',"ab\rcd\\e\nf','gh",'2014-04-15 13:49:14']])
            end
          end

          context 'when data includes mixed escaped characters in a row' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'ab\\\\ncd\\\\\\nefgh','2014-04-15 13:49:14');" }
            it 'should escape all' do
              expect(subject).to eq([['1',"ab\\ncd\\\nefgh",'2014-04-15 13:49:14']])
            end
          end

          context 'with escape chars' do
            let(:target_line) { "INSERT INTO `test_table` VALUES ('#{value}');" }

            context 'with a single escape char' do
              let(:value) { %q|\\0| }
              #let(:expected_value) { %Q|\0| }
              let(:expected_value) { value }  # this is compatible with the previous implementation but it's actually wrong.  For now, keeping it as is because allowing the null character in a string could open a can of worms.
              it 'returns correct chars' do
                expect(subject).to eq([[expected_value]])
              end
            end
            context 'with an escape char followed by a regular char' do
              let(:value) { %q|\\'m| }
              let(:expected_value) { %Q|'m| }
              it 'returns correct chars' do
                expect(subject).to eq([[expected_value]])
              end
            end
            context 'with two consecutive escape chars' do
              let(:value) { %Q|\\"\b| }
              let(:expected_value) { %Q|"\b| }
              it 'returns correct chars' do
                expect(subject).to eq([[expected_value]])
              end
            end
            context 'with a escape char following a regular char' do
              let(:value) { %q|a\\n| }
              let(:expected_value) { %Q|a\n| }
              it 'returns correct chars' do
                expect(subject).to eq([[expected_value]])
              end
            end
            context 'with various escape chars 1' do
              let(:value) { %Q|\\r\t\\Z| }
=begin
# Use this when _parse2 is used
              let(:expected_value) { %Q|\r\t\x1a| }
=end
# =begin
# Use this when _parse is used
              let(:expected_value) { %Q|\r\t\\Z| }
# =end
              it 'returns correct chars' do
                expect(subject).to eq([[expected_value]])
              end
            end
            context 'with various escape chars 2' do
              let(:value) { %q|c\\\\\\\\%\\\\_| }
              let(:expected_value) { %q|c\\\\%\\_| }
              it 'returns correct chars' do
                expect(subject).to eq([[expected_value]])
              end
            end
          end

          context 'when data end with back slash' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'D:\\\\download\\\\','2014-04-15 13:49:14');" }
            it 'should escape back slash' do
              expect(subject).to eq([['1',"D:\\download\\",'2014-04-15 13:49:14']])
            end
          end

          context 'when a regular character is escaped' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'\\a','2014-04-15 13:49:14');" }
            it 'should leave the back slash as is' do
              expect(subject).to eq([['1',"\\a",'2014-04-15 13:49:14']])
            end
          end

          context 'when comma is the first character of a string' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,',9','2014-04-15 13:49:14');" }
            it 'should parse the string correctly' do
              expect(subject).to eq([['1',',9','2014-04-15 13:49:14']])
            end
          end

          context 'when comma is the last character of a string' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'9,','2014-04-15 13:49:14');" }
            it 'should parse the string correctly' do
              expect(subject).to eq([['1','9,','2014-04-15 13:49:14']])
            end
          end

          context 'when a string consists of a comma' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,',','2014-04-15 13:49:14');" }
            it 'should parse the string correctly' do
              expect(subject).to eq([['1',',','2014-04-15 13:49:14']])
            end
          end

          context 'when two commas are given as a string' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,',,','2014-04-15 13:49:14');" }
            it 'should parse the string correctly' do
              expect(subject).to eq([['1',',,','2014-04-15 13:49:14']])
            end
          end

          context 'when an empty string value is given' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'','2014-04-15 13:49:14');" }
            it 'should parse the string correctly' do
              expect(subject).to eq([['1','','2014-04-15 13:49:14']])
            end
          end

          context 'when a value consists of a comma followed by closing bracket' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'),ksd','2014-04-15 13:49:14');" }
            it 'should parse the string correctly' do
              expect(subject).to eq([['1','),ksd','2014-04-15 13:49:14']])
            end
          end

          context 'when there is a white space before the closing bracket' do
            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'aa','2014-04-15 13:49:14' );" }
            it 'should fail to parse.  This is intentional for performance reason' do
              expect{subject}.to raise_error
            end
          end

          context 'when an integer that has leading zeros is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,00013);"}
            it 'should remove the leading zeros' do
              expect(subject).to eq([['1', '13']])
            end
          end

          context 'when a decimal that has leading zeros is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,00013.40);"}
            it 'should remove the leading zeros' do
              expect(subject).to eq([['1', '13.40']])
            end
          end

          context 'when a timestamp that has leading zeros is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,'0004-04-15 13:49:14');"}
            it 'should not remove the leading zeros' do
              expect(subject).to eq([['1', '0004-04-15 13:49:14']])
            end
          end

          context 'when a string that has leading zeros is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,'00000aa');"}
            it 'should not remove the leading zeros' do
              expect(subject).to eq([['1', '00000aa']])
            end
          end

          context 'when a string that has leading zeros, numbers and a comma in between is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,'0003,00033');"}
            it 'should not remove the leading zeros' do
              expect(subject).to eq([['1', '0003,00033']])
            end
          end

          context 'when a string that has leading zeros, has only numbers is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,'00033');"}
            it 'should not remove the leading zeros' do
              expect(subject).to eq([['1', '00033']])
            end
          end

          context 'when 0 is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,0);"}
            it 'should not remove the leading zeros' do
              expect(subject).to eq([['1', '0']])
            end
          end

          context 'when a scientific number is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,#{num_str});"}
            shared_examples "accepting the value as is" do
              it 'should accept the value as is' do
                expect(subject).to eq([['1', num_str]])
              end
            end
            context 'capital E' do
              let(:num_str) { '1.2E3' }
              it_behaves_like "accepting the value as is"
            end
            context 'lowercase e' do
              let(:num_str) { '1.2e3' }
              it_behaves_like "accepting the value as is"
            end
            context 'negative integer' do
              let(:num_str) { '-1.2e3' }
              it_behaves_like "accepting the value as is"
            end
            context 'negative fractional' do
              let(:num_str) { '1.2e-3' }
              it_behaves_like "accepting the value as is"
            end
            context 'negative integer & fractional' do
              let(:num_str) { '-1.2e-3' }
              it_behaves_like "accepting the value as is"
            end
          end

          context 'when a number with positive sign is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,+9.10);"}
            it 'should accept the value as is' do
              expect(subject).to eq([['1', '+9.10']])
            end
          end

          context 'when a number with no leading zero is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,.10);"}
            it 'should accept the value as is' do
              expect(subject).to eq([['1', '.10']])
            end
          end

          context 'when 0.00 is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,0.00);"}
            it 'should not remove the leading zeros' do
              expect(subject).to eq([['1', '0.00']])
            end
          end

          context 'when a hex blob is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (#{hex_blob});"}
            context 'uppercase hex' do
              let(:hex_blob) { '0x5CFA' }
              it 'extracts the same string' do
                expect(subject).to eq([[hex_blob]])
              end
            end
            context 'lowercase hex' do
              let(:hex_blob) { '0x5cfa' }
              it 'extracts the same string' do
                expect(subject).to eq([[hex_blob]])
              end
            end
          end

          context 'when a negative number is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES (1,-0.004,-293);"}
            it 'should preserve the minus sign' do
              expect(subject).to eq([['1', '-0.004', '-293']])
            end
          end

          context 'when NULL is given' do
            context 'in the end' do
              let(:target_line) {"INSERT INTO `test_table` VALUES (1,NULL);"}
              it 'should preserve the minus sign' do
                expect(subject).to eq([['1', nil]])
              end
            end
            context 'in the middle' do
              let(:target_line) {"INSERT INTO `test_table` VALUES (1,NULL,'hi');"}
              it 'should preserve the minus sign' do
                expect(subject).to eq([['1', nil, 'hi']])
              end
            end
          end
          context 'with many columns' do
            let(:target_line) {<<EOS.chomp}
INSERT INTO `type_without_width_info` VALUES (1098238,0x5C,0x01,0x6974206C6F6F6B73206C696B65206120746578742062757420697427732062696E617279,0,1,'c','2015-10-18','2015-10-18 23:12:04',4,192,292.22,92,293.83,222,292,NULL,'I\\'m a \\\\ very long text',NULL,29838,'sdaklfj;',2983,12,'\\',\\\\','04:58:21','2015-10-18 12:34:56',NULL,-1,'28',1),(-2938,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,-0.49,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,2);
EOS
            it 'should preserve the minus sign' do
              expect(subject).to eq([['1098238','0x5C','0x01','0x6974206C6F6F6B73206C696B65206120746578742062757420697427732062696E617279','0','1','c','2015-10-18','2015-10-18 23:12:04','4','192','292.22','92','293.83','222','292',nil,%q|I'm a \\ very long text|,nil,'29838','sdaklfj;','2983','12','\',\\','04:58:21','2015-10-18 12:34:56',nil,'-1','28','1'],['-2938',nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,'-0.49',nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,'2']])
            end
          end

          context 'when ^B is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES ('testtest');"}
            it 'should not remove the leading zeros' do
              expect(subject).to eq([["test\x02test"]])
            end
          end
          context 'when ^\\ is given' do
            let(:target_line) {"INSERT INTO `test_table` VALUES ('testtest');"}
            it 'should not remove the leading zeros' do
              expect(subject).to eq([["test\x1ctest"]])
            end
          end

          context 'with various characters' do
            context 'UTF-8 1 byte char' do
              let(:target_line) {"INSERT INTO `test_table` VALUES ('testtest');"}
              it 'should convert correctly' do
                expect(subject).to eq([["testtest"]])
              end
            end
            context 'UTF-8 2 byte char' do
              let(:target_line) {"INSERT INTO `test_table` VALUES ('testðtest');"}
              it 'should convert correctly' do
                expect(subject).to eq([["testðtest"]])
              end
            end
            context 'UTF-8 3 byte char' do
              let(:target_line) {"INSERT INTO `test_table` VALUES ('testあtest');"}
              it 'should convert correctly' do
                expect(subject).to eq([["testあtest"]])
              end
            end
            context 'UTF-8 4 byte char' do
              let(:target_line) {"INSERT INTO `test_table` VALUES ('test\xf0\x90\x85\x83test');"}
              it 'should convert correctly' do
                expect(subject).to eq([["test\xf0\x90\x85\x83test"]])
              end
            end
          end
        end
      end
    end
  end
end