ibm_db 3.0.4-x86-mingw32 → 3.0.5-x86-mingw32

data/test/cases/type/decimal_test.rb

@@ -1,51 +1,56 @@
-require "cases/helper"
-
-module ActiveRecord
-  module Type
-    class DecimalTest < ActiveRecord::TestCase
-      def test_type_cast_decimal
-        type = Decimal.new
-        assert_equal BigDecimal.new("0"), type.type_cast_from_user(BigDecimal.new("0"))
-        assert_equal BigDecimal.new("123"), type.type_cast_from_user(123.0)
-        assert_equal BigDecimal.new("1"), type.type_cast_from_user(:"1")
-      end
-
-      def test_type_cast_decimal_from_float_with_large_precision
-        type = Decimal.new(precision: ::Float::DIG + 2)
-        assert_equal BigDecimal.new("123.0"), type.type_cast_from_user(123.0)
-      end
-
-      def test_type_cast_from_float_with_unspecified_precision
-        type = Decimal.new
-        assert_equal 22.68.to_d, type.type_cast_from_user(22.68)
-      end
-
-      def test_type_cast_decimal_from_rational_with_precision
-        type = Decimal.new(precision: 2)
-        assert_equal BigDecimal("0.33"), type.type_cast_from_user(Rational(1, 3))
-      end
-
-      def test_type_cast_decimal_from_rational_without_precision_defaults_to_18_36
-        type = Decimal.new
-        assert_equal BigDecimal("0.333333333333333333E0"), type.type_cast_from_user(Rational(1, 3))
-      end
-
-      def test_type_cast_decimal_from_object_responding_to_d
-        value = Object.new
-        def value.to_d
-          BigDecimal.new("1")
-        end
-        type = Decimal.new
-        assert_equal BigDecimal("1"), type.type_cast_from_user(value)
-      end
-
-      def test_changed?
-        type = Decimal.new
-
-        assert type.changed?(5.0, 5.0, '5.0wibble')
-        assert_not type.changed?(5.0, 5.0, '5.0')
-        assert_not type.changed?(-5.0, -5.0, '-5.0')
-      end
-    end
-  end
-end
+require "cases/helper"
+
+module ActiveRecord
+  module Type
+    class DecimalTest < ActiveRecord::TestCase
+      def test_type_cast_decimal
+        type = Decimal.new
+        assert_equal BigDecimal.new("0"), type.type_cast_from_user(BigDecimal.new("0"))
+        assert_equal BigDecimal.new("123"), type.type_cast_from_user(123.0)
+        assert_equal BigDecimal.new("1"), type.type_cast_from_user(:"1")
+      end
+
+      def test_type_cast_decimal_from_float_with_large_precision
+        type = Decimal.new(precision: ::Float::DIG + 2)
+        assert_equal BigDecimal.new("123.0"), type.type_cast_from_user(123.0)
+      end
+
+      def test_type_cast_from_float_with_unspecified_precision
+        type = Decimal.new
+        assert_equal 22.68.to_d, type.type_cast_from_user(22.68)
+      end
+
+      def test_type_cast_decimal_from_rational_with_precision
+        type = Decimal.new(precision: 2)
+        assert_equal BigDecimal("0.33"), type.type_cast_from_user(Rational(1, 3))
+      end
+
+      def test_type_cast_decimal_from_rational_with_precision_and_scale
+        type = Decimal.new(precision: 4, scale: 2)
+        assert_equal BigDecimal("0.33"), type.type_cast_from_user(Rational(1, 3))
+      end
+
+      def test_type_cast_decimal_from_rational_without_precision_defaults_to_18_36
+        type = Decimal.new
+        assert_equal BigDecimal("0.333333333333333333E0"), type.type_cast_from_user(Rational(1, 3))
+      end
+
+      def test_type_cast_decimal_from_object_responding_to_d
+        value = Object.new
+        def value.to_d
+          BigDecimal.new("1")
+        end
+        type = Decimal.new
+        assert_equal BigDecimal("1"), type.type_cast_from_user(value)
+      end
+
+      def test_changed?
+        type = Decimal.new
+
+        assert type.changed?(5.0, 5.0, '5.0wibble')
+        assert_not type.changed?(5.0, 5.0, '5.0')
+        assert_not type.changed?(-5.0, -5.0, '-5.0')
+      end
+    end
+  end
+end

