sqlite3 1.3.5 → 1.3.13

data/test/helper.rb

@@ -1,3 +1,18 @@
 require 'sqlite3'
-require 'test/unit'
-require 'iconv'
+require 'minitest/autorun'
+
+unless RUBY_VERSION >= "1.9"
+  require 'iconv'
+end
+
+module SQLite3
+  class TestCase < Minitest::Test
+    alias :assert_not_equal :refute_equal
+    alias :assert_not_nil   :refute_nil
+    alias :assert_raise     :assert_raises
+
+    def assert_nothing_raised
+      yield
+    end
+  end
+end

data/test/test_backup.rb

@@ -1,7 +1,7 @@
-require File.expand_path('helper', File.dirname(__FILE__))
+require 'helper'
 
 module SQLite3
-  class TestBackup < Test::Unit::TestCase
+  class TestBackup < SQLite3::TestCase
     def setup
       @sdb = SQLite3::Database.new(':memory:')
       @ddb = SQLite3::Database.new(':memory:')

data/test/test_collation.rb

@@ -3,7 +3,7 @@
 require 'helper'
 
 module SQLite3
-  class TestCollation < Test::Unit::TestCase
+  class TestCollation < SQLite3::TestCase
     class Comparator
       attr_reader :calls
       def initialize

data/test/test_database.rb

@@ -1,17 +1,50 @@
 require 'helper'
+require 'tempfile'
+require 'pathname'
 
 module SQLite3
-  class TestDatabase < Test::Unit::TestCase
+  class TestDatabase < SQLite3::TestCase
     attr_reader :db
 
     def setup
       @db = SQLite3::Database.new(':memory:')
+      super
     end
 
     def test_segv
       assert_raises(TypeError) { SQLite3::Database.new 1 }
     end
 
+    def test_db_filename
+      tf = nil
+      assert_equal '', @db.filename('main')
+      tf = Tempfile.new 'thing'
+      @db = SQLite3::Database.new tf.path
+      assert_equal File.expand_path(tf.path), File.expand_path(@db.filename('main'))
+    ensure
+      tf.unlink if tf
+    end
+
+    def test_filename
+      tf = nil
+      assert_equal '', @db.filename
+      tf = Tempfile.new 'thing'
+      @db = SQLite3::Database.new tf.path
+      assert_equal File.expand_path(tf.path), File.expand_path(@db.filename)
+    ensure
+      tf.unlink if tf
+    end
+
+    def test_filename_with_attachment
+      tf = nil
+      assert_equal '', @db.filename
+      tf = Tempfile.new 'thing'
+      @db.execute "ATTACH DATABASE '#{tf.path}' AS 'testing'"
+      assert_equal File.expand_path(tf.path), File.expand_path(@db.filename('testing'))
+    ensure
+      tf.unlink if tf
+    end
+
     def test_bignum
       num = 4907021672125087844
       db.execute 'CREATE TABLE "employees" ("token" integer(8), "name" varchar(20) NOT NULL)'
@@ -22,9 +55,9 @@ module SQLite3
 
     def test_blob
       @db.execute("CREATE TABLE blobs ( id INTEGER, hash BLOB(10) )")
-      str = "\0foo"
-      @db.execute("INSERT INTO blobs VALUES (0, ?)", [str])
-      assert_equal [[0, str]], @db.execute("SELECT * FROM blobs")
+      blob = Blob.new("foo\0bar")
+      @db.execute("INSERT INTO blobs VALUES (0, ?)", [blob])
+      assert_equal [[0, blob, blob.length, blob.length*2]], @db.execute("SELECT id, hash, length(hash), length(hex(hash)) FROM blobs")
     end
 
     def test_get_first_row
@@ -60,6 +93,14 @@ module SQLite3
       assert_equal [[30]], @db.execute("select number from items")
     end
 
