ibm_db 4.0.0-x86-mingw32 → 5.0.2-x86-mingw32

data/test/cases/adapters/postgresql/bit_string_test.rb

@@ -1,82 +1,82 @@
-require "cases/helper"
-require 'support/connection_helper'
-require 'support/schema_dumping_helper'
-
-class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
-  include ConnectionHelper
-  include SchemaDumpingHelper
-
-  class PostgresqlBitString < ActiveRecord::Base; end
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table('postgresql_bit_strings', :force => true) do |t|
-      t.bit :a_bit, default: "00000011", limit: 8
-      t.bit_varying :a_bit_varying, default: "0011", limit: 4
-      t.bit :another_bit
-      t.bit_varying :another_bit_varying
-    end
-  end
-
-  def teardown
-    return unless @connection
-    @connection.drop_table 'postgresql_bit_strings', if_exists: true
-  end
-
-  def test_bit_string_column
-    column = PostgresqlBitString.columns_hash["a_bit"]
-    assert_equal :bit, column.type
-    assert_equal "bit(8)", column.sql_type
-    assert_not column.array?
-
-    type = PostgresqlBitString.type_for_attribute("a_bit")
-    assert_not type.binary?
-  end
-
-  def test_bit_string_varying_column
-    column = PostgresqlBitString.columns_hash["a_bit_varying"]
-    assert_equal :bit_varying, column.type
-    assert_equal "bit varying(4)", column.sql_type
-    assert_not column.array?
-
-    type = PostgresqlBitString.type_for_attribute("a_bit_varying")
-    assert_not type.binary?
-  end
-
-  def test_default
-    assert_equal "00000011", PostgresqlBitString.column_defaults['a_bit']
-    assert_equal "00000011", PostgresqlBitString.new.a_bit
-
-    assert_equal "0011", PostgresqlBitString.column_defaults['a_bit_varying']
-    assert_equal "0011", PostgresqlBitString.new.a_bit_varying
-  end
-
-  def test_schema_dumping
-    output = dump_table_schema("postgresql_bit_strings")
-    assert_match %r{t\.bit\s+"a_bit",\s+limit: 8,\s+default: "00000011"$}, output
-    assert_match %r{t\.bit_varying\s+"a_bit_varying",\s+limit: 4,\s+default: "0011"$}, output
-  end
-
-  if ActiveRecord::Base.connection.prepared_statements
-    def test_assigning_invalid_hex_string_raises_exception
-      assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit: "FF" }
-      assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit_varying: "F" }
-    end
-  end
-
-  def test_roundtrip
-    record = PostgresqlBitString.create!(a_bit: "00001010", a_bit_varying: "0101")
-    assert_equal "00001010", record.a_bit
-    assert_equal "0101", record.a_bit_varying
-    assert_nil record.another_bit
-    assert_nil record.another_bit_varying
-
-    record.a_bit = "11111111"
-    record.a_bit_varying = "0xF"
-    record.save!
-
-    assert record.reload
-    assert_equal "11111111", record.a_bit
-    assert_equal "1111", record.a_bit_varying
-  end
-end
+require "cases/helper"
+require 'support/connection_helper'
+require 'support/schema_dumping_helper'
+
+class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
+  include ConnectionHelper
+  include SchemaDumpingHelper
+
+  class PostgresqlBitString < ActiveRecord::Base; end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table('postgresql_bit_strings', :force => true) do |t|
+      t.bit :a_bit, default: "00000011", limit: 8
+      t.bit_varying :a_bit_varying, default: "0011", limit: 4
+      t.bit :another_bit
+      t.bit_varying :another_bit_varying
+    end
+  end
+
+  def teardown
+    return unless @connection
+    @connection.drop_table 'postgresql_bit_strings', if_exists: true
+  end
+
+  def test_bit_string_column
+    column = PostgresqlBitString.columns_hash["a_bit"]
+    assert_equal :bit, column.type
+    assert_equal "bit(8)", column.sql_type
+    assert_not column.array?
+
+    type = PostgresqlBitString.type_for_attribute("a_bit")
+    assert_not type.binary?
+  end
+
+  def test_bit_string_varying_column
+    column = PostgresqlBitString.columns_hash["a_bit_varying"]
+    assert_equal :bit_varying, column.type
+    assert_equal "bit varying(4)", column.sql_type
+    assert_not column.array?
+
+    type = PostgresqlBitString.type_for_attribute("a_bit_varying")
+    assert_not type.binary?
+  end
+
+  def test_default
+    assert_equal "00000011", PostgresqlBitString.column_defaults['a_bit']
+    assert_equal "00000011", PostgresqlBitString.new.a_bit
+
+    assert_equal "0011", PostgresqlBitString.column_defaults['a_bit_varying']
+    assert_equal "0011", PostgresqlBitString.new.a_bit_varying
+  end
+
+  def test_schema_dumping
+    output = dump_table_schema("postgresql_bit_strings")
+    assert_match %r{t\.bit\s+"a_bit",\s+limit: 8,\s+default: "00000011"$}, output
+    assert_match %r{t\.bit_varying\s+"a_bit_varying",\s+limit: 4,\s+default: "0011"$}, output
+  end
+
+  if ActiveRecord::Base.connection.prepared_statements
+    def test_assigning_invalid_hex_string_raises_exception
+      assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit: "FF" }
+      assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit_varying: "F" }
+    end
+  end
+
+  def test_roundtrip
+    record = PostgresqlBitString.create!(a_bit: "00001010", a_bit_varying: "0101")
+    assert_equal "00001010", record.a_bit
+    assert_equal "0101", record.a_bit_varying
+    assert_nil record.another_bit
+    assert_nil record.another_bit_varying
+
+    record.a_bit = "11111111"
+    record.a_bit_varying = "0xF"
+    record.save!
+
+    assert record.reload
+    assert_equal "11111111", record.a_bit
+    assert_equal "1111", record.a_bit_varying
+  end
+end