data/test/cases/type/integer_test.rb

@@ -1,121 +1,121 @@
-require "cases/helper"
-require "models/company"
-
-module ActiveRecord
-  module Type
-    class IntegerTest < ActiveRecord::TestCase
-      test "simple values" do
-        type = Type::Integer.new
-        assert_equal 1, type.type_cast_from_user(1)
-        assert_equal 1, type.type_cast_from_user('1')
-        assert_equal 1, type.type_cast_from_user('1ignore')
-        assert_equal 0, type.type_cast_from_user('bad1')
-        assert_equal 0, type.type_cast_from_user('bad')
-        assert_equal 1, type.type_cast_from_user(1.7)
-        assert_equal 0, type.type_cast_from_user(false)
-        assert_equal 1, type.type_cast_from_user(true)
-        assert_nil type.type_cast_from_user(nil)
-      end
-
-      test "random objects cast to nil" do
-        type = Type::Integer.new
-        assert_nil type.type_cast_from_user([1,2])
-        assert_nil type.type_cast_from_user({1 => 2})
-        assert_nil type.type_cast_from_user((1..2))
-      end
-
-      test "casting ActiveRecord models" do
-        type = Type::Integer.new
-        firm = Firm.create(:name => 'Apple')
-        assert_nil type.type_cast_from_user(firm)
-      end
-
-      test "casting objects without to_i" do
-        type = Type::Integer.new
-        assert_nil type.type_cast_from_user(::Object.new)
-      end
-
-      test "casting nan and infinity" do
-        type = Type::Integer.new
-        assert_nil type.type_cast_from_user(::Float::NAN)
-        assert_nil type.type_cast_from_user(1.0/0.0)
-      end
-
-      test "changed?" do
-        type = Type::Integer.new
-
-        assert type.changed?(5, 5, '5wibble')
-        assert_not type.changed?(5, 5, '5')
-        assert_not type.changed?(5, 5, '5.0')
-        assert_not type.changed?(-5, -5, '-5')
-        assert_not type.changed?(-5, -5, '-5.0')
-        assert_not type.changed?(nil, nil, nil)
-      end
-
-      test "values below int min value are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(-2147483649)
-        end
-      end
-
-      test "values above int max value are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(2147483648)
-        end
-      end
-
-      test "very small numbers are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(-9999999999999999999999999999999)
-        end
-      end
-
-      test "very large numbers are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(9999999999999999999999999999999)
-        end
-      end
-
-      test "normal numbers are in range" do
-        type = Integer.new
-        assert_equal(0, type.type_cast_for_database(0))
-        assert_equal(-1, type.type_cast_for_database(-1))
-        assert_equal(1, type.type_cast_for_database(1))
-      end
-
-      test "int max value is in range" do
-        assert_equal(2147483647, Integer.new.type_cast_for_database(2147483647))
-      end
-
-      test "int min value is in range" do
-        assert_equal(-2147483648, Integer.new.type_cast_for_database(-2147483648))
-      end
-
-      test "columns with a larger limit have larger ranges" do
-        type = Integer.new(limit: 8)
-
-        assert_equal(9223372036854775807, type.type_cast_for_database(9223372036854775807))
-        assert_equal(-9223372036854775808, type.type_cast_for_database(-9223372036854775808))
-        assert_raises(::RangeError) do
-          type.type_cast_for_database(-9999999999999999999999999999999)
-        end
-        assert_raises(::RangeError) do
-          type.type_cast_for_database(9999999999999999999999999999999)
-        end
-      end
-
-      test "values which are out of range can be re-assigned" do
-        klass = Class.new(ActiveRecord::Base) do
-          self.table_name = 'posts'
-          attribute :foo, Type::Integer.new
-        end
-        model = klass.new
-
-        model.foo = 2147483648
-        model.foo = 1
-
-        assert_equal 1, model.foo
-      end
-    end
-  end
-end
+require "cases/helper"
+require "models/company"
+
+module ActiveRecord
+  module Type
+    class IntegerTest < ActiveRecord::TestCase
+      test "simple values" do
+        type = Type::Integer.new
+        assert_equal 1, type.type_cast_from_user(1)
+        assert_equal 1, type.type_cast_from_user('1')
+        assert_equal 1, type.type_cast_from_user('1ignore')
+        assert_equal 0, type.type_cast_from_user('bad1')
+        assert_equal 0, type.type_cast_from_user('bad')
+        assert_equal 1, type.type_cast_from_user(1.7)
+        assert_equal 0, type.type_cast_from_user(false)
+        assert_equal 1, type.type_cast_from_user(true)
+        assert_nil type.type_cast_from_user(nil)
+      end
+
+      test "random objects cast to nil" do
+        type = Type::Integer.new
+        assert_nil type.type_cast_from_user([1,2])
+        assert_nil type.type_cast_from_user({1 => 2})
+        assert_nil type.type_cast_from_user((1..2))
+      end
+
+      test "casting ActiveRecord models" do
+        type = Type::Integer.new
+        firm = Firm.create(:name => 'Apple')
+        assert_nil type.type_cast_from_user(firm)
+      end
+
+      test "casting objects without to_i" do
+        type = Type::Integer.new
+        assert_nil type.type_cast_from_user(::Object.new)
+      end
+
+      test "casting nan and infinity" do
+        type = Type::Integer.new
+        assert_nil type.type_cast_from_user(::Float::NAN)
+        assert_nil type.type_cast_from_user(1.0/0.0)
+      end
+
+      test "changed?" do
+        type = Type::Integer.new
+
+        assert type.changed?(5, 5, '5wibble')
+        assert_not type.changed?(5, 5, '5')
+        assert_not type.changed?(5, 5, '5.0')
+        assert_not type.changed?(-5, -5, '-5')
+        assert_not type.changed?(-5, -5, '-5.0')
+        assert_not type.changed?(nil, nil, nil)
+      end
+
+      test "values below int min value are out of range" do
+        assert_raises(::RangeError) do
+          Integer.new.type_cast_for_database(-2147483649)
+        end
+      end
+
+      test "values above int max value are out of range" do
+        assert_raises(::RangeError) do
+          Integer.new.type_cast_for_database(2147483648)
+        end
+      end
+
+      test "very small numbers are out of range" do
+        assert_raises(::RangeError) do
+          Integer.new.type_cast_for_database(-9999999999999999999999999999999)
+        end
+      end
+
+      test "very large numbers are out of range" do
+        assert_raises(::RangeError) do
+          Integer.new.type_cast_for_database(9999999999999999999999999999999)
+        end
+      end
+
+      test "normal numbers are in range" do
+        type = Integer.new
+        assert_equal(0, type.type_cast_for_database(0))
+        assert_equal(-1, type.type_cast_for_database(-1))
+        assert_equal(1, type.type_cast_for_database(1))
+      end
+
+      test "int max value is in range" do
+        assert_equal(2147483647, Integer.new.type_cast_for_database(2147483647))
+      end
+
+      test "int min value is in range" do
+        assert_equal(-2147483648, Integer.new.type_cast_for_database(-2147483648))
+      end
+
+      test "columns with a larger limit have larger ranges" do
+        type = Integer.new(limit: 8)
+
+        assert_equal(9223372036854775807, type.type_cast_for_database(9223372036854775807))
+        assert_equal(-9223372036854775808, type.type_cast_for_database(-9223372036854775808))
+        assert_raises(::RangeError) do
+          type.type_cast_for_database(-9999999999999999999999999999999)
+        end
+        assert_raises(::RangeError) do
+          type.type_cast_for_database(9999999999999999999999999999999)
+        end
+      end
+
+      test "values which are out of range can be re-assigned" do
+        klass = Class.new(ActiveRecord::Base) do
+          self.table_name = 'posts'
+          attribute :foo, Type::Integer.new
+        end
+        model = klass.new
+
+        model.foo = 2147483648
+        model.foo = 1
+
+        assert_equal 1, model.foo
+      end
+    end
+  end
+end

