sqlite3 1.7.3-x86_64-darwin → 2.0.0-x86_64-darwin

data/test/test_database_flags.rb

@@ -1,95 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestDatabaseFlags < SQLite3::TestCase
-    def setup
-      File.unlink 'test-flags.db' if File.exist?('test-flags.db')
-      @db = SQLite3::Database.new('test-flags.db')
-      @db.execute("CREATE TABLE foos (id integer)")
-      @db.close
-    end
-
-    def teardown
-      @db.close unless @db.closed?
-      File.unlink 'test-flags.db' if File.exist?('test-flags.db')
-    end
-
-    def test_open_database_flags_constants
-      defined_to_date = [:READONLY, :READWRITE, :CREATE, :DELETEONCLOSE,
-                         :EXCLUSIVE, :MAIN_DB, :TEMP_DB, :TRANSIENT_DB,
-                         :MAIN_JOURNAL, :TEMP_JOURNAL, :SUBJOURNAL,
-                         :MASTER_JOURNAL, :NOMUTEX, :FULLMUTEX]
-      if SQLite3::SQLITE_VERSION_NUMBER > 3007002
-        defined_to_date += [:AUTOPROXY, :SHAREDCACHE, :PRIVATECACHE, :WAL]
-      end
-      if SQLite3::SQLITE_VERSION_NUMBER > 3007007
-        defined_to_date += [:URI]
-      end
-      if SQLite3::SQLITE_VERSION_NUMBER > 3007013
-        defined_to_date += [:MEMORY]
-      end
-      assert defined_to_date.sort == SQLite3::Constants::Open.constants.sort
-    end
-
-    def test_open_database_flags_conflicts_with_readonly
-      assert_raise(RuntimeError) do
-        @db = SQLite3::Database.new('test-flags.db', :flags => 2, :readonly => true)
-      end
-    end
-
-    def test_open_database_flags_conflicts_with_readwrite
-      assert_raise(RuntimeError) do
-        @db = SQLite3::Database.new('test-flags.db', :flags => 2, :readwrite => true)
-      end
-    end
-
-    def test_open_database_readonly_flags
-      @db = SQLite3::Database.new('test-flags.db', :flags => SQLite3::Constants::Open::READONLY)
-      assert @db.readonly?
-    end
-
-    def test_open_database_readwrite_flags
-      @db = SQLite3::Database.new('test-flags.db', :flags => SQLite3::Constants::Open::READWRITE)
-      assert !@db.readonly?
-    end
-
-    def test_open_database_readonly_flags_cant_open
-      File.unlink 'test-flags.db'
-      assert_raise(SQLite3::CantOpenException) do
-        @db = SQLite3::Database.new('test-flags.db', :flags => SQLite3::Constants::Open::READONLY)
-      end
-    end
-
-    def test_open_database_readwrite_flags_cant_open
-      File.unlink 'test-flags.db'
-      assert_raise(SQLite3::CantOpenException) do
-        @db = SQLite3::Database.new('test-flags.db', :flags => SQLite3::Constants::Open::READWRITE)
-      end
-    end
-
-    def test_open_database_misuse_flags
-      assert_raise(SQLite3::MisuseException) do
-        flags = SQLite3::Constants::Open::READONLY | SQLite3::Constants::Open::READWRITE # <== incompatible flags
-        @db = SQLite3::Database.new('test-flags.db', :flags => flags)
-      end
-    end
-
-    def test_open_database_create_flags
-      File.unlink 'test-flags.db'
-      flags = SQLite3::Constants::Open::READWRITE | SQLite3::Constants::Open::CREATE
-      @db = SQLite3::Database.new('test-flags.db', :flags => flags) do |db|
-        db.execute("CREATE TABLE foos (id integer)")
-        db.execute("INSERT INTO foos (id) VALUES (12)")
-      end
-      assert File.exist?('test-flags.db')
-    end
-
-    def test_open_database_exotic_flags
-      flags = SQLite3::Constants::Open::READWRITE | SQLite3::Constants::Open::CREATE
-      exotic_flags = SQLite3::Constants::Open::NOMUTEX | SQLite3::Constants::Open::TEMP_DB
-      @db = SQLite3::Database.new('test-flags.db', :flags => flags | exotic_flags)
-      @db.execute("INSERT INTO foos (id) VALUES (12)")
-      assert @db.changes == 1
-    end
-  end
-end