+    def test_batch_last_comment_is_processed
+      # FIXME: nil as a successful return value is kinda dumb
+      assert_nil @db.execute_batch <<-eosql
+        CREATE TABLE items (id integer PRIMARY KEY AUTOINCREMENT);
+        -- omg
+      eosql
+    end
+
     def test_new
       db = SQLite3::Database.new(':memory:')
       assert db
@@ -77,8 +118,12 @@ module SQLite3
       # determine if Ruby is running on Big Endian platform
       utf16 = ([1].pack("I") == [1].pack("N")) ? "UTF-16BE" : "UTF-16LE"
 
-      db = SQLite3::Database.new(Iconv.conv(utf16, 'UTF-8', ':memory:'),
-                                 :utf16 => true)
+      if RUBY_VERSION >= "1.9"
+        db = SQLite3::Database.new(':memory:'.encode(utf16), :utf16 => true)
+      else
+        db = SQLite3::Database.new(Iconv.conv(utf16, 'UTF-8', ':memory:'),
+                                   :utf16 => true)
+      end
       assert db
     end
 
@@ -97,12 +142,33 @@ module SQLite3
       assert thing.closed?
     end
 
+    def test_block_closes_self_even_raised
+      thing = nil
+      begin
+        SQLite3::Database.new(':memory:') do |db|
+          thing = db
+          raise
+        end
+      rescue
+      end
+      assert thing.closed?
+    end
+
     def test_prepare
       db = SQLite3::Database.new(':memory:')
       stmt = db.prepare('select "hello world"')
       assert_instance_of(SQLite3::Statement, stmt)
     end
 
+    def test_block_prepare_does_not_double_close
+      db = SQLite3::Database.new(':memory:')
+      r = db.prepare('select "hello world"') do |stmt|
+        stmt.close
+        :foo
+      end
+      assert_equal :foo, r
+    end
+
     def test_total_changes
       db = SQLite3::Database.new(':memory:')
       db.execute("create table foo ( a integer primary key, b text )")
@@ -223,18 +289,47 @@ module SQLite3
       assert_equal [2.2, 'foo', nil], called_with
     end
 
+    def test_call_func_blob
+      called_with = nil
+      @db.define_function("hello") do |a, b|
+        called_with = [a, b, a.length]
+        nil
+      end
+      blob = Blob.new("a\0fine\0kettle\0of\0fish")
+      @db.execute("select hello(?, length(?))", [blob, blob])
+      assert_equal [blob, blob.length, 21], called_with
+    end
+
     def test_function_return
       @db.define_function("hello") { |a| 10 }
       assert_equal [10], @db.execute("select hello('world')").first
     end
 
     def test_function_return_types
-      [10, 2.2, nil, "foo"].each do |thing|
+      [10, 2.2, nil, "foo", Blob.new("foo\0bar")].each do |thing|
         @db.define_function("hello") { |a| thing }
         assert_equal [thing], @db.execute("select hello('world')").first
       end
     end
 
+    def test_function_gc_segfault
+      @db.create_function("bug", -1) { |func, *values| func.result = values.join }
+      # With a lot of data and a lot of threads, try to induce a GC segfault.
+      params = Array.new(127, "?" * 28000)
+      proc = Proc.new {
+        db.execute("select bug(#{Array.new(params.length, "?").join(",")})", params)
+      }
+      m = Mutex.new
+      30.times.map { Thread.new { m.synchronize { proc.call } } }.each(&:join)
+    end
+
+    def test_function_return_type_round_trip
+      [10, 2.2, nil, "foo", Blob.new("foo\0bar")].each do |thing|
+        @db.define_function("hello") { |a| a }
+        assert_equal [thing], @db.execute("select hello(hello(?))", [thing]).first
+      end
+    end
+
     def test_define_function_closed
       @db.close
       assert_raise(SQLite3::Exception) do

data/test/test_database_readonly.rb

@@ -1,9 +1,9 @@
 require 'helper'
 
 module SQLite3
-  class TestDatabaseReadonly < Test::Unit::TestCase
+  class TestDatabaseReadonly < SQLite3::TestCase
     def setup