data/test/cases/type/string_test.rb

@@ -1,36 +1,36 @@
-require 'cases/helper'
-
-module ActiveRecord
-  class StringTypeTest < ActiveRecord::TestCase
-    test "type casting" do
-      type = Type::String.new
-      assert_equal "t", type.type_cast_from_user(true)
-      assert_equal "f", type.type_cast_from_user(false)
-      assert_equal "123", type.type_cast_from_user(123)
-    end
-
-    test "values are duped coming out" do
-      s = "foo"
-      type = Type::String.new
-      assert_not_same s, type.type_cast_from_user(s)
-      assert_not_same s, type.type_cast_from_database(s)
-    end
-
-    test "string mutations are detected" do
-      klass = Class.new(Base)
-      klass.table_name = 'authors'
-
-      author = klass.create!(name: 'Sean')
-      assert_not author.changed?
-
-      author.name << ' Griffin'
-      assert author.name_changed?
-
-      author.save!
-      author.reload
-
-      assert_equal 'Sean Griffin', author.name
-      assert_not author.changed?
-    end
-  end
-end
+require 'cases/helper'
+
+module ActiveRecord
+  class StringTypeTest < ActiveRecord::TestCase
+    test "type casting" do
+      type = Type::String.new
+      assert_equal "t", type.type_cast_from_user(true)
+      assert_equal "f", type.type_cast_from_user(false)
+      assert_equal "123", type.type_cast_from_user(123)
+    end
+
+    test "values are duped coming out" do
+      s = "foo"
+      type = Type::String.new
+      assert_not_same s, type.type_cast_from_user(s)
+      assert_not_same s, type.type_cast_from_database(s)
+    end
+
+    test "string mutations are detected" do
+      klass = Class.new(Base)
+      klass.table_name = 'authors'
+
+      author = klass.create!(name: 'Sean')
+      assert_not author.changed?
+
+      author.name << ' Griffin'
+      assert author.name_changed?
+
+      author.save!
+      author.reload
+
+      assert_equal 'Sean Griffin', author.name
+      assert_not author.changed?
+    end
+  end
+end

