ruby-mysql 2.9.14 → 3.0.0

data/test/test_mysql.rb

@@ -20,28 +20,71 @@ MYSQL_SOCKET   = ENV['MYSQL_SOCKET']
 class TestMysql < Test::Unit::TestCase
   sub_test_case 'Mysql::VERSION' do
     test 'returns client version' do
-      assert{ Mysql::VERSION == 20913 }
+      assert{ Mysql::VERSION == '3.0.0' }
     end
   end
 
-  sub_test_case 'Mysql.init' do
+  sub_test_case 'Mysql.new' do
     test 'returns Mysql object' do
-      assert{ Mysql.init.kind_of? Mysql }
+      assert{ Mysql.new.kind_of? Mysql }
     end
   end
 
-  sub_test_case 'Mysql.real_connect' do
-    test 'connect to mysqld' do
-      @m = Mysql.real_connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
-      assert{ @m.kind_of? Mysql }
-    end
-
-    test 'flag argument affects' do
-      @m = Mysql.real_connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET, Mysql::CLIENT_FOUND_ROWS)
-      @m.query 'create temporary table t (c int)'
-      @m.query 'insert into t values (123)'
-      @m.query 'update t set c=123'
-      assert{ @m.affected_rows == 1 }
+  sub_test_case 'arguments' do
+    test 'with fixed arguments' do
+      @m = Mysql.new('127.0.0.1', 'hoge', 'abc&def', 'test', 3306, '/tmp/socket', 12345)
+      assert{ @m.host == '127.0.0.1' }
+      assert{ @m.username == 'hoge' }
+      assert{ @m.password == 'abc&def' }
+      assert{ @m.database == 'test' }
+      assert{ @m.port == 3306 }
+      assert{ @m.socket == '/tmp/socket' }
+      assert{ @m.flags == 12345 }
+    end
+
+    test 'with keyword arguments' do
+      @m = Mysql.new(host: '127.0.0.1', username: 'hoge', password: 'abc&def', database: 'test', port: 3306, socket: '/tmp/socket', flags: 12345)
+      assert{ @m.host == '127.0.0.1' }
+      assert{ @m.username == 'hoge' }
+      assert{ @m.password == 'abc&def' }
+      assert{ @m.database == 'test' }
+      assert{ @m.port == 3306 }
+      assert{ @m.socket == '/tmp/socket' }
+      assert{ @m.flags == 12345 }
+    end
+
+    test 'with URI' do
+      uri = URI.parse("mysql://hoge:abc%26def@127.0.0.1:3306/test?socket=/tmp/socket&flags=12345")
+      @m = Mysql.new(uri)
+      assert{ @m.host == '127.0.0.1' }
+      assert{ @m.username == 'hoge' }
+      assert{ @m.password == 'abc&def' }
+      assert{ @m.database == 'test' }
+      assert{ @m.port == 3306 }
+      assert{ @m.socket == '/tmp/socket' }
+      assert{ @m.flags == 12345 }
+    end
+
+    test 'with URI string' do
+      @m = Mysql.new("mysql://hoge:abc%26def@127.0.0.1:3306/test?socket=/tmp/socket&flags=12345")
+      assert{ @m.host == '127.0.0.1' }
+      assert{ @m.username == 'hoge' }
+      assert{ @m.password == 'abc&def' }
+      assert{ @m.database == 'test' }
+      assert{ @m.port == 3306 }
+      assert{ @m.socket == '/tmp/socket' }
+      assert{ @m.flags == 12345 }
+    end
+
+    test 'with URI string: host is filename' do
+      @m = Mysql.new("mysql://hoge:abc%26def@%2Ftmp%2Fsocket:3306/test?flags=12345")
+      assert{ @m.host == '' }
+      assert{ @m.username == 'hoge' }
+      assert{ @m.password == 'abc&def' }
+      assert{ @m.database == 'test' }
+      assert{ @m.port == 3306 }
+      assert{ @m.socket == '/tmp/socket' }
+      assert{ @m.flags == 12345 }
     end
 
     teardown do
@@ -55,16 +98,14 @@ class TestMysql < Test::Unit::TestCase
       assert{ @m.kind_of? Mysql }
     end
 
-    teardown do
-      @m.close if @m
+    test 'flag argument affects' do
+      @m = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET, Mysql::CLIENT_FOUND_ROWS)
+      @m.query 'create temporary table t (c int)'
+      @m.query 'insert into t values (123)'
+      @m.query 'update t set c=123'
+      assert{ @m.affected_rows == 1 }
     end
-  end
 
-  sub_test_case 'Mysql.new' do
-    test 'connect to mysqld' do
-      @m = Mysql.new(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
-      assert{ @m.kind_of? Mysql }
-    end
     teardown do
       @m.close if @m
     end
@@ -82,66 +123,43 @@ class TestMysql < Test::Unit::TestCase
     end
   end
 
-  sub_test_case 'Mysql.client_info' do
-    test 'returns client version as string' do
-      assert{ Mysql.client_info == '5.0.0' }
-    end
-  end
-
-  sub_test_case 'Mysql.get_client_info' do
-    test 'returns client version as string' do
-      assert{ Mysql.get_client_info == '5.0.0' }
-    end
-  end
-
-  sub_test_case 'Mysql.client_version' do
-    test 'returns client version as Integer' do
-      assert{ Mysql.client_version == 50000 }
+  sub_test_case 'Mysql#connect' do
+    test 'connect to mysqld' do
+      @m = Mysql.new(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      assert{ @m.connect == @m }
     end
-  end
 
-  sub_test_case 'Mysql.get_client_version' do
-    test 'returns client version as Integer' do
-      assert{ Mysql.client_version == 50000 }
+    test 'connect to mysqld by URI' do
+      @m = Mysql.new("mysql://#{MYSQL_USER}:#{MYSQL_PASSWORD}@#{MYSQL_SERVER}:#{MYSQL_PORT}/#{MYSQL_DATABASE}?socket=#{MYSQL_SOCKET}")
+      assert{ @m.connect == @m }
     end
-  end
 
-  sub_test_case 'Mysql#real_connect' do
-    test 'connect to mysqld' do
-      @m = Mysql.init
-      assert{ @m.real_connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET) == @m }
-    end
-    teardown do
-      @m.close if @m
+    test 'overrides arguments of new method' do
+      @m = Mysql.new('example.com', 12345)
+      @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
     end
-  end
 
-  sub_test_case 'Mysql#connect' do
-    test 'connect to mysqld' do
-      @m = Mysql.init
-      assert{ @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET) == @m }
-    end
     teardown do
       @m.close if @m
     end
   end
 