-      File.unlink 'test-readonly.db' if File.exists?('test-readonly.db')
+      File.unlink 'test-readonly.db' if File.exist?('test-readonly.db')
       @db = SQLite3::Database.new('test-readonly.db')
       @db.execute("CREATE TABLE foos (id integer)")
       @db.close
@@ -11,7 +11,7 @@ module SQLite3
 
     def teardown
       @db.close unless @db.closed?
-      File.unlink 'test-readonly.db'
+      File.unlink 'test-readonly.db' if File.exist?('test-readonly.db')
     end
 
     def test_open_readonly_database
@@ -19,6 +19,13 @@ module SQLite3
       assert @db.readonly?
     end
 
+    def test_open_readonly_not_exists_database
+      File.unlink 'test-readonly.db'
+      assert_raise(SQLite3::CantOpenException) do
+        @db = SQLite3::Database.new('test-readonly.db', :readonly => true)
+      end
+    end
+
     def test_insert_readonly_database
       @db = SQLite3::Database.new('test-readonly.db', :readonly => true)
       assert_raise(SQLite3::ReadOnlyException) do

data/test/test_deprecated.rb

@@ -1,12 +1,15 @@
 require 'helper'
 
 module SQLite3
-  class TestDeprecated < Test::Unit::TestCase
+  class TestDeprecated < SQLite3::TestCase
+    attr_reader :db
+
     def setup
       super
       @warn_before = $-w
       $-w = false
       @db = SQLite3::Database.new(':memory:')
+      @db.execute 'CREATE TABLE test_table (name text, age int)'
     end
 
     def teardown
@@ -14,6 +17,10 @@ module SQLite3
       $-w = @warn_before
     end
 
+    def test_query_with_many_bind_params_not_nil
+      assert_equal [[1, 2]], db.query('select ?, ?', 1, 2).to_a
+    end
+
     def test_execute_with_many_bind_params_not_nil
       assert_equal [[1, 2]], @db.execute("select ?, ?", 1, 2).to_a
     end

data/test/test_encoding.rb

@@ -3,7 +3,7 @@
 require 'helper'
 
 module SQLite3
-  class TestEncoding < Test::Unit::TestCase
+  class TestEncoding < SQLite3::TestCase
     def setup
       @db = SQLite3::Database.new(':memory:')
       @create = "create table ex(id int, data string)"
@@ -11,6 +11,40 @@ module SQLite3
       @db.execute(@create);
     end
 
+    def test_select_encoding_on_utf_16
+      str = "foo"
+      utf16 = ([1].pack("I") == [1].pack("N")) ? "UTF-16BE" : "UTF-16LE"
+      db = SQLite3::Database.new(':memory:'.encode(utf16))
+      db.execute @create
+      db.execute "insert into ex (id, data) values (1, \"#{str}\")"
+
+      stmt = db.prepare 'select * from ex where data = ?'
+      ['US-ASCII', utf16, 'EUC-JP', 'UTF-8'].each do |enc|
+        stmt.bind_param 1, str.encode(enc)
+        assert_equal 1, stmt.to_a.length
+        stmt.reset!
+      end
+    end
+
+    def test_insert_encoding
+      str = "foo"
+      utf16 = ([1].pack("I") == [1].pack("N")) ? "UTF-16BE" : "UTF-16LE"
+      db = SQLite3::Database.new(':memory:'.encode(utf16))
+      db.execute @create
+      stmt = db.prepare @insert
+
+      ['US-ASCII', utf16, 'EUC-JP', 'UTF-8'].each_with_index do |enc,i|
+        stmt.bind_param 1, i
+        stmt.bind_param 2, str.encode(enc)
+        stmt.to_a
+        stmt.reset!
+      end
+
+      db.execute('select data from ex').flatten.each do |s|
+        assert_equal str, s
+      end
+    end
+
     def test_default_internal_is_honored
       warn_before = $-w
       $-w = false

data/test/test_integration.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-class TC_Database_Integration < Test::Unit::TestCase
+class TC_Database_Integration < SQLite3::TestCase
   def setup
     @db = SQLite3::Database.new(":memory:")
     @db.transaction do