data/test/cases/adapters/postgresql/bytea_test.rb

@@ -1,134 +1,134 @@
-require "cases/helper"
-require 'support/schema_dumping_helper'
-
-class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
-  include SchemaDumpingHelper
-
-  class ByteaDataType < ActiveRecord::Base
-    self.table_name = 'bytea_data_type'
-  end
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-    begin
-      @connection.transaction do
-        @connection.create_table('bytea_data_type') do |t|
-          t.binary 'payload'
-          t.binary 'serialized'
-        end
-      end
-    end
-    @column = ByteaDataType.columns_hash['payload']
-    @type = ByteaDataType.type_for_attribute("payload")
-  end
-
-  teardown do
-    @connection.drop_table 'bytea_data_type', if_exists: true
-  end
-
-  def test_column
-    assert @column.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn)
-    assert_equal :binary, @column.type
-  end
-
-  def test_binary_columns_are_limitless_the_upper_limit_is_one_GB
-    assert_equal 'bytea', @connection.type_to_sql(:binary, 100_000)
-    assert_raise ActiveRecord::ActiveRecordError do
-      @connection.type_to_sql :binary, 4294967295
-    end
-  end
-
-  def test_type_cast_binary_converts_the_encoding
-    assert @column
-
-    data = "\u001F\x8B"
-    assert_equal('UTF-8', data.encoding.name)
-    assert_equal('ASCII-8BIT', @type.deserialize(data).encoding.name)
-  end
-
-  def test_type_cast_binary_value
-    data = "\u001F\x8B".force_encoding("BINARY")
-    assert_equal(data, @type.deserialize(data))
-  end
-
-  def test_type_case_nil
-    assert_equal(nil, @type.deserialize(nil))
-  end
-
-  def test_read_value
-    data = "\u001F"
-    @connection.execute "insert into bytea_data_type (payload) VALUES ('#{data}')"
-    record = ByteaDataType.first
-    assert_equal(data, record.payload)
-    record.delete
-  end
-
-  def test_read_nil_value
-    @connection.execute "insert into bytea_data_type (payload) VALUES (null)"
-    record = ByteaDataType.first
-    assert_equal(nil, record.payload)
-    record.delete
-  end
-
-  def test_write_value
-    data = "\u001F"
-    record = ByteaDataType.create(payload: data)
-    assert_not record.new_record?
-    assert_equal(data, record.payload)
-  end
-
-  def test_via_to_sql
-    data = "'\u001F\\"
-    ByteaDataType.create(payload: data)
-    sql = ByteaDataType.where(payload: data).select(:payload).to_sql
-    result = @connection.query(sql)
-    assert_equal([[data]], result)
-  end
-
-  def test_via_to_sql_with_complicating_connection
-    Thread.new do
-      other_conn = ActiveRecord::Base.connection
-      other_conn.execute('SET standard_conforming_strings = off')
-    end.join
-
-    test_via_to_sql
-  end
-
-  def test_write_binary
-    data = File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'assets', 'example.log'))
-    assert(data.size > 1)
-    record = ByteaDataType.create(payload: data)
-    assert_not record.new_record?
-    assert_equal(data, record.payload)
-    assert_equal(data, ByteaDataType.where(id: record.id).first.payload)
-  end
-
-  def test_write_nil
-    record = ByteaDataType.create(payload: nil)
-    assert_not record.new_record?
-    assert_equal(nil, record.payload)
-    assert_equal(nil, ByteaDataType.where(id: record.id).first.payload)
-  end
-
-  class Serializer
-    def load(str); str; end
-    def dump(str); str; end
-  end
-
-  def test_serialize
-    klass = Class.new(ByteaDataType) {
-      serialize :serialized, Serializer.new
-    }
-    obj = klass.new
-    obj.serialized = "hello world"
-    obj.save!
-    obj.reload
-    assert_equal "hello world", obj.serialized
-  end
-
-  def test_schema_dumping
-    output = dump_table_schema("bytea_data_type")
-    assert_match %r{t\.binary\s+"payload"$}, output
-    assert_match %r{t\.binary\s+"serialized"$}, output
-  end
-end
+require "cases/helper"
+require 'support/schema_dumping_helper'
+
+class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  class ByteaDataType < ActiveRecord::Base
+    self.table_name = 'bytea_data_type'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    begin
+      @connection.transaction do
+        @connection.create_table('bytea_data_type') do |t|
+          t.binary 'payload'
+          t.binary 'serialized'
+        end
+      end
+    end
+    @column = ByteaDataType.columns_hash['payload']
+    @type = ByteaDataType.type_for_attribute("payload")
+  end
+
+  teardown do
+    @connection.drop_table 'bytea_data_type', if_exists: true
+  end
+
+  def test_column
+    assert @column.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn)
+    assert_equal :binary, @column.type
+  end
+
+  def test_binary_columns_are_limitless_the_upper_limit_is_one_GB
+    assert_equal 'bytea', @connection.type_to_sql(:binary, 100_000)
+    assert_raise ActiveRecord::ActiveRecordError do
+      @connection.type_to_sql :binary, 4294967295
+    end
+  end
+
+  def test_type_cast_binary_converts_the_encoding
+    assert @column
+
+    data = "\u001F\x8B"
+    assert_equal('UTF-8', data.encoding.name)
+    assert_equal('ASCII-8BIT', @type.deserialize(data).encoding.name)
+  end
+
+  def test_type_cast_binary_value
+    data = "\u001F\x8B".force_encoding("BINARY")
+    assert_equal(data, @type.deserialize(data))
+  end
+
+  def test_type_case_nil
+    assert_equal(nil, @type.deserialize(nil))
+  end
+
+  def test_read_value
+    data = "\u001F"
+    @connection.execute "insert into bytea_data_type (payload) VALUES ('#{data}')"
+    record = ByteaDataType.first
+    assert_equal(data, record.payload)
+    record.delete
+  end
+
+  def test_read_nil_value
+    @connection.execute "insert into bytea_data_type (payload) VALUES (null)"
+    record = ByteaDataType.first
+    assert_equal(nil, record.payload)
+    record.delete
+  end
+
+  def test_write_value
+    data = "\u001F"
+    record = ByteaDataType.create(payload: data)
+    assert_not record.new_record?
+    assert_equal(data, record.payload)
+  end
+
+  def test_via_to_sql
+    data = "'\u001F\\"
+    ByteaDataType.create(payload: data)
+    sql = ByteaDataType.where(payload: data).select(:payload).to_sql
+    result = @connection.query(sql)
+    assert_equal([[data]], result)
+  end
+
+  def test_via_to_sql_with_complicating_connection
+    Thread.new do
+      other_conn = ActiveRecord::Base.connection
+      other_conn.execute('SET standard_conforming_strings = off')
+    end.join
+
+    test_via_to_sql
+  end
+
+  def test_write_binary
+    data = File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'assets', 'example.log'))
+    assert(data.size > 1)
+    record = ByteaDataType.create(payload: data)
+    assert_not record.new_record?
+    assert_equal(data, record.payload)
+    assert_equal(data, ByteaDataType.where(id: record.id).first.payload)
+  end
+
+  def test_write_nil
+    record = ByteaDataType.create(payload: nil)
+    assert_not record.new_record?
+    assert_equal(nil, record.payload)
+    assert_equal(nil, ByteaDataType.where(id: record.id).first.payload)
+  end
+
+  class Serializer
+    def load(str); str; end
+    def dump(str); str; end
+  end
+
+  def test_serialize
+    klass = Class.new(ByteaDataType) {
+      serialize :serialized, Serializer.new
+    }
+    obj = klass.new
+    obj.serialized = "hello world"
+    obj.save!
+    obj.reload
+    assert_equal "hello world", obj.serialized
+  end
+
+  def test_schema_dumping
+    output = dump_table_schema("bytea_data_type")
+    assert_match %r{t\.binary\s+"payload"$}, output
+    assert_match %r{t\.binary\s+"serialized"$}, output
+  end
+end