-  sub_test_case 'Mysql#options' do
+  sub_test_case 'options' do
     setup do
-      @m = Mysql.init
+      @m = Mysql.new
     end
     teardown do
       @m.close
     end
-    test 'INIT_COMMAND: execute query when connecting' do
-      assert{ @m.options(Mysql::INIT_COMMAND, "SET AUTOCOMMIT=0") == @m }
+    test 'init_command: execute query when connecting' do
+      @m.init_command = "SET AUTOCOMMIT=0"
       assert{ @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET) == @m }
       assert{ @m.query('select @@AUTOCOMMIT').fetch_row == ["0"] }
     end
-    test 'OPT_CONNECT_TIMEOUT: set timeout for connecting' do
-      assert{ @m.options(Mysql::OPT_CONNECT_TIMEOUT, 0.1) == @m }
-      stub(UNIXSocket).new{ sleep 1}
-      stub(TCPSocket).new{ sleep 1}
+    test 'connect_timeout: set timeout for connecting' do
+      @m.connect_timeout = 0.1
+      stub(Socket).tcp{ raise Errno::ETIMEDOUT }
+      stub(Socket).unix{ raise Errno::ETIMEDOUT }
       assert_raise Mysql::ClientError, 'connection timeout' do
         @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
       end
@@ -149,33 +167,80 @@ class TestMysql < Test::Unit::TestCase
         @m.connect
       end
     end
-    test 'OPT_LOCAL_INFILE: client can execute LOAD DATA LOCAL INFILE query' do
+    test 'local_infile: client can execute LOAD DATA LOCAL INFILE query' do
+      require 'tempfile'
+      tmpf = Tempfile.new 'mysql_spec'
+      tmpf.puts "123\tabc\n"
+      tmpf.close
+      @m.local_infile = true
+      @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m.query('create temporary table t (i int, c char(10))')
+      @m.query("load data local infile '#{tmpf.path}' into table t")
+      assert{ @m.query('select * from t').fetch_row == ['123','abc'] }
+    end
+    test 'load_data_local_dir: client can execute LOAD DATA LOCAL INFILE query with specified directory' do
       require 'tempfile'
       tmpf = Tempfile.new 'mysql_spec'
       tmpf.puts "123\tabc\n"
       tmpf.close
-      assert{ @m.options(Mysql::OPT_LOCAL_INFILE, true) == @m }
+      @m.load_data_local_dir = File.dirname(tmpf.path)
       @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
       @m.query('create temporary table t (i int, c char(10))')
       @m.query("load data local infile '#{tmpf.path}' into table t")
       assert{ @m.query('select * from t').fetch_row == ['123','abc'] }
     end
-    test 'OPT_READ_TIMEOUT: set timeout for reading packet' do
-      assert{ @m.options(Mysql::OPT_READ_TIMEOUT, 10) == @m }
+    test 'load_data_local_dir: client cannot execute LOAD DATA LOCAL INFILE query without specified directory' do
+      require 'tempfile'
+      tmpf = Tempfile.new 'mysql_spec'
+      tmpf.puts "123\tabc\n"
+      tmpf.close
+      @m.load_data_local_dir = '/hoge'
+      @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m.query('create temporary table t (i int, c char(10))')
+      assert_raise Mysql::ClientError::LoadDataLocalInfileRejected, 'LOAD DATA LOCAL INFILE file request rejected due to restrictions on access.' do
+        @m.query("load data local infile '#{tmpf.path}' into table t")
+      end
+    end
+    test 'without local_infile and load_data_local_dir: client cannot execute LOAD DATA LOCAL INFILE query' do
+      require 'tempfile'
+      tmpf = Tempfile.new 'mysql_spec'
+      tmpf.puts "123\tabc\n"
+      tmpf.close
+      @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m.query('create temporary table t (i int, c char(10))')
+      if @m.server_version >= 80000
+        assert_raise Mysql::ServerError, 'Loading local data is disabled; this must be enabled on both the client and server sides' do
+          @m.query("load data local infile '#{tmpf.path}' into table t")
+        end
+      else
+        assert_raise Mysql::ServerError::NotAllowedCommand, 'The used command is not allowed with this MySQL version' do
+          @m.query("load data local infile '#{tmpf.path}' into table t")
+        end
+      end
+    end
+    test 'read_timeout: set timeout for reading packet' do
+      @m.read_timeout = 1
+      @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m.query("select 123").entries
     end
-    test 'OPT_WRITE_TIMEOUT: set timeout for writing packet' do
-      assert{ @m.options(Mysql::OPT_WRITE_TIMEOUT, 10) == @m }
+    test 'write_timeout: set timeout for writing packet' do
+      @m.write_timeout = 1
+      @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m.query("select 123").entries
     end
-    test 'SET_CHARSET_NAME: set charset for connection' do
-      assert{ @m.options(Mysql::SET_CHARSET_NAME, 'utf8') == @m }
+    test 'charset: set charset for connection' do
+      @m.charset = 'utf8mb3'
       @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
-      assert{ @m.query('select @@character_set_connection').fetch_row == ['utf8'] }
+      assert do
+        @m.query('select @@character_set_connection').fetch_row == ['utf8mb3'] ||
+          @m.query('select @@character_set_connection').fetch_row == ['utf8']
+      end
     end
   end
 
   sub_test_case 'Mysql' do
     setup do