data/test/test_database_readonly.rb

@@ -1,36 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestDatabaseReadonly < SQLite3::TestCase
-    def setup
-      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
-    end
-
-    def teardown
-      @db.close unless @db.closed?
-      File.unlink 'test-readonly.db' if File.exist?('test-readonly.db')
-    end
-
-    def test_open_readonly_database
-      @db = SQLite3::Database.new('test-readonly.db', :readonly => true)
-      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
-        @db.execute("INSERT INTO foos (id) VALUES (12)")
-      end
-    end
-  end
-end

data/test/test_database_readwrite.rb

@@ -1,41 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestDatabaseReadwrite < SQLite3::TestCase
-    def setup
-      File.unlink 'test-readwrite.db' if File.exist?('test-readwrite.db')
-      @db = SQLite3::Database.new('test-readwrite.db')
-      @db.execute("CREATE TABLE foos (id integer)")
-      @db.close
-    end
-
-    def teardown
-      @db.close unless @db.closed?
-      File.unlink 'test-readwrite.db' if File.exist?('test-readwrite.db')
-    end
-
-    def test_open_readwrite_database
-      @db = SQLite3::Database.new('test-readwrite.db', :readwrite => true)
-      assert !@db.readonly?
-    end
-
-    def test_open_readwrite_readonly_database
-      assert_raise(RuntimeError) do
-        @db = SQLite3::Database.new('test-readwrite.db', :readwrite => true, :readonly => true)
-      end
-    end
-
-    def test_open_readwrite_not_exists_database
-      File.unlink 'test-readwrite.db'
-      assert_raise(SQLite3::CantOpenException) do
-        @db = SQLite3::Database.new('test-readwrite.db', :readonly => true)
-      end
-    end
-
-    def test_insert_readwrite_database
-      @db = SQLite3::Database.new('test-readwrite.db', :readwrite => true)
-      @db.execute("INSERT INTO foos (id) VALUES (12)")
-      assert @db.changes == 1
-    end
-  end
-end

data/test/test_deprecated.rb

@@ -1,49 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestDeprecated < SQLite3::TestCase
-    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
-      super
-      $-w = @warn_before
-      @db.close
-    end
-
-    def test_query_with_many_bind_params_not_nil
-      rs = @db.query('select ?, ?', 1, 2)
-      assert_equal [[1, 2]], rs.to_a
-      rs.close
-    end
-
-    def test_execute_with_many_bind_params_not_nil
-      assert_equal [[1, 2]], @db.execute("select ?, ?", 1, 2).to_a
-    end
-
-    def test_query_with_many_bind_params
-      rs = @db.query("select ?, ?", nil, 1)
-      assert_equal [[nil, 1]], rs.to_a
-      rs.close
-    end
-
-    def test_query_with_nil_bind_params
-      rs = @db.query("select 'foo'", nil)
-      assert_equal [['foo']], rs.to_a
-      rs.close
-    end
-
-    def test_execute_with_many_bind_params
-      assert_equal [[nil, 1]], @db.execute("select ?, ?", nil, 1)
-    end
-
-    def test_execute_with_nil_bind_params
-      assert_equal [['foo']], @db.execute("select 'foo'", nil)
-    end
-  end
-end

data/test/test_encoding.rb

@@ -1,165 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'helper'
-
-module SQLite3
-  class TestEncoding < SQLite3::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 teardown
-      @db.close
-    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
-      stmt.close
-    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
-      stmt.close
-
-      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
-
-      before_enc = Encoding.default_internal
-
-      str = "壁に耳あり、障子に目あり"
-      stmt = @db.prepare('insert into ex(data) values (?)')
-      stmt.bind_param 1, str
-      stmt.step
-      stmt.close
-
-      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
-      $-w = warn_before
-    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
-      stmt.close
-
-      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
-      stmt.close
-
-      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
-      stmt.close
-
-      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
-      utf16 = ([1].pack("I") == [1].pack("N")) ? "UTF-16BE" : "UTF-16LE"
-
-      db = SQLite3::Database.new(':memory:'.encode(utf16))
-      assert_equal(Encoding.find(utf16), 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