data/test/cases/adapters/postgresql/case_insensitive_test.rb

@@ -1,26 +1,26 @@
-require "cases/helper"
-
-class PostgresqlCaseInsensitiveTest < ActiveRecord::PostgreSQLTestCase
-  class Default < ActiveRecord::Base; end
-
-  def test_case_insensitiveness
-    connection = ActiveRecord::Base.connection
-    table = Default.arel_table
-
-    column = Default.columns_hash["char1"]
-    comparison = connection.case_insensitive_comparison table, :char1, column, nil
-    assert_match(/lower/i, comparison.to_sql)
-
-    column = Default.columns_hash["char2"]
-    comparison = connection.case_insensitive_comparison table, :char2, column, nil
-    assert_match(/lower/i, comparison.to_sql)
-
-    column = Default.columns_hash["char3"]
-    comparison = connection.case_insensitive_comparison table, :char3, column, nil
-    assert_match(/lower/i, comparison.to_sql)
-
-    column = Default.columns_hash["multiline_default"]
-    comparison = connection.case_insensitive_comparison table, :multiline_default, column, nil
-    assert_match(/lower/i, comparison.to_sql)
-  end
-end
+require "cases/helper"
+
+class PostgresqlCaseInsensitiveTest < ActiveRecord::PostgreSQLTestCase
+  class Default < ActiveRecord::Base; end
+
+  def test_case_insensitiveness
+    connection = ActiveRecord::Base.connection
+    table = Default.arel_table
+
+    column = Default.columns_hash["char1"]
+    comparison = connection.case_insensitive_comparison table, :char1, column, nil
+    assert_match(/lower/i, comparison.to_sql)
+
+    column = Default.columns_hash["char2"]
+    comparison = connection.case_insensitive_comparison table, :char2, column, nil
+    assert_match(/lower/i, comparison.to_sql)
+
+    column = Default.columns_hash["char3"]
+    comparison = connection.case_insensitive_comparison table, :char3, column, nil
+    assert_match(/lower/i, comparison.to_sql)
+
+    column = Default.columns_hash["multiline_default"]
+    comparison = connection.case_insensitive_comparison table, :multiline_default, column, nil
+    assert_match(/lower/i, comparison.to_sql)
+  end
+end