sqlite3-ruby 1.2.5-x86-mingw32 → 1.3.0.beta.1-x86-mingw32

data/test/test_encoding.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+
+require 'helper'
+
+module SQLite3
+  class TestEncoding < Test::Unit::TestCase
+    def setup
+      @db = SQLite3::Database.new(':memory:')
+      @create = "create table ex(id int, data string)"
+      @insert = "insert into ex(id, data) values (?, ?)"
+      @db.execute(@create);
+    end
+
+    def test_default_internal_is_honored
+      before_enc = Encoding.default_internal
+
+      str = "壁に耳あり、障子に目あり"
+      stmt = @db.prepare('insert into ex(data) values (?)')
+      stmt.bind_param 1, str
+      stmt.step
+
+      Encoding.default_internal = 'EUC-JP'
+      string = @db.execute('select data from ex').first.first
+
+      assert_equal Encoding.default_internal, string.encoding
+      assert_equal str.encode('EUC-JP'), string
+      assert_equal str, string.encode(str.encoding)
+    ensure
+      Encoding.default_internal = before_enc
+    end
+
+    def test_blob_is_binary
+      str = "猫舌"
+      @db.execute('create table foo(data text)')
+      stmt = @db.prepare('insert into foo(data) values (?)')
+      stmt.bind_param(1, SQLite3::Blob.new(str))
+      stmt.step
+
+      string = @db.execute('select data from foo').first.first
+      assert_equal Encoding.find('ASCII-8BIT'), string.encoding
+      assert_equal str, string.force_encoding('UTF-8')
+    end
+
+    def test_blob_is_ascii8bit
+      str = "猫舌"
+      @db.execute('create table foo(data text)')
+      stmt = @db.prepare('insert into foo(data) values (?)')
+      stmt.bind_param(1, str.dup.force_encoding("ASCII-8BIT"))
+      stmt.step
+
+      string = @db.execute('select data from foo').first.first
+      assert_equal Encoding.find('ASCII-8BIT'), string.encoding
+      assert_equal str, string.force_encoding('UTF-8')
+    end
+
+    def test_blob_with_eucjp
+      str = "猫舌".encode("EUC-JP")
+      @db.execute('create table foo(data text)')
+      stmt = @db.prepare('insert into foo(data) values (?)')
+      stmt.bind_param(1, SQLite3::Blob.new(str))
+      stmt.step
+
+      string = @db.execute('select data from foo').first.first
+      assert_equal Encoding.find('ASCII-8BIT'), string.encoding
+      assert_equal str, string.force_encoding('EUC-JP')
+    end
+
+    def test_db_with_eucjp
+      db = SQLite3::Database.new(':memory:'.encode('EUC-JP'))
+      assert_equal(Encoding.find('UTF-8'), db.encoding)
+    end
+
+    def test_db_with_utf16
+      db = SQLite3::Database.new(':memory:'.encode('UTF-16LE'))
+      assert_equal(Encoding.find('UTF-16LE'), db.encoding)
+    end
+
+    def test_statement_eucjp
+      str = "猫舌"
+      @db.execute("insert into ex(data) values ('#{str}')".encode('EUC-JP'))
+      row = @db.execute("select data from ex")
+      assert_equal @db.encoding, row.first.first.encoding
+      assert_equal str, row.first.first
+    end
+
+    def test_statement_utf8
+      str = "猫舌"
+      @db.execute("insert into ex(data) values ('#{str}')")
+      row = @db.execute("select data from ex")
+      assert_equal @db.encoding, row.first.first.encoding
+      assert_equal str, row.first.first
+    end
+
+    def test_encoding
+      assert_equal Encoding.find("UTF-8"), @db.encoding
+    end
+
+    def test_utf_8
+      str = "猫舌"
+      @db.execute(@insert, 10, str)
+      row = @db.execute("select data from ex")
+      assert_equal @db.encoding, row.first.first.encoding
+      assert_equal str, row.first.first
+    end
+
+    def test_euc_jp
+      str = "猫舌".encode('EUC-JP')
+      @db.execute(@insert, 10, str)
+      row = @db.execute("select data from ex")
+      assert_equal @db.encoding, row.first.first.encoding
+      assert_equal str.encode('UTF-8'), row.first.first
+    end
+
+  end if RUBY_VERSION >= '1.9.1'
+end

data/test/test_integration.rb

@@ -1,8 +1,8 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require 'helper'
 
 class TC_Database_Integration < Test::Unit::TestCase
   def setup