-      @m = Mysql.new(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
     end
 
     teardown do
@@ -183,22 +248,9 @@ class TestMysql < Test::Unit::TestCase
     end
 
     sub_test_case '#escape_string' do
-      if defined? ::Encoding
-        test 'escape special character for charset' do
-          @m.charset = 'cp932'
-          assert{ @m.escape_string("abc'def\"ghi\0jkl%mno_表".encode('cp932')) == "abc\\'def\\\"ghi\\0jkl%mno_表".encode('cp932') }
-        end
-      else
-        test 'raise error if charset is multibyte' do
-          @m.charset = 'cp932'
-          assert_raise Mysql::ClientError, 'Mysql#escape_string is called for unsafe multibyte charset' do
-            @m.escape_string("abc'def\"ghi\0jkl%mno_\x95\\")
-          end
-        end
-        test 'not warn if charset is singlebyte' do
-          @m.charset = 'latin1'
-          assert{ @m.escape_string("abc'def\"ghi\0jkl%mno_\x95\\") == "abc\\'def\\\"ghi\\0jkl%mno_\x95\\\\" }
-        end
+      test 'escape special character for charset' do
+        @m.charset = 'cp932'
+        assert{ @m.escape_string("abc'def\"ghi\0jkl%mno_表".encode('cp932')) == "abc\\'def\\\"ghi\\0jkl%mno_表".encode('cp932') }
       end
     end
 
@@ -208,18 +260,6 @@ class TestMysql < Test::Unit::TestCase
       end
     end
 
-    sub_test_case '#client_info' do
-      test 'returns client version as string' do
-        assert{ @m.client_info == '5.0.0' }
-      end
-    end
-
-    sub_test_case '#get_client_info' do
-      test 'returns client version as string' do
-        assert{ @m.get_client_info == '5.0.0' }
-      end
-    end
-
     sub_test_case '#affected_rows' do
       test 'returns number of affected rows' do
         @m.query 'create temporary table t (id int)'
@@ -230,8 +270,8 @@ class TestMysql < Test::Unit::TestCase
 
     sub_test_case '#character_set_name' do
       test 'returns charset name' do
-        m = Mysql.init
-        m.options Mysql::SET_CHARSET_NAME, 'cp932'
+        m = Mysql.new
+        m.charset = 'cp932'
         m.connect MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET
         assert{ m.character_set_name == 'cp932' }
       end
@@ -279,28 +319,6 @@ class TestMysql < Test::Unit::TestCase
       end
     end
 
-    sub_test_case '#client_version' do
-      test 'returns client version as Integer' do
-        assert{ @m.client_version.kind_of? Integer }
-      end
-    end
-
-    sub_test_case '#get_client_version' do
-      test 'returns client version as Integer' do
-        assert{ @m.get_client_version.kind_of? Integer }
-      end
-    end
-
-    sub_test_case '#get_host_info' do
-      test 'returns connection type as String' do
-        if MYSQL_SERVER == nil or MYSQL_SERVER == 'localhost'
-          assert{ @m.get_host_info == 'Localhost via UNIX socket' }
-        else
-          assert{ @m.get_host_info == "#{MYSQL_SERVER} via TCP/IP" }
-        end
-      end
-    end
-
     sub_test_case '#host_info' do
       test 'returns connection type as String' do
         if MYSQL_SERVER == nil or MYSQL_SERVER == 'localhost'
@@ -311,24 +329,6 @@ class TestMysql < Test::Unit::TestCase
       end
     end
 
-    sub_test_case '#get_proto_info' do
-      test 'returns version of connection as Integer' do
-        assert{ @m.get_proto_info == 10 }
-      end
-    end
-
-    sub_test_case '#proto_info' do
-      test 'returns version of connection as Integer' do
-        assert{ @m.proto_info == 10 }
-      end
-    end
-
-    sub_test_case '#get_server_info' do
-      test 'returns server version as String' do
-        assert{ @m.get_server_info =~ /\A\d+\.\d+\.\d+/ }
-      end
-    end
-
     sub_test_case '#server_info' do
       test 'returns server version as String' do
         assert{ @m.server_info =~ /\A\d+\.\d+\.\d+/ }
@@ -356,7 +356,7 @@ class TestMysql < Test::Unit::TestCase
 
     sub_test_case '#kill' do
       setup do
-        @m2 = Mysql.new(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+        @m2 = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
       end
       teardown do
         @m2.close rescue nil
@@ -366,61 +366,6 @@ class TestMysql < Test::Unit::TestCase
       end
     end
 
-    sub_test_case '#list_dbs' do
-      test 'returns database list' do
-        ret = @m.list_dbs
-        assert{ ret.kind_of? Array }
-        assert{ ret.include? MYSQL_DATABASE }
-      end
-      test 'with pattern returns databases that matches pattern' do
-        assert{ @m.list_dbs('info%').include? 'information_schema' }
-      end
-    end
-
-    sub_test_case '#list_fields' do
-      setup do
-        @m.query 'create temporary table t (i int, c char(10), d date)'
-      end
-      test 'returns result set that contains information of fields' do
-        ret = @m.list_fields('t')
-        assert{ ret.kind_of? Mysql::Result }
-        assert{ ret.num_rows == 0 }
-        assert{ ret.fetch_fields.map{|f|f.name} == ['i','c','d'] }
-      end
-      test 'with pattern returns result set that contains information of fields that matches pattern' do
-        ret = @m.list_fields('t', 'i')
-        assert{ ret.kind_of? Mysql::Result }
-        assert{ ret.num_rows == 0 }
-        ret.fetch_fields.map{|f|f.name} == ['i']
-      end
-    end
-
-    sub_test_case '#list_processes' do
-      test 'returns result set that contains information of all connections' do
-        ret = @m.list_processes
-        assert{ ret.kind_of? Mysql::Result }
-        assert{ ret.find{|r|r[0].to_i == @m.thread_id}[4] == "Processlist" }
-      end
-    end
-
-    sub_test_case '#list_tables' do
-      setup do
-        @m.query 'create table test_mysql_list_tables (id int)'
-      end
-      teardown do
-        @m.query 'drop table if exists test_mysql_list_tables'
-      end
-      test 'returns table list' do
-        ret = @m.list_tables
-        assert{ ret.kind_of? Array }
-        assert{ ret.include? 'test_mysql_list_tables' }
-      end
-      test 'with pattern returns lists that matches pattern' do
-        ret = @m.list_tables '%mysql\_list\_t%'
-        assert{ ret.include? 'test_mysql_list_tables' }
-      end
-    end
-
     sub_test_case '#ping' do
       test 'returns self' do
         assert{ @m.ping == @m }
@@ -434,17 +379,8 @@ class TestMysql < Test::Unit::TestCase
       test 'returns nil if query returns no results' do
         assert{ @m.query('set @hoge:=123') == nil }
       end
-      test 'returns self if query_with_result is false' do
-        @m.query_with_result = false
-        assert{ @m.query('select 123') == @m }
-        @m.store_result
-        assert{ @m.query('set @hoge:=123') == @m }
-      end
-    end
-
-    sub_test_case '#real_query' do
-      test 'is same as #query' do
-        assert{ @m.real_query('select 123').kind_of? Mysql::Result }
+      test 'returns self if block is specified' do
+        assert{ @m.query('select 123'){} == @m }
       end
     end
 
@@ -476,60 +412,12 @@ class TestMysql < Test::Unit::TestCase
       end
     end
 
-    sub_test_case '#store_result' do
-      test 'returns Mysql::Result' do
-        @m.query_with_result = false
-        @m.query 'select 1,2,3'
-        ret = @m.store_result
-        assert{ ret.kind_of? Mysql::Result }
-        assert{ ret.fetch_row == ['1','2','3'] }
-      end
-      test 'raises error when no query' do
-        assert_raise Mysql::ClientError, 'invalid usage' do
-          @m.store_result
-        end
-      end
-      test 'raises error when query does not return results' do
-        @m.query 'set @hoge:=123'
-        assert_raise Mysql::ClientError, 'invalid usage' do
-          @m.store_result
-        end
-      end
-    end
-
     sub_test_case '#thread_id' do
       test 'returns thread id as Integer' do
         assert{ @m.thread_id.kind_of? Integer }
       end
     end
 
-    sub_test_case '#use_result' do
-      test 'returns Mysql::Result' do
-        @m.query_with_result = false
-        @m.query 'select 1,2,3'
-        ret = @m.use_result
-        assert{ ret.kind_of? Mysql::Result }
-        assert{ ret.fetch_row == ['1','2','3'] }
-      end
-      test 'raises error when no query' do
-        assert_raise Mysql::ClientError, 'invalid usage' do
-          @m.use_result
-        end
-      end
-      test 'raises error when query does not return results' do
-        @m.query 'set @hoge:=123'
-        assert_raise Mysql::ClientError, 'invalid usage' do
-          @m.use_result
-        end
-      end
-    end
-
-    sub_test_case '#get_server_version' do
-      test 'returns server version as Integer' do
-        assert{ @m.get_server_version.kind_of? Integer }
-      end
-    end
-
     sub_test_case '#server_version' do
       test 'returns server version as Integer' do
         assert{ @m.server_version.kind_of? Integer }
@@ -594,27 +482,6 @@ class TestMysql < Test::Unit::TestCase
       end
     end
 
-    sub_test_case '#query_with_result' do
-      test 'default value is true' do
-        assert{ @m.query_with_result == true }
-      end
-      test 'can set value' do
-        assert{ (@m.query_with_result=true) == true }
-        assert{ @m.query_with_result == true }
-        assert{ (@m.query_with_result=false) == false }
-        assert{ @m.query_with_result == false }
-      end
-    end
-
-    sub_test_case '#query_with_result is false' do
-      test 'Mysql#query returns self and Mysql#store_result returns result set' do
-        @m.query_with_result = false
-        assert{ @m.query('select 1,2,3') == @m }
-        res = @m.store_result
-        assert{ res.fetch_row == ['1','2','3'] }
-      end
-    end
-
     sub_test_case '#query with block' do
       test 'returns self' do
         assert{ @m.query('select 1'){} == @m }
@@ -647,7 +514,7 @@ class TestMysql < Test::Unit::TestCase
 
   sub_test_case 'multiple statement query:' do
     setup do
-      @m = Mysql.new(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
       @m.set_server_option(Mysql::OPTION_MULTI_STATEMENTS_ON)
       @res = @m.query 'select 1,2; select 3,4,5'
     end
@@ -685,7 +552,7 @@ class TestMysql < Test::Unit::TestCase
 
   sub_test_case 'Mysql::Result' do
     setup do
-      @m = Mysql.new(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
       @m.charset = 'latin1'
       @m.query 'create temporary table t (id int default 0, str char(10), primary key (id))'
       @m.query "insert into t values (1,'abc'),(2,'defg'),(3,'hi'),(4,null)"
@@ -841,7 +708,7 @@ class TestMysql < Test::Unit::TestCase
 
   sub_test_case 'Mysql::Field' do
     setup do
-      @m = Mysql.new(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
       @m.charset = 'latin1'
       @m.query 'create temporary table t (id int default 0, str char(10), primary key (id))'
       @m.query "insert into t values (1,'abc'),(2,'defg'),(3,'hi'),(4,null)"
@@ -864,10 +731,6 @@ class TestMysql < Test::Unit::TestCase
       assert{ @res.fetch_field.def == nil }
     end
 
-    test '#def for field information is default value' do
-      assert{ @m.list_fields('t').fetch_field.def == '0' }
-    end
-
     test '#type is type of field as Integer' do
       assert{ @res.fetch_field.type == Mysql::Field::TYPE_LONG }
       assert{ @res.fetch_field.type == Mysql::Field::TYPE_STRING }
@@ -892,8 +755,8 @@ class TestMysql < Test::Unit::TestCase
       assert{ @m.query('select 1.23').fetch_field.decimals == 2 }
     end
 
-    test '#hash return field as hash' do
-      assert{ @res.fetch_field.hash == {
+    test '#to_hash return field as hash' do
+      assert{ @res.fetch_field.to_hash == {
           'name'       => 'id',
           'table'      => 't',
           'def'        => nil,
@@ -904,7 +767,7 @@ class TestMysql < Test::Unit::TestCase
           'decimals'   => 0,
         }
       }
-      assert{ @res.fetch_field.hash == {
+      assert{ @res.fetch_field.to_hash == {
           'name'       => 'str',
           'table'      => 't',
           'def'        => nil,
@@ -940,15 +803,15 @@ class TestMysql < Test::Unit::TestCase
 
   sub_test_case 'create Mysql::Stmt object:' do
     setup do
-      @m = Mysql.new(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
     end
 
     teardown do
       @m.close if @m
     end
 
-    test 'Mysql#stmt_init returns Mysql::Stmt object' do
-      assert{ @m.stmt_init.kind_of? Mysql::Stmt }
+    test 'Mysql#stmt returns Mysql::Stmt object' do
+      assert{ @m.stmt.kind_of? Mysql::Stmt }
     end
 
     test 'Mysq;#prepare returns Mysql::Stmt object' do
@@ -958,9 +821,9 @@ class TestMysql < Test::Unit::TestCase
 
   sub_test_case 'Mysql::Stmt' do
     setup do
-      @m = Mysql.new(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
       @m.query("set sql_mode=''")
-      @s = @m.stmt_init
+      @s = @m.stmt
     end
 
     teardown do
@@ -980,68 +843,6 @@ class TestMysql < Test::Unit::TestCase
       assert{ @s.affected_rows == 3 }
     end
 
-    sub_test_case '#bind_result' do
-      setup do
-        @m.query 'create temporary table t (i int, c char(10), d double, t datetime)'
-        @m.query 'insert into t values (123,"9abcdefg",1.2345,20091208100446)'
-        @s.prepare 'select * from t'
-      end
-
-      test '(nil) make result format to be standard value' do
-        @s.bind_result nil, nil, nil, nil
-        @s.execute
-        assert{ @s.fetch == [123, '9abcdefg', 1.2345, Mysql::Time.new(2009,12,8,10,4,46)] }
-      end
-
-      test '(Numeric) make result format to be Integer value' do
-        @s.bind_result Numeric, Numeric, Numeric, Numeric
-        @s.execute
-        assert{ @s.fetch == [123, 9, 1, 20091208100446] }
-      end
-
-      test '(Integer) make result format to be Integer value' do
-        @s.bind_result Integer, Integer, Integer, Integer
-        @s.execute
-        assert{ @s.fetch == [123, 9, 1, 20091208100446] }
-      end
-
-      test '(Fixnum) make result format to be Integer value' do
-        @s.bind_result Fixnum, Fixnum, Fixnum, Fixnum
-        @s.execute
-        assert{ @s.fetch == [123, 9, 1, 20091208100446] }
-      end
-
-      test '(String) make result format to be String value' do
-        @s.bind_result String, String, String, String
-        @s.execute
-        assert{ @s.fetch == ["123", "9abcdefg", "1.2345", "2009-12-08 10:04:46"] }
-      end
-
-      test '(Float) make result format to be Float value' do
-        @s.bind_result Float, Float, Float, Float
-        @s.execute
-        assert{ @s.fetch == [123.0, 9.0, 1.2345 , 20091208100446.0] }
-      end
-
-      test '(Mysql::Time) make result format to be Mysql::Time value' do
-        @s.bind_result Mysql::Time, Mysql::Time, Mysql::Time, Mysql::Time
-        @s.execute
-        assert{ @s.fetch == [Mysql::Time.new(2000,1,23), Mysql::Time.new, Mysql::Time.new, Mysql::Time.new(2009,12,8,10,4,46)] }
-      end
-
-      test '(invalid) raises error' do
-        assert_raise TypeError do
-          @s.bind_result(Time, nil, nil, nil)
-        end
-      end
-
-      test 'with mismatch argument count raise error' do
-        assert_raise Mysql::ClientError, 'bind_result: result value count(4) != number of argument(1)' do
-          @s.bind_result(nil)
-        end
-      end
-    end
-
     test '#close returns nil' do
       assert{ @s.close == nil }
     end
@@ -1066,8 +867,8 @@ class TestMysql < Test::Unit::TestCase
       @s.prepare 'select * from t'
       @s.execute
       expect = [
-        [1, 'abc', Mysql::Time.new(1970,12,24,23,59,05)],
-        [2, 'def', Mysql::Time.new(2112,9,3,12,34,56)],
+        [1, 'abc', Time.new(1970,12,24,23,59,05)],
+        [2, 'def', Time.new(2112,9,3,12,34,56)],
         [3, '123', nil],
       ]
       @s.each do |a|
@@ -1213,20 +1014,16 @@ class TestMysql < Test::Unit::TestCase
       @m.query 'insert into t values (0),(-1),(127),(-128),(255),(-255),(256)'
       @s.prepare 'select i from t'
       @s.execute
-      if defined? Encoding
-        assert{ @s.entries == [
-            ["\x00".force_encoding('ASCII-8BIT')],
-            ["\xff".force_encoding('ASCII-8BIT')],
-            ["\x7f".force_encoding('ASCII-8BIT')],
-            ["\xff".force_encoding('ASCII-8BIT')],
-            ["\xff".force_encoding('ASCII-8BIT')],
-            ["\xff".force_encoding('ASCII-8BIT')],
-            ["\xff".force_encoding('ASCII-8BIT')],
-          ]
-        }
-      else
-        assert{ @s.entries == [["\x00"], ["\xff"], ["\x7f"], ["\xff"], ["\xff"], ["\xff"], ["\xff"]] }
-      end
+      assert{ @s.entries == [
+          ["\x00".force_encoding('ASCII-8BIT')],
+          ["\xff".force_encoding('ASCII-8BIT')],
+          ["\x7f".force_encoding('ASCII-8BIT')],
+          ["\xff".force_encoding('ASCII-8BIT')],
+          ["\xff".force_encoding('ASCII-8BIT')],
+          ["\xff".force_encoding('ASCII-8BIT')],
+          ["\xff".force_encoding('ASCII-8BIT')],
+        ]
+      }
     end
 
     test '#fetch bit column (64bit)' do
@@ -1234,25 +1031,14 @@ class TestMysql < Test::Unit::TestCase
       @m.query 'insert into t values (0),(-1),(4294967296),(18446744073709551615),(18446744073709551616)'
       @s.prepare 'select i from t'
       @s.execute
-      if defined? Encoding
-        assert{ @s.entries == [
-            ["\x00\x00\x00\x00\x00\x00\x00\x00".force_encoding('ASCII-8BIT')],
-            ["\xff\xff\xff\xff\xff\xff\xff\xff".force_encoding('ASCII-8BIT')],
-            ["\x00\x00\x00\x01\x00\x00\x00\x00".force_encoding('ASCII-8BIT')],
-            ["\xff\xff\xff\xff\xff\xff\xff\xff".force_encoding('ASCII-8BIT')],
-            ["\xff\xff\xff\xff\xff\xff\xff\xff".force_encoding('ASCII-8BIT')],
-          ]
-        }
-      else
-        assert{ @s.entries == [
-            ["\x00\x00\x00\x00\x00\x00\x00\x00"],
-            ["\xff\xff\xff\xff\xff\xff\xff\xff"],
-            ["\x00\x00\x00\x01\x00\x00\x00\x00"],
-            ["\xff\xff\xff\xff\xff\xff\xff\xff"],
-            ["\xff\xff\xff\xff\xff\xff\xff\xff"],
-          ]
-        }
-      end
+      assert{ @s.entries == [
+          ["\x00\x00\x00\x00\x00\x00\x00\x00".force_encoding('ASCII-8BIT')],
+          ["\xff\xff\xff\xff\xff\xff\xff\xff".force_encoding('ASCII-8BIT')],
+          ["\x00\x00\x00\x01\x00\x00\x00\x00".force_encoding('ASCII-8BIT')],
+          ["\xff\xff\xff\xff\xff\xff\xff\xff".force_encoding('ASCII-8BIT')],
+          ["\xff\xff\xff\xff\xff\xff\xff\xff".force_encoding('ASCII-8BIT')],
+        ]
+      }
     end
 
     test '#fetch tinyint column' do
@@ -1405,14 +1191,11 @@ class TestMysql < Test::Unit::TestCase
       @s.prepare 'select i from t'
       @s.execute
       cols = @s.fetch
-      assert{ cols == [Mysql::Time.new] }
-      assert{ cols.first.to_s == '0000-00-00' }
+      assert{ cols == [nil] }
       cols = @s.fetch
-      assert{ cols == [Mysql::Time.new(1000,1,1)] }
-      assert{ cols.first.to_s == '1000-01-01' }
+      assert{ cols == [Time.new(1000,1,1)] }
       cols = @s.fetch
-      assert{ cols == [Mysql::Time.new(9999,12,31)] }
-      assert{ cols.first.to_s == '9999-12-31' }
+      assert{ cols == [Time.new(9999,12,31)] }
     end
 
     test '#fetch datetime column' do
@@ -1420,9 +1203,9 @@ class TestMysql < Test::Unit::TestCase
       @m.query "insert into t values ('0000-00-00 00:00:00'),('1000-01-01 00:00:00'),('9999-12-31 23:59:59')"
       @s.prepare 'select i from t'
       @s.execute
-      assert{ @s.fetch == [Mysql::Time.new] }
-      assert{ @s.fetch == [Mysql::Time.new(1000,1,1)] }
-      assert{ @s.fetch == [Mysql::Time.new(9999,12,31,23,59,59)] }
+      assert{ @s.fetch == [nil] }
+      assert{ @s.fetch == [Time.new(1000,1,1)] }
+      assert{ @s.fetch == [Time.new(9999,12,31,23,59,59)] }
     end
 
     test '#fetch timestamp column' do
@@ -1430,8 +1213,8 @@ class TestMysql < Test::Unit::TestCase
       @m.query("insert into t values ('1970-01-02 00:00:00'),('2037-12-30 23:59:59')")
       @s.prepare 'select i from t'
       @s.execute
-      assert{ @s.fetch == [Mysql::Time.new(1970,1,2)] }
-      assert{ @s.fetch == [Mysql::Time.new(2037,12,30,23,59,59)] }
+      assert{ @s.fetch == [Time.new(1970,1,2)] }
+      assert{ @s.fetch == [Time.new(2037,12,30,23,59,59)] }
     end
 
     test '#fetch time column' do
@@ -1439,9 +1222,9 @@ class TestMysql < Test::Unit::TestCase
       @m.query "insert into t values ('-838:59:59'),(0),('838:59:59')"
       @s.prepare 'select i from t'
       @s.execute
-      assert{ @s.fetch == [Mysql::Time.new(0,0,0,838,59,59,true)] }
-      assert{ @s.fetch == [Mysql::Time.new(0,0,0,0,0,0,false)] }
-      assert{ @s.fetch == [Mysql::Time.new(0,0,0,838,59,59,false)] }
+      assert{ @s.fetch == [-(838*3600+59*60+59)] }
+      assert{ @s.fetch == [0] }
+      assert{ @s.fetch == [838*3600+59*60+59] }
     end
 
     test '#fetch year column' do
@@ -1666,79 +1449,6 @@ class TestMysql < Test::Unit::TestCase
     end
   end
 
-  sub_test_case 'Mysql::Time' do
-    setup do
-      @t = Mysql::Time.new
-    end
-
-    test '.new with no arguments returns 0' do
-      assert{ @t.year == 0 }
-      assert{ @t.month == 0 }
-      assert{ @t.day == 0 }
-      assert{ @t.hour == 0 }
-      assert{ @t.minute == 0 }
-      assert{ @t.second == 0 }
-      assert{ @t.neg == false }
-      assert{ @t.second_part == 0 }
-    end
-
-    test '#inspect' do
-      assert{ Mysql::Time.new(2009,12,8,23,35,21).inspect == '#<Mysql::Time:2009-12-08 23:35:21>' }
-    end
-
-    test '#to_s' do
-      assert{ Mysql::Time.new(2009,12,8,23,35,21).to_s == '2009-12-08 23:35:21' }
-    end
-
-    test '#to_i' do
-      assert{ Mysql::Time.new(2009,12,8,23,35,21).to_i == 20091208233521 }
-    end
-
-    test '#year' do
-      assert{ (@t.year = 2009) == 2009 }
-      assert{ @t.year == 2009 }
-    end
-
-    test '#month' do
-      assert{ (@t.month = 12) == 12 }
-      assert{ @t.month == 12 }
-    end
-
-    test '#day' do
-      assert{ (@t.day = 8) == 8 }
-      assert{ @t.day == 8 }
-    end
-
-    test '#hour' do
-      assert{ (@t.hour = 23) == 23 }
-      assert{ @t.hour == 23 }
-    end
-
-    test '#minute' do
-      assert{ (@t.minute = 35) == 35 }
-      assert{ @t.minute == 35 }
-    end
-
-    test '#second' do
-      assert{ (@t.second = 21) == 21 }
-      assert{ @t.second == 21 }
-    end
-
-    test '#neg' do
-      assert{ @t.neg == false }
-    end
-
-    test '#second_part' do
-      assert{ @t.second_part == 0 }
-    end
-
-    test '#==' do
-      t1 = Mysql::Time.new 2009,12,8,23,35,21
-      t2 = Mysql::Time.new 2009,12,8,23,35,21
-      assert{ t1 == t2 }
-    end
-  end
-
   sub_test_case 'Mysql::Error' do
     setup do
       m = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
@@ -1761,90 +1471,94 @@ class TestMysql < Test::Unit::TestCase
     end
   end
 
-  if defined? Encoding
-    sub_test_case 'Connection charset is UTF-8:' do
+  sub_test_case 'Connection charset is UTF-8:' do
+    setup do
+      @m = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m.charset = "utf8"
+      @m.query "create temporary table t (utf8 char(10) charset utf8, cp932 char(10) charset cp932, eucjp char(10) charset eucjpms, bin varbinary(10))"
+      @utf8 = "いろは"
+      @cp932 = @utf8.encode "CP932"
+      @eucjp = @utf8.encode "EUC-JP-MS"
+      @bin = "\x00\x01\x7F\x80\xFE\xFF".force_encoding("ASCII-8BIT")
+      @default_internal = Encoding.default_internal
+    end
+
+    teardown do
+      v =  $VERBOSE
+      $VERBOSE = false
+      Encoding.default_internal = @default_internal
+      $VERBOSE = v
+    end
+
+    sub_test_case 'default_internal is CP932' do
       setup do
-        @m = Mysql.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
-        @m.charset = "utf8"
-        @m.query "create temporary table t (utf8 char(10) charset utf8, cp932 char(10) charset cp932, eucjp char(10) charset eucjpms, bin varbinary(10))"
-        @utf8 = "いろは"
-        @cp932 = @utf8.encode "CP932"
-        @eucjp = @utf8.encode "EUC-JP-MS"
-        @bin = "\x00\x01\x7F\x80\xFE\xFF".force_encoding("ASCII-8BIT")
-        @default_internal = Encoding.default_internal
+        @m.prepare("insert into t (utf8,cp932,eucjp,bin) values (?,?,?,?)").execute @utf8, @cp932, @eucjp, @bin
+        v =  $VERBOSE
+        $VERBOSE = false
+        Encoding.default_internal = 'CP932'
+        $VERBOSE = v
       end
-
-      teardown do
-        Encoding.default_internal = @default_internal
+      test 'is converted to CP932' do
+        assert @m.query('select "あいう"').fetch == ["\x82\xA0\x82\xA2\x82\xA4".force_encoding("CP932")]
       end
-
-      sub_test_case 'default_internal is CP932' do
-        setup do
-          @m.prepare("insert into t (utf8,cp932,eucjp,bin) values (?,?,?,?)").execute @utf8, @cp932, @eucjp, @bin
-          Encoding.default_internal = 'CP932'
-        end
-        test 'is converted to CP932' do
-          assert @m.query('select "あいう"').fetch == ["\x82\xA0\x82\xA2\x82\xA4".force_encoding("CP932")]
-        end
-        test 'data is stored as is' do
-          assert @m.query('select hex(utf8),hex(cp932),hex(eucjp),hex(bin) from t').fetch == ['E38184E3828DE381AF', '82A282EB82CD', 'A4A4A4EDA4CF', '00017F80FEFF']
-        end
-        test 'By simple query, charset of retrieved data is connection charset' do
-          assert @m.query('select utf8,cp932,eucjp,bin from t').fetch == [@cp932, @cp932, @cp932, @bin]
-        end
-        test 'By prepared statement, charset of retrieved data is connection charset except for binary' do
-          assert @m.prepare('select utf8,cp932,eucjp,bin from t').execute.fetch == [@cp932, @cp932, @cp932, @bin]
-        end
+      test 'data is stored as is' do
+        assert @m.query('select hex(utf8),hex(cp932),hex(eucjp),hex(bin) from t').fetch == ['E38184E3828DE381AF', '82A282EB82CD', 'A4A4A4EDA4CF', '00017F80FEFF']
+      end
+      test 'By simple query, charset of retrieved data is connection charset' do
+        assert @m.query('select utf8,cp932,eucjp,bin from t').fetch == [@cp932, @cp932, @cp932, @bin]
+      end
+      test 'By prepared statement, charset of retrieved data is connection charset except for binary' do
+        assert @m.prepare('select utf8,cp932,eucjp,bin from t').execute.fetch == [@cp932, @cp932, @cp932, @bin]
       end
+    end
 
-      sub_test_case 'query with CP932 encoding' do
-        test 'is converted to UTF-8' do
-          assert @m.query('select HEX("あいう")'.encode("CP932")).fetch == ["E38182E38184E38186"]
-        end
+    sub_test_case 'query with CP932 encoding' do
+      test 'is converted to UTF-8' do
+        assert @m.query('select HEX("あいう")'.encode("CP932")).fetch == ["E38182E38184E38186"]
       end
+    end
 
-      sub_test_case 'prepared statement with CP932 encoding' do
-        test 'is converted to UTF-8' do
-          assert @m.prepare('select HEX("あいう")'.encode("CP932")).execute.fetch == ["E38182E38184E38186"]
-        end
+    sub_test_case 'prepared statement with CP932 encoding' do
+      test 'is converted to UTF-8' do
+        assert @m.prepare('select HEX("あいう")'.encode("CP932")).execute.fetch == ["E38182E38184E38186"]
       end
+    end
 
-      sub_test_case 'The encoding of data are correspond to charset of column:' do
-        setup do
-          @m.prepare("insert into t (utf8,cp932,eucjp,bin) values (?,?,?,?)").execute @utf8, @cp932, @eucjp, @bin
-        end
-        test 'data is stored as is' do
-          assert{ @m.query('select hex(utf8),hex(cp932),hex(eucjp),hex(bin) from t').fetch == ['E38184E3828DE381AF', '82A282EB82CD', 'A4A4A4EDA4CF', '00017F80FEFF'] }
-        end
-        test 'By simple query, charset of retrieved data is connection charset' do
-          assert{ @m.query('select utf8,cp932,eucjp,bin from t').fetch == [@utf8, @utf8, @utf8, @bin] }
-        end
-        test 'By prepared statement, charset of retrieved data is connection charset except for binary' do
-          assert{ @m.prepare('select utf8,cp932,eucjp,bin from t').execute.fetch == [@utf8, @utf8, @utf8, @bin] }
-        end
+    sub_test_case 'The encoding of data are correspond to charset of column:' do
+      setup do
+        @m.prepare("insert into t (utf8,cp932,eucjp,bin) values (?,?,?,?)").execute @utf8, @cp932, @eucjp, @bin
+      end
+      test 'data is stored as is' do
+        assert{ @m.query('select hex(utf8),hex(cp932),hex(eucjp),hex(bin) from t').fetch == ['E38184E3828DE381AF', '82A282EB82CD', 'A4A4A4EDA4CF', '00017F80FEFF'] }
       end
+      test 'By simple query, charset of retrieved data is connection charset' do
+        assert{ @m.query('select utf8,cp932,eucjp,bin from t').fetch == [@utf8, @utf8, @utf8, @bin] }
+      end
+      test 'By prepared statement, charset of retrieved data is connection charset except for binary' do
+        assert{ @m.prepare('select utf8,cp932,eucjp,bin from t').execute.fetch == [@utf8, @utf8, @utf8, @bin] }
+      end
+    end
 
-      sub_test_case 'The encoding of data are different from charset of column:' do
-        setup do
-          @m.prepare("insert into t (utf8,cp932,eucjp,bin) values (?,?,?,?)").execute @utf8, @utf8, @utf8, @utf8
-        end
-        test 'stored data is converted' do
-          assert{ @m.query("select hex(utf8),hex(cp932),hex(eucjp),hex(bin) from t").fetch == ["E38184E3828DE381AF", "82A282EB82CD", "A4A4A4EDA4CF", "E38184E3828DE381AF"] }
-        end
-        test 'By simple query, charset of retrieved data is connection charset' do
-          assert{ @m.query("select utf8,cp932,eucjp,bin from t").fetch == [@utf8, @utf8, @utf8, @utf8.dup.force_encoding('ASCII-8BIT')] }
-        end
-        test 'By prepared statement, charset of retrieved data is connection charset except for binary' do
-          assert{ @m.prepare("select utf8,cp932,eucjp,bin from t").execute.fetch == [@utf8, @utf8, @utf8, @utf8.dup.force_encoding("ASCII-8BIT")] }
-        end
+    sub_test_case 'The encoding of data are different from charset of column:' do
+      setup do
+        @m.prepare("insert into t (utf8,cp932,eucjp,bin) values (?,?,?,?)").execute @utf8, @utf8, @utf8, @utf8
       end
+      test 'stored data is converted' do
+        assert{ @m.query("select hex(utf8),hex(cp932),hex(eucjp),hex(bin) from t").fetch == ["E38184E3828DE381AF", "82A282EB82CD", "A4A4A4EDA4CF", "E38184E3828DE381AF"] }
+      end
+      test 'By simple query, charset of retrieved data is connection charset' do
+        assert{ @m.query("select utf8,cp932,eucjp,bin from t").fetch == [@utf8, @utf8, @utf8, @utf8.dup.force_encoding('ASCII-8BIT')] }
+      end
+      test 'By prepared statement, charset of retrieved data is connection charset except for binary' do
+        assert{ @m.prepare("select utf8,cp932,eucjp,bin from t").execute.fetch == [@utf8, @utf8, @utf8, @utf8.dup.force_encoding("ASCII-8BIT")] }
+      end
+    end
 
-      sub_test_case 'The data include invalid byte code:' do
-        test 'raises Encoding::InvalidByteSequenceError' do
-          cp932 = "\x01\xFF\x80".force_encoding("CP932")
-          assert_raise Encoding::InvalidByteSequenceError do
-            @m.prepare("insert into t (cp932) values (?)").execute cp932
-          end
+    sub_test_case 'The data include invalid byte code:' do
+      test 'raises Encoding::InvalidByteSequenceError' do
+        cp932 = "\x01\xFF\x80".force_encoding("CP932")
+        assert_raise Encoding::InvalidByteSequenceError do
+          @m.prepare("insert into t (cp932) values (?)").execute cp932
         end
       end
     end