@@ -21,12 +21,14 @@ class TC_Database_Integration < Test::Unit::TestCase
 
   def test_table_info_with_defaults_for_version_3_3_8_and_higher
     @db.transaction do
-      @db.execute "create table defaults_test ( a string default NULL, b string default 'Hello' )"
+      @db.execute "create table defaults_test ( a string default NULL, b string default 'Hello', c string default '--- []\n' )"
       data = @db.table_info( "defaults_test" )
       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},
         data[1])
+      assert_equal({"name" => "c", "type" => "string", "dflt_value" => "--- []\n", "notnull" => 0, "cid" => 2, "pk" => 0},
+        data[2])
     end
   end
 
@@ -236,7 +238,7 @@ class TC_Database_Integration < Test::Unit::TestCase
 
   def test_execute2_with_block_with_bind_with_match
     called = 0
-    @db.execute2( "select * from foo where a = ?", 1 ) do |row|
+    @db.execute2( "select * from foo where a = ?", 1 ) do
       called += 1
     end
     assert_equal 2, called
@@ -497,6 +499,10 @@ class TC_Database_Integration < Test::Unit::TestCase
 
     value = @db.get_first_value( "select accumulate(a) from foo" )
     assert_equal 6, value
+
+    # calling #get_first_value twice don't add up to the latest result
+    value = @db.get_first_value( "select accumulate(a) from foo" )
+    assert_equal 6, value
   end
 
   def test_create_aggregate_with_block
@@ -528,21 +534,36 @@ class TC_Database_Integration < Test::Unit::TestCase
     assert_equal 0, value
   end
 
-  def test_create_aggregate_handler
-    handler = Class.new do
-      class << self
-        def arity; 1; end
-        def text_rep; SQLite3::Constants::TextRep::ANY; end
-        def name; "multiply"; end
-      end
-      def step(ctx, a)
-        ctx[:buffer] ||= 1
-        ctx[:buffer] *= a.to_i
+  class AggregateHandler
+    class << self
+      def arity; 1; end
+      def text_rep; SQLite3::Constants::TextRep::ANY; end
+      def name; "multiply"; end
+    end
+    def step(ctx, a)
+      ctx[:buffer] ||= 1
+      ctx[:buffer] *= a.to_i
+    end
+    def finalize(ctx); ctx.result = ctx[:buffer]; end
+  end
+
+  def test_aggregate_initialized_twice
+    initialized = 0
+    handler = Class.new(AggregateHandler) do
+      define_method(:initialize) do
+        initialized += 1
+        super()
       end
-      def finalize(ctx); ctx.result = ctx[:buffer]; end
     end
 
-    @db.create_aggregate_handler( handler )
+    @db.create_aggregate_handler handler
+    @db.get_first_value( "select multiply(a) from foo" )
+    @db.get_first_value( "select multiply(a) from foo" )
+    assert_equal 2, initialized
+  end
+
+  def test_create_aggregate_handler
+    @db.create_aggregate_handler AggregateHandler
     value = @db.get_first_value( "select multiply(a) from foo" )
     assert_equal 6, value
   end

data/test/test_integration_open_close.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-class TC_OpenClose < Test::Unit::TestCase
+class TC_OpenClose < SQLite3::TestCase
   def test_create_close
     begin
       db = SQLite3::Database.new( "test-create.db" )

data/test/test_integration_pending.rb

@@ -3,7 +3,7 @@ require 'helper'
 require 'thread'
 require 'benchmark'
 
-class TC_Integration_Pending < Test::Unit::TestCase
+class TC_Integration_Pending < SQLite3::TestCase
   def setup
     @db = SQLite3::Database.new("test.db")
     @db.transaction do
@@ -69,7 +69,7 @@ class TC_Integration_Pending < Test::Unit::TestCase
     end
     sleep 1
 
-    @db.busy_handler do |count|
+    @db.busy_handler do
       handler_call_count += 1
       false
     end