data/test/cases/type/type_map_test.rb

@@ -1,177 +1,177 @@
-require "cases/helper"
-
-module ActiveRecord
-  module Type
-    class TypeMapTest < ActiveRecord::TestCase
-      def test_default_type
-        mapping = TypeMap.new
-
-        assert_kind_of Value, mapping.lookup(:undefined)
-      end
-
-      def test_registering_types
-        boolean = Boolean.new
-        mapping = TypeMap.new
-
-        mapping.register_type(/boolean/i, boolean)
-
-        assert_equal mapping.lookup('boolean'), boolean
-      end
-
-      def test_overriding_registered_types
-        time = Time.new
-        timestamp = DateTime.new
-        mapping = TypeMap.new
-
-        mapping.register_type(/time/i, time)
-        mapping.register_type(/time/i, timestamp)
-
-        assert_equal mapping.lookup('time'), timestamp
-      end
-
-      def test_fuzzy_lookup
-        string = String.new
-        mapping = TypeMap.new
-
-        mapping.register_type(/varchar/i, string)
-
-        assert_equal mapping.lookup('varchar(20)'), string
-      end
-
-      def test_aliasing_types
-        string = String.new
-        mapping = TypeMap.new
-
-        mapping.register_type(/string/i, string)
-        mapping.alias_type(/varchar/i, 'string')
-
-        assert_equal mapping.lookup('varchar'), string
-      end
-
-      def test_changing_type_changes_aliases
-        time = Time.new
-        timestamp = DateTime.new
-        mapping = TypeMap.new
-
-        mapping.register_type(/timestamp/i, time)
-        mapping.alias_type(/datetime/i, 'timestamp')
-        mapping.register_type(/timestamp/i, timestamp)
-
-        assert_equal mapping.lookup('datetime'), timestamp
-      end
-
-      def test_aliases_keep_metadata
-        mapping = TypeMap.new
-
-        mapping.register_type(/decimal/i) { |sql_type| sql_type }
-        mapping.alias_type(/number/i, 'decimal')
-
-        assert_equal mapping.lookup('number(20)'), 'decimal(20)'
-        assert_equal mapping.lookup('number'), 'decimal'
-      end
-
-      def test_register_proc
-        string = String.new
-        binary = Binary.new
-        mapping = TypeMap.new
-
-        mapping.register_type(/varchar/i) do |type|
-          if type.include?('(')
-            string
-          else
-            binary
-          end
-        end
-
-        assert_equal mapping.lookup('varchar(20)'), string
-        assert_equal mapping.lookup('varchar'), binary
-      end
-
-      def test_additional_lookup_args
-        mapping = TypeMap.new
-
-        mapping.register_type(/varchar/i) do |type, limit|
-          if limit > 255
-            'text'
-          else
-            'string'
-          end
-        end
-        mapping.alias_type(/string/i, 'varchar')
-
-        assert_equal mapping.lookup('varchar', 200), 'string'
-        assert_equal mapping.lookup('varchar', 400), 'text'
-        assert_equal mapping.lookup('string', 400), 'text'
-      end
-
-      def test_requires_value_or_block
-        mapping = TypeMap.new
-
-        assert_raises(ArgumentError) do
-          mapping.register_type(/only key/i)
-        end
-      end
-
-      def test_lookup_non_strings
-        mapping = HashLookupTypeMap.new
-
-        mapping.register_type(1, 'string')
-        mapping.register_type(2, 'int')
-        mapping.alias_type(3, 1)
-
-        assert_equal mapping.lookup(1), 'string'
-        assert_equal mapping.lookup(2), 'int'
-        assert_equal mapping.lookup(3), 'string'
-        assert_kind_of Type::Value, mapping.lookup(4)
-      end
-
-      def test_fetch
-        mapping = TypeMap.new
-        mapping.register_type(1, "string")
-
-        assert_equal "string", mapping.fetch(1) { "int" }
-        assert_equal "int", mapping.fetch(2) { "int" }
-      end
-
-      def test_fetch_yields_args
-        mapping = TypeMap.new
-
-        assert_equal "foo-1-2-3", mapping.fetch("foo", 1, 2, 3) { |*args| args.join("-") }
-        assert_equal "bar-1-2-3", mapping.fetch("bar", 1, 2, 3) { |*args| args.join("-") }
-      end
-
-      def test_fetch_memoizes
-        mapping = TypeMap.new
-
-        looked_up = false
-        mapping.register_type(1) do
-          fail if looked_up
-          looked_up = true
-          "string"
-        end
-
-        assert_equal "string", mapping.fetch(1)
-        assert_equal "string", mapping.fetch(1)
-      end
-
-      def test_fetch_memoizes_on_args
-        mapping = TypeMap.new
-        mapping.register_type("foo") { |*args| args.join("-") }
-
-        assert_equal "foo-1-2-3", mapping.fetch("foo", 1, 2, 3) { |*args| args.join("-") }
-        assert_equal "foo-2-3-4", mapping.fetch("foo", 2, 3, 4) { |*args| args.join("-") }
-      end
-
-      def test_register_clears_cache
-        mapping = TypeMap.new
-
-        mapping.register_type(1, "string")
-        mapping.lookup(1)
-        mapping.register_type(1, "int")
-
-        assert_equal "int", mapping.lookup(1)
-      end
-    end
-  end
-end
-
+require "cases/helper"
+
+module ActiveRecord
+  module Type
+    class TypeMapTest < ActiveRecord::TestCase
+      def test_default_type
+        mapping = TypeMap.new
+
+        assert_kind_of Value, mapping.lookup(:undefined)
+      end
+
+      def test_registering_types
+        boolean = Boolean.new
+        mapping = TypeMap.new
+
+        mapping.register_type(/boolean/i, boolean)
+
+        assert_equal mapping.lookup('boolean'), boolean
+      end
+
+      def test_overriding_registered_types
+        time = Time.new
+        timestamp = DateTime.new
+        mapping = TypeMap.new
+
+        mapping.register_type(/time/i, time)
+        mapping.register_type(/time/i, timestamp)
+
+        assert_equal mapping.lookup('time'), timestamp
+      end
+
+      def test_fuzzy_lookup
+        string = String.new
+        mapping = TypeMap.new
+
+        mapping.register_type(/varchar/i, string)
+
+        assert_equal mapping.lookup('varchar(20)'), string
+      end
+
+      def test_aliasing_types
+        string = String.new
+        mapping = TypeMap.new
+
+        mapping.register_type(/string/i, string)
+        mapping.alias_type(/varchar/i, 'string')
+
+        assert_equal mapping.lookup('varchar'), string
+      end
+
+      def test_changing_type_changes_aliases
+        time = Time.new
+        timestamp = DateTime.new
+        mapping = TypeMap.new
+
+        mapping.register_type(/timestamp/i, time)
+        mapping.alias_type(/datetime/i, 'timestamp')
+        mapping.register_type(/timestamp/i, timestamp)
+
+        assert_equal mapping.lookup('datetime'), timestamp
+      end
+
+      def test_aliases_keep_metadata
+        mapping = TypeMap.new
+
+        mapping.register_type(/decimal/i) { |sql_type| sql_type }
+        mapping.alias_type(/number/i, 'decimal')
+
+        assert_equal mapping.lookup('number(20)'), 'decimal(20)'
+        assert_equal mapping.lookup('number'), 'decimal'
+      end
+
+      def test_register_proc
+        string = String.new
+        binary = Binary.new
+        mapping = TypeMap.new
+
+        mapping.register_type(/varchar/i) do |type|
+          if type.include?('(')
+            string
+          else
+            binary
+          end
+        end
+
+        assert_equal mapping.lookup('varchar(20)'), string
+        assert_equal mapping.lookup('varchar'), binary
+      end
+
+      def test_additional_lookup_args
+        mapping = TypeMap.new
+
+        mapping.register_type(/varchar/i) do |type, limit|
+          if limit > 255
+            'text'
+          else
+            'string'
+          end
+        end
+        mapping.alias_type(/string/i, 'varchar')
+
+        assert_equal mapping.lookup('varchar', 200), 'string'
+        assert_equal mapping.lookup('varchar', 400), 'text'
+        assert_equal mapping.lookup('string', 400), 'text'
+      end
+
+      def test_requires_value_or_block
+        mapping = TypeMap.new
+
+        assert_raises(ArgumentError) do
+          mapping.register_type(/only key/i)
+        end
+      end
+
+      def test_lookup_non_strings
+        mapping = HashLookupTypeMap.new
+
+        mapping.register_type(1, 'string')
+        mapping.register_type(2, 'int')
+        mapping.alias_type(3, 1)
+
+        assert_equal mapping.lookup(1), 'string'
+        assert_equal mapping.lookup(2), 'int'
+        assert_equal mapping.lookup(3), 'string'
+        assert_kind_of Type::Value, mapping.lookup(4)
+      end
+
+      def test_fetch
+        mapping = TypeMap.new
+        mapping.register_type(1, "string")
+
+        assert_equal "string", mapping.fetch(1) { "int" }
+        assert_equal "int", mapping.fetch(2) { "int" }
+      end
+
+      def test_fetch_yields_args
+        mapping = TypeMap.new
+
+        assert_equal "foo-1-2-3", mapping.fetch("foo", 1, 2, 3) { |*args| args.join("-") }
+        assert_equal "bar-1-2-3", mapping.fetch("bar", 1, 2, 3) { |*args| args.join("-") }
+      end
+
+      def test_fetch_memoizes
+        mapping = TypeMap.new
+
+        looked_up = false
+        mapping.register_type(1) do
+          fail if looked_up
+          looked_up = true
+          "string"
+        end
+
+        assert_equal "string", mapping.fetch(1)
+        assert_equal "string", mapping.fetch(1)
+      end
+
+      def test_fetch_memoizes_on_args
+        mapping = TypeMap.new
+        mapping.register_type("foo") { |*args| args.join("-") }
+
+        assert_equal "foo-1-2-3", mapping.fetch("foo", 1, 2, 3) { |*args| args.join("-") }
+        assert_equal "foo-2-3-4", mapping.fetch("foo", 2, 3, 4) { |*args| args.join("-") }
+      end
+
+      def test_register_clears_cache
+        mapping = TypeMap.new
+
+        mapping.register_type(1, "string")
+        mapping.lookup(1)
+        mapping.register_type(1, "int")
+
+        assert_equal "int", mapping.lookup(1)
+      end
+    end
+  end
+end
+