-    @db = SQLite3::Database.new( "test.db" )
+    @db = SQLite3::Database.new(":memory:")
     @db.transaction do
       @db.execute "create table foo ( a integer primary key, b text )"
       @db.execute "insert into foo ( b ) values ( 'foo' )"
@@ -13,7 +13,6 @@ class TC_Database_Integration < Test::Unit::TestCase
 
   def teardown
     @db.close
-    File.delete( "test.db" )
   end
 
   def test_table_info_with_type_translation_active
@@ -25,9 +24,9 @@ class TC_Database_Integration < Test::Unit::TestCase
     @db.transaction do
       @db.execute "create table defaults_test ( a string default NULL, b string default 'Hello' )"
       data = @db.table_info( "defaults_test" )
-      assert_equal({"name" => "a", "type" => "string", "dflt_value" => nil, "notnull" => "0", "cid" => "0", "pk" => "0"},
+      assert_equal({"name" => "a", "type" => "string", "dflt_value" => nil, "notnull" => 0, "cid" => 0, "pk" => 0},
         data[0])
-      assert_equal({"name" => "b", "type" => "string", "dflt_value" => "Hello", "notnull" => "0", "cid" => "1", "pk" => "0"},
+      assert_equal({"name" => "b", "type" => "string", "dflt_value" => "Hello", "notnull" => 0, "cid" => 1, "pk" => 0},
         data[1])
     end
   end
@@ -36,9 +35,9 @@ class TC_Database_Integration < Test::Unit::TestCase
     @db.transaction do
       @db.execute "create table no_defaults_test ( a integer default 1, b integer )"
       data = @db.table_info( "no_defaults_test" )
-      assert_equal({"name" => "a", "type" => "integer", "dflt_value" => "1", "notnull" => "0", "cid" => "0", "pk" => "0"},
+      assert_equal({"name" => "a", "type" => "integer", "dflt_value" => "1", "notnull" => 0, "cid" => 0, "pk" => 0},
         data[0])
-      assert_equal({"name" => "b", "type" => "integer", "dflt_value" => nil, "notnull" => "0", "cid" => "1", "pk" => "0"},
+      assert_equal({"name" => "b", "type" => "integer", "dflt_value" => nil, "notnull" => 0, "cid" => 1, "pk" => 0},
         data[1])
     end
   end
@@ -50,21 +49,25 @@ class TC_Database_Integration < Test::Unit::TestCase
     assert @db.complete?( "select * from foo;" )
   end
 
-  def test_complete_fail_utf16
-    assert !@db.complete?( "select * from foo".to_utf16(false), true )
-  end
+  # FIXME: do people really need UTF16 sql statements?
+  #def test_complete_fail_utf16
+  #  assert !@db.complete?( "select * from foo".to_utf16(false), true )
+  #end
 
-  def test_complete_success_utf16
-    assert @db.complete?( "select * from foo;".to_utf16(true), true )
-  end
+  # FIXME: do people really need UTF16 sql statements?
+  #def test_complete_success_utf16
+  #  assert @db.complete?( "select * from foo;".to_utf16(true), true )
+  #end
 
   def test_errmsg
     assert_equal "not an error", @db.errmsg
   end
 
-  def test_errmsg_utf16
-    assert_equal "not an error".to_utf16, @db.errmsg(true)
-  end
+  # FIXME: do people really need UTF16 error messages?
+  #def test_errmsg_utf16
+  #  msg = Iconv.conv('UTF-16', 'UTF-8', 'not an error')
+  #  assert_equal msg, @db.errmsg(true)
+  #end
 
   def test_errcode
     assert_equal 0, @db.errcode
@@ -72,26 +75,26 @@ class TC_Database_Integration < Test::Unit::TestCase
 
   def test_trace
     result = nil
-    @db.trace( "data" ) { |data,sql| result = [ data, sql ]; 0 }
+    @db.trace { |sql| result = sql }
     @db.execute "select * from foo"
-    assert_equal ["data","select * from foo"], result
+    assert_equal "select * from foo", result
   end
 
   def test_authorizer_okay
-    @db.authorizer( "data" ) { |data,type,a,b,c,d| 0 }
+    @db.authorizer { |type,a,b,c,d| 0 }
     rows = @db.execute "select * from foo"
     assert_equal 3, rows.length
   end
 
   def test_authorizer_error
-    @db.authorizer( "data" ) { |data,type,a,b,c,d| 1 }
+    @db.authorizer { |type,a,b,c,d| 1 }
     assert_raise( SQLite3::AuthorizationException ) do
       @db.execute "select * from foo"
     end
   end
 
   def test_authorizer_silent
-    @db.authorizer( "data" ) { |data,type,a,b,c,d| 2 }
+    @db.authorizer { |type,a,b,c,d| 2 }
     rows = @db.execute "select * from foo"
     assert rows.empty?
   end
@@ -184,7 +187,7 @@ class TC_Database_Integration < Test::Unit::TestCase
   def test_execute2_no_block_no_bind_no_match
     columns, *rows = @db.execute2( "select * from foo where a > 100" )
     assert rows.empty?
-    assert [ "a", "b" ], columns
+    assert_equal [ "a", "b" ], columns
   end
 
   def test_execute2_with_block_no_bind_no_match
@@ -199,13 +202,13 @@ class TC_Database_Integration < Test::Unit::TestCase
   def test_execute2_no_block_with_bind_no_match
     columns, *rows = @db.execute2( "select * from foo where a > ?", 100 )
     assert rows.empty?
-    assert [ "a", "b" ], columns
+    assert_equal [ "a", "b" ], columns
   end
 
   def test_execute2_with_block_with_bind_no_match
     called = 0
     @db.execute2( "select * from foo where a > ?", 100 ) do |row|
-      assert [ "a", "b" ], row unless called == 0
+      assert_equal [ "a", "b" ], row unless called == 0
       called += 1
     end
     assert_equal 1, called
@@ -214,13 +217,13 @@ class TC_Database_Integration < Test::Unit::TestCase
   def test_execute2_no_block_no_bind_with_match
     columns, *rows = @db.execute2( "select * from foo where a = 1" )
     assert_equal 1, rows.length
-    assert [ "a", "b" ], columns
+    assert_equal [ "a", "b" ], columns
   end
 
   def test_execute2_with_block_no_bind_with_match
     called = 0
     @db.execute2( "select * from foo where a = 1" ) do |row|
-      assert [ "a", "b" ], row unless called == 0
+      assert_equal [ 1, "foo" ], row unless called == 0
       called += 1
     end
     assert_equal 2, called
@@ -229,7 +232,7 @@ class TC_Database_Integration < Test::Unit::TestCase
   def test_execute2_no_block_with_bind_with_match
     columns, *rows = @db.execute2( "select * from foo where a = ?", 1 )
     assert_equal 1, rows.length
-    assert [ "a", "b" ], columns
+    assert_equal [ "a", "b" ], columns
   end
 
   def test_execute2_with_block_with_bind_with_match
@@ -265,7 +268,7 @@ class TC_Database_Integration < Test::Unit::TestCase
       insert into bar values ( 'seven', 8, ? );
     SQL
     rows = @db.execute( "select * from bar" ).map { |a,b,c| c }
-    assert_equal %w{1 1 1}, rows
+    assert_equal [1, 1, 1], rows
   end
 
   def test_query_no_block_no_bind_no_match
@@ -339,7 +342,7 @@ class TC_Database_Integration < Test::Unit::TestCase
 
   def test_get_first_row_no_bind_with_match
     result = @db.get_first_row( "select * from foo where a=1" )
-    assert_equal [ "1", "foo" ], result
+    assert_equal [ 1, "foo" ], result
   end
 
   def test_get_first_row_with_bind_no_match
@@ -349,7 +352,7 @@ class TC_Database_Integration < Test::Unit::TestCase
 
   def test_get_first_row_with_bind_with_match
     result = @db.get_first_row( "select * from foo where a=?", 1 )
-    assert_equal [ "1", "foo" ], result
+    assert_equal [ 1, "foo" ], result
   end
 
   def test_get_first_value_no_bind_no_match
@@ -458,7 +461,7 @@ class TC_Database_Integration < Test::Unit::TestCase
       func.result = x
     end
 
-    assert_raise( SQLite3::SQLException ) do
+    assert_raise( SQLite3::InterruptException ) do
       @db.execute "select abort(a) from foo"
     end
   end
@@ -483,7 +486,7 @@ class TC_Database_Integration < Test::Unit::TestCase
     @db.create_aggregate( "accumulate", 1, step, final )
 
     value = @db.get_first_value( "select accumulate(a) from foo" )
-    assert_equal "6", value
+    assert_equal 6, value
   end
 
   def test_create_aggregate_with_block
@@ -497,7 +500,7 @@ class TC_Database_Integration < Test::Unit::TestCase
     end
 
     value = @db.get_first_value( "select accumulate(a) from foo" )
-    assert_equal "6", value
+    assert_equal 6, value
   end
 
   def test_create_aggregate_with_no_data
@@ -512,7 +515,7 @@ class TC_Database_Integration < Test::Unit::TestCase
 
     value = @db.get_first_value(
       "select accumulate(a) from foo where a = 100" )
-    assert_equal "0", value
+    assert_equal 0, value
   end
 
   def test_create_aggregate_handler
@@ -531,7 +534,7 @@ class TC_Database_Integration < Test::Unit::TestCase
 
     @db.create_aggregate_handler( handler )
     value = @db.get_first_value( "select multiply(a) from foo" )
-    assert_equal "6", value
+    assert_equal 6, value
   end
 
   def test_bind_array_parameter

data/test/test_integration_open_close.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require 'helper'
 
 class TC_OpenClose < Test::Unit::TestCase
   def test_create_close

data/test/test_integration_pending.rb

@@ -1,11 +1,11 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require 'helper'
 
 require 'thread'
 require 'benchmark'
 
 class TC_Integration_Pending < Test::Unit::TestCase
   def setup
-    @db = SQLite3::Database.new( "test.db" )
+    @db = SQLite3::Database.new("test.db")
     @db.transaction do
       @db.execute "create table foo ( a integer primary key, b text )"
       @db.execute "insert into foo ( b ) values ( 'foo' )"
@@ -65,8 +65,9 @@ class TC_Integration_Pending < Test::Unit::TestCase
         db2.close if db2
       end
     end
+    sleep 1
 
-    @db.busy_handler do |data, count|
+    @db.busy_handler do |count|
       handler_call_count += 1
       false
     end
@@ -97,6 +98,7 @@ class TC_Integration_Pending < Test::Unit::TestCase
       end
     end
 
+    sleep 1
     time = Benchmark.measure do
       assert_raise( SQLite3::BusyException ) do
         @db.execute "insert into foo (b) values ( 'from 2' )"
@@ -108,4 +110,4 @@ class TC_Integration_Pending < Test::Unit::TestCase
 
     assert time.real*1000 >= 1000
   end
-end
+end

data/test/test_integration_resultset.rb

@@ -1,8 +1,8 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require 'helper'
 
 class TC_ResultSet < Test::Unit::TestCase
   def setup
-    @db = SQLite3::Database.new( "test.db" )
+    @db = SQLite3::Database.new(":memory:")
     @db.transaction do
       @db.execute "create table foo ( a integer primary key, b text )"
       @db.execute "insert into foo ( b ) values ( 'foo' )"
@@ -16,7 +16,6 @@ class TC_ResultSet < Test::Unit::TestCase
   def teardown
     @stmt.close
     @db.close
-    File.delete( "test.db" )
   end
 
   def test_reset_unused
@@ -56,7 +55,7 @@ class TC_ResultSet < Test::Unit::TestCase
 
   def test_next_no_type_translation_no_hash
     @result.reset( 1 )
-    assert_equal [ "1", "foo" ], @result.next
+    assert_equal [ 1, "foo" ], @result.next
   end
 
   def test_next_type_translation
@@ -68,7 +67,7 @@ class TC_ResultSet < Test::Unit::TestCase
   def test_next_type_translation_with_untyped_column
     @db.type_translation = true
     @db.query( "select count(*) from foo" ) do |result|
-      assert_equal ["3"], result.next
+      assert_equal [3], result.next
     end
   end
 
@@ -98,10 +97,23 @@ class TC_ResultSet < Test::Unit::TestCase
     end
   end
 
+  def test_real_translation
+    @db.type_translation = true
+    @db.execute('create table foo_real(a real)')
+    @db.execute('insert into foo_real values (42)' )
+    @db.query('select a, sum(a), typeof(a), typeof(sum(a)) from foo_real') do |result|
+      result = result.next
+      assert result[0].is_a?(Float)
+      assert result[1].is_a?(Float)
+      assert result[2].is_a?(String)
+      assert result[3].is_a?(String)
+    end
+  end
+
   def test_next_results_as_hash
     @db.results_as_hash = true
     @result.reset( 1 )
-    assert_equal( { "a" => "1", "b" => "foo", 0 => "1", 1 => "foo" },
+    assert_equal( { "a" => 1, "b" => "foo", 0 => 1, 1 => "foo" },
       @result.next )
   end
 
@@ -110,7 +122,7 @@ class TC_ResultSet < Test::Unit::TestCase
     @result.reset( 1 )
     row = @result.next
     row.each do |_, v|
-      assert_equal true, v.tainted?
+      assert(v.tainted?) if String === v
     end
   end
 
@@ -118,7 +130,7 @@ class TC_ResultSet < Test::Unit::TestCase
     @result.reset( 1 )
     row = @result.next
     row.each do |v|
-      assert_equal true, v.tainted?
+      assert(v.tainted?) if String === v
     end
   end