rmagick 3.1.0 → 3.2.0

data/test/Fill.rb

@@ -2,7 +2,7 @@
 
 require 'rmagick'
 require 'test/unit'
-require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
+require 'test/unit/ui/console/testrunner'
 
 class GradientFillUT < Test::Unit::TestCase
   def test_new

data/test/Image1.rb

@@ -2,13 +2,29 @@
 
 require 'rmagick'
 require 'test/unit'
-require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
+require 'test/unit/ui/console/testrunner'
 
 class Image1_UT < Test::Unit::TestCase
   def setup
     @img = Magick::Image.new(20, 20)
   end
 
+  def test_class_type
+    assert_raise(ArgumentError) { @img.class_type = Magick::UndefinedClass }
+  end
+
+  def test_constitute
+    pixels = @img.dispatch(0, 0, @img.columns, @img.rows, 'RGBA')
+    res = Magick::Image.constitute(@img.columns, @img.rows, 'RGBA', pixels)
+    assert_equal(res.columns, @img.columns)
+    assert_equal(res.rows, @img.rows)
+
+    assert_nothing_raised { Magick::Image.constitute(@img.columns, @img.rows, 'RGBA', [1.0] * (4 * @img.columns * @img.rows)) }
+    assert_raise(TypeError) { Magick::Image.constitute(@img.columns, @img.rows, 'RGBA', ['x'] * (4 * @img.columns * @img.rows)) }
+    assert_raise(ArgumentError) { Magick::Image.constitute(0, @img.rows, 'RGBA', pixels) }
+    assert_raise(ArgumentError) { Magick::Image.constitute(@img.columns, 0, 'RGBA', pixels) }
+  end
+
   def test_read_inline
     img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
     blob = img.to_blob
@@ -33,6 +49,7 @@ class Image1_UT < Test::Unit::TestCase
     assert_equal(sig1 <=> sig0, img1 <=> img0)
     assert_equal(img0, img0)
     assert_not_equal(img0, img1)
+    assert_nil(img0 <=> nil)
   end
 
   def test_adaptive_blur
@@ -54,7 +71,7 @@ class Image1_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.adaptive_blur_channel(3, 2) }
     assert_nothing_raised { @img.adaptive_blur_channel(3, 2, Magick::RedChannel) }
     assert_nothing_raised { @img.adaptive_blur_channel(3, 2, Magick::RedChannel, Magick::BlueChannel) }
-    assert_raise(ArgumentError) { @img.adaptive_blur(3, 2, 2) }
+    assert_raise(TypeError) { @img.adaptive_blur_channel(3, 2, 2) }
   end
 
   def test_adaptive_resize
@@ -63,8 +80,10 @@ class Image1_UT < Test::Unit::TestCase
       assert_instance_of(Magick::Image, res)
     end
     assert_nothing_raised { @img.adaptive_resize(2) }
+    assert_raise(ArgumentError) { @img.adaptive_resize(-1.0) }
     assert_raise(ArgumentError) { @img.adaptive_resize(10, 10, 10) }
     assert_raise(ArgumentError) { @img.adaptive_resize }
+    assert_raise(RangeError) { @img.adaptive_resize(Float::MAX) }
   end
 
   def test_adaptive_sharpen
@@ -86,7 +105,7 @@ class Image1_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.adaptive_sharpen_channel(3, 2) }
     assert_nothing_raised { @img.adaptive_sharpen_channel(3, 2, Magick::RedChannel) }
     assert_nothing_raised { @img.adaptive_sharpen_channel(3, 2, Magick::RedChannel, Magick::BlueChannel) }
-    assert_raise(ArgumentError) { @img.adaptive_sharpen(3, 2, 2) }
+    assert_raise(TypeError) { @img.adaptive_sharpen_channel(3, 2, 2) }
   end
 
   def test_adaptive_threshold
@@ -108,15 +127,15 @@ class Image1_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.add_compose_mask(mask) }
     assert_nothing_raised { @img.delete_compose_mask }
     assert_nothing_raised { @img.delete_compose_mask }
+
+    mask = Magick::Image.new(10, 10)
+    assert_raise(ArgumentError) { @img.add_compose_mask(mask) }
   end
 
   def test_add_noise
-    assert_nothing_raised { @img.add_noise(Magick::UniformNoise) }
-    assert_nothing_raised { @img.add_noise(Magick::GaussianNoise) }
-    assert_nothing_raised { @img.add_noise(Magick::MultiplicativeGaussianNoise) }
-    assert_nothing_raised { @img.add_noise(Magick::ImpulseNoise) }
-    assert_nothing_raised { @img.add_noise(Magick::LaplacianNoise) }
-    assert_nothing_raised { @img.add_noise(Magick::PoissonNoise) }
+    Magick::NoiseType.values do |noise|
+      assert_nothing_raised { @img.add_noise(noise) }
+    end
     assert_raise(TypeError) { @img.add_noise(0) }
   end
 
@@ -136,10 +155,11 @@ class Image1_UT < Test::Unit::TestCase
     assert_raise(ArgumentError) { @img.add_noise_channel }
   end
 
-  def add_delete_profile
-    img = Magick::Image.read('cmyk.jpg'), first
-    assert_nothing_raised { img.add_profile('cmyk.icm') }
-    assert_nothing_raised { img.add_profile('srgb.icm') }
+  def test_add_delete_profile
+    img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
+    assert_nothing_raised { img.add_profile(File.join(__dir__, 'cmyk.icm')) }
+    # assert_raise(Magick::ImageMagickError) { img.add_profile(File.join(__dir__, 'srgb.icm')) }
+
     img.each_profile { |name, _value| assert_equal('icc', name) }
     assert_nothing_raised { img.delete_profile('icc') }
   end
@@ -167,12 +187,28 @@ class Image1_UT < Test::Unit::TestCase
     assert @img.alpha?
     assert_nothing_raised { @img.alpha Magick::DeactivateAlphaChannel }
     assert !@img.alpha?
-    assert_nothing_raised { @img.alpha Magick::ResetAlphaChannel }
+    assert_nothing_raised { @img.alpha Magick::OpaqueAlphaChannel }
     assert_nothing_raised { @img.alpha Magick::SetAlphaChannel }
+    assert_raise(ArgumentError) { @img.alpha Magick::SetAlphaChannel, Magick::OpaqueAlphaChannel }
     @img.freeze
     assert_raise(FreezeError) { @img.alpha Magick::SetAlphaChannel }
   end
 
+  def test_aref
+    img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
+    assert_nil(img[nil])
+    assert_nil(img['label'])
+    assert_match(/^Creator: PolyView/, img[:comment])
+  end
+
+  def test_aset
+    @img['label'] = 'foobarbaz'
+    @img[:comment] = 'Hello world'
+    assert_equal('foobarbaz', @img['label'])
+    assert_equal('Hello world', @img['comment'])
+    assert_nothing_raised { @img[nil] = 'foobarbaz' }
+  end
+
   def test_auto_gamma
     res = nil
     assert_nothing_raised { res = @img.auto_gamma_channel }
@@ -194,10 +230,14 @@ class Image1_UT < Test::Unit::TestCase
   end
 
   def test_auto_orient
-    assert_nothing_raised do
-      res = @img.auto_orient
-      assert_instance_of(Magick::Image, res)
-      assert_not_same(@img, res)
+    Magick::OrientationType.values.each do |v|
+      assert_nothing_raised do
+        img = Magick::Image.new(10, 10)
+        img.orientation = v
+        res = img.auto_orient
+        assert_instance_of(Magick::Image, res)
+        assert_not_same(img, res)
+      end
     end
 
     assert_nothing_raised do
@@ -224,13 +264,17 @@ class Image1_UT < Test::Unit::TestCase
     @img2 = Magick::Image.new(20, 20) { self.background_color = 'black' }
     assert_nothing_raised { @img.blend(@img2, 0.25) }
     res = @img.blend(@img2, 0.25)
+
+    Magick::GravityType.values do |gravity|
+      assert_nothing_raised { @img.blend(@img2, 0.25, 0.75, gravity) }
+      assert_nothing_raised { @img.blend(@img2, 0.25, 0.75, gravity, 10) }
+      assert_nothing_raised { @img.blend(@img2, 0.25, 0.75, gravity, 10, 10) }
+    end
+
     assert_instance_of(Magick::Image, res)
     assert_nothing_raised { @img.blend(@img2, '25%') }
     assert_nothing_raised { @img.blend(@img2, 0.25, 0.75) }
     assert_nothing_raised { @img.blend(@img2, '25%', '75%') }
-    assert_nothing_raised { @img.blend(@img2, 0.25, 0.75, Magick::CenterGravity) }
-    assert_nothing_raised { @img.blend(@img2, 0.25, 0.75, Magick::CenterGravity, 10) }
-    assert_nothing_raised { @img.blend(@img2, 0.25, 0.75, Magick::CenterGravity, 10, 10) }
     assert_raise(ArgumentError) { @img.blend }
     assert_raise(ArgumentError) { @img.blend(@img2, 'x') }
     assert_raise(TypeError) { @img.blend(@img2, 0.25, []) }
@@ -242,6 +286,13 @@ class Image1_UT < Test::Unit::TestCase
     assert_raise(Magick::DestroyedImageError) { @img.blend(@img2, '25%') }
   end
 
+  def test_blue_shift
+    assert_not_same(@img, @img.blue_shift)
+    assert_not_same(@img, @img.blue_shift(2.0))
+    assert_raise(TypeError) { @img.blue_shift('x') }
+    assert_raise(ArgumentError) { @img.blue_shift(2, 2) }
+  end
+
   def test_blur_channel
     assert_nothing_raised { @img.blur_channel }
     assert_nothing_raised { @img.blur_channel(1) }
@@ -271,6 +322,9 @@ class Image1_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.black_threshold(50, 50) }
     assert_nothing_raised { @img.black_threshold(50, 50, 50) }
     assert_nothing_raised { @img.black_threshold(50, 50, 50, 50) }
+    assert_nothing_raised { @img.black_threshold(50, 50, 50, alpha: 50) }
+    assert_raise(ArgumentError) { @img.black_threshold(50, 50, 50, wrong: 50) }
+    assert_raise(ArgumentError) { @img.black_threshold(50, 50, 50, alpha: 50, extra: 50) }
     assert_raise(ArgumentError) { @img.black_threshold(50, 50, 50, 50, 50) }
     res = @img.black_threshold(50)
     assert_instance_of(Magick::Image, res)
@@ -285,6 +339,16 @@ class Image1_UT < Test::Unit::TestCase
     assert_raise(FreezeError) { @img.border!(2, 2, 'red') }
   end
 
+  def test_capture
+    # assert_nothing_raised { Magick::Image.capture }
+    # assert_nothing_raised { Magick::Image.capture(true) }
+    # assert_nothing_raised { Magick::Image.capture(true, true) }
+    # assert_nothing_raised { Magick::Image.capture(true, true, true) }
+    # assert_nothing_raised { Magick::Image.capture(true, true, true, true) }
+    # assert_nothing_raised { Magick::Image.capture(true, true, true, true, true) }
+    assert_raise(ArgumentError) { Magick::Image.capture(true, true, true, true, true, true) }
+  end
+
   def test_change_geometry
     assert_raise(ArgumentError) { @img.change_geometry('sss') }
     assert_raise(LocalJumpError) { @img.change_geometry('100x100') }
@@ -302,20 +366,10 @@ class Image1_UT < Test::Unit::TestCase
   end
 
   def test_channel
-    assert_nothing_raised { @img.channel(Magick::RedChannel) }
-    assert_nothing_raised { @img.channel(Magick::BlueChannel) }
-    assert_nothing_raised { @img.channel(Magick::GreenChannel) }
-    assert_nothing_raised { @img.channel(Magick::OpacityChannel) }
-    assert_nothing_raised { @img.channel(Magick::MagentaChannel) }
-    assert_nothing_raised { @img.channel(Magick::CyanChannel) }
-    assert_nothing_raised { @img.channel(Magick::YellowChannel) }
-    assert_nothing_raised { @img.channel(Magick::BlackChannel) }
-    assert_nothing_raised { @img.channel(Magick::GrayChannel) }
-    assert_nothing_raised { @img.channel(Magick::AlphaChannel) }
-    assert_nothing_raised { @img.channel(Magick::DefaultChannels) }
-    assert_nothing_raised { @img.channel(Magick::HueChannel) }
-    assert_nothing_raised { @img.channel(Magick::LuminosityChannel) }
-    assert_nothing_raised { @img.channel(Magick::SaturationChannel) }
+    Magick::ChannelType.values do |channel|
+      assert_nothing_raised { @img.channel(channel) }
+    end
+
     assert_instance_of(Magick::Image, @img.channel(Magick::RedChannel))
     assert_raise(TypeError) { @img.channel(2) }
   end
@@ -404,6 +458,7 @@ class Image1_UT < Test::Unit::TestCase
     assert_same(res, img)
     assert_nothing_raised { img.clut_channel(clut, Magick::RedChannel) }
     assert_nothing_raised { img.clut_channel(clut, Magick::RedChannel, Magick::BlueChannel) }
+    assert_raises(ArgumentError) { img.clut_channel }
     assert_raises(ArgumentError) { img.clut_channel(clut, 1, Magick::RedChannel) }
   end
 
@@ -485,6 +540,8 @@ class Image1_UT < Test::Unit::TestCase
     end
     pixel = Magick::Pixel.new(Magick::QuantumRange)
     assert_nothing_raised { pc_img.colormap(0, pixel) }
+    assert_raise(ArgumentError) { pc_img.colormap }
+    assert_raise(ArgumentError) { pc_img.colormap(0, pixel, Magick::BlackChannel) }
     assert_raise(TypeError) { pc_img.colormap(0, [2]) }
     pc_img.freeze
     assert_raise(FreezeError) { pc_img.colormap(0, 'red') }
@@ -537,13 +594,10 @@ class Image1_UT < Test::Unit::TestCase
   def test_compare_channel
     img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
     img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first
-    assert_nothing_raised { img1.compare_channel(img2, Magick::MeanAbsoluteErrorMetric) }
-    assert_nothing_raised { img1.compare_channel(img2, Magick::MeanSquaredErrorMetric) }
-    assert_nothing_raised { img1.compare_channel(img2, Magick::PeakAbsoluteErrorMetric) }
-    assert_nothing_raised { img1.compare_channel(img2, Magick::PeakSignalToNoiseRatioMetric) }
-    assert_nothing_raised { img1.compare_channel(img2, Magick::RootMeanSquaredErrorMetric) }
-    assert_nothing_raised { img1.compare_channel(img2, Magick::NormalizedCrossCorrelationErrorMetric) }
-    assert_nothing_raised { img1.compare_channel(img2, Magick::FuzzErrorMetric) }
+
+    Magick::MetricType.values do |metric|
+      assert_nothing_raised { img1.compare_channel(img2, metric) }
+    end
     assert_raise(TypeError) { img1.compare_channel(img2, 2) }
     assert_raise(ArgumentError) { img1.compare_channel }
 
@@ -569,5 +623,5 @@ end
 if $PROGRAM_NAME == __FILE__
   IMAGES_DIR = '../doc/ex/images'
   FILES = Dir[IMAGES_DIR + '/Button_*.gif']
-  Test::Unit::UI::Console::TestRunner.run(Image1UT) unless RUBY_VERSION[/^1\.9|^2/]
+  Test::Unit::UI::Console::TestRunner.run(Image1UT)
 end

data/test/Image2.rb

@@ -2,7 +2,7 @@
 
 require 'rmagick'
 require 'test/unit'
-require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
+require 'test/unit/ui/console/testrunner'
 
 # TODO: improve exif tests - need a benchmark image with EXIF data
 
@@ -11,12 +11,42 @@ class Image2_UT < Test::Unit::TestCase
     @img = Magick::Image.new(20, 20)
   end
 
-  def test_composite!
+  def test_composite
     img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
     img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first
+    Magick::CompositeOperator.values do |op|
+      Magick::GravityType.values do |gravity|
+        assert_nothing_raised do
+          res = img1.composite(img2, gravity, 5, 5, op)
+          assert_not_same(img1, res)
+        end
+      end
+    end
+
     assert_nothing_raised do
-      res = img1.composite!(img2, Magick::NorthWestGravity, Magick::OverCompositeOp)
-      assert_same(img1, res)
+      res = img1.composite(img2, 5, 5, Magick::OverCompositeOp)
+      assert_not_same(img1, res)
+    end
+
+    assert_raise(TypeError) { img1.composite(img2, 'x', 5, Magick::OverCompositeOp) }
+    assert_raise(TypeError) { img1.composite(img2, 5, 'y', Magick::OverCompositeOp) }
+    assert_raise(TypeError) { img1.composite(img2, Magick::NorthWestGravity, 'x', 5, Magick::OverCompositeOp) }
+    assert_raise(TypeError) { img1.composite(img2, Magick::NorthWestGravity, 5, 'y', Magick::OverCompositeOp) }
+
+    img1.freeze
+    assert_nothing_raised { img1.composite(img2, Magick::NorthWestGravity, Magick::OverCompositeOp) }
+  end
+
+  def test_composite!
+    img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
+    img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first
+    Magick::CompositeOperator.values do |op|
+      Magick::GravityType.values do |gravity|
+        assert_nothing_raised do
+          res = img1.composite!(img2, gravity, op)
+          assert_same(img1, res)
+        end
+      end
     end
     img1.freeze
     assert_raise(FreezeError) { img1.composite!(img2, Magick::NorthWestGravity, Magick::OverCompositeOp) }
@@ -33,6 +63,22 @@ class Image2_UT < Test::Unit::TestCase
     end
   end
 
+  def test_composite_channel
+    img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
+    img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first
+    Magick::CompositeOperator.values do |op|
+      Magick::GravityType.values do |gravity|
+        assert_nothing_raised do
+          res = img1.composite_channel(img2, gravity, 5, 5, op, Magick::BlueChannel)
+          assert_not_same(img1, res)
+        end
+      end
+    end
+
+    assert_raise(ArgumentError) { img1.composite_channel(img2, Magick::NorthWestGravity) }
+    assert_raise(TypeError) { img1.composite_channel(img2, Magick::NorthWestGravity, 5, 5, Magick::OverCompositeOp, 'x') }
+  end
+
   def test_composite_mathematics
     bg = Magick::Image.new(50, 50)
     fg = Magick::Image.new(50, 50) { self.background_color = 'black' }
@@ -66,6 +112,10 @@ class Image2_UT < Test::Unit::TestCase
     assert_nothing_raised { bg.composite_tiled(fg, Magick::RedChannel) }
     assert_nothing_raised { bg.composite_tiled(fg, Magick::RedChannel, Magick::GreenChannel) }
 
+    assert_raise(ArgumentError) { bg.composite_tiled }
+    assert_raise(TypeError) { bg.composite_tiled(fg, 'x') }
+    assert_raise(TypeError) { bg.composite_tiled(fg, Magick::AtopCompositeOp, Magick::RedChannel, 'x') }
+
     fg.destroy!
     assert_raise(Magick::DestroyedImageError) { bg.composite_tiled(fg) }
   end
@@ -107,6 +157,17 @@ class Image2_UT < Test::Unit::TestCase
     assert_raise(ArgumentError) { @img.contrast_stretch_channel(25, 'x') }
   end
 
+  def test_morphology
+    kernel = Magick::KernelInfo.new('Octagon')
+    Magick::MorphologyMethod.values do |method|
+      assert_nothing_raised do
+        res = @img.morphology(method, 2, kernel)
+        assert_instance_of(Magick::Image, res)
+        assert_not_same(@img, res)
+      end
+    end
+  end
+
   def test_morphology_channel
     assert_raise(ArgumentError) { @img.morphology_channel }
     assert_raise(ArgumentError) { @img.morphology_channel(Magick::RedChannel) }
@@ -131,15 +192,19 @@ class Image2_UT < Test::Unit::TestCase
       assert_not_same(@img, res)
     end
     assert_raise(ArgumentError) { @img.convolve }
+    assert_raise(ArgumentError) { @img.convolve(0) }
+    assert_raise(ArgumentError) { @img.convolve(-1) }
     assert_raise(ArgumentError) { @img.convolve(order) }
     assert_raise(IndexError) { @img.convolve(5, kernel) }
     assert_raise(IndexError) { @img.convolve(order, 'x') }
     assert_raise(TypeError) { @img.convolve(3, [1.0, 1.0, 1.0, 1.0, 'x', 1.0, 1.0, 1.0, 1.0]) }
-    assert_raise(Magick::ImageMagickError) { @img.convolve(-1, [1.0, 1.0, 1.0, 1.0]) }
+    assert_raise(ArgumentError) { @img.convolve(-1, [1.0, 1.0, 1.0, 1.0]) }
   end
 
   def test_convolve_channel
     assert_raise(ArgumentError) { @img.convolve_channel }
+    assert_raise(ArgumentError) { @img.convolve_channel(0) }
+    assert_raise(ArgumentError) { @img.convolve_channel(-1) }
     assert_raise(ArgumentError) { @img.convolve_channel(3) }
     kernel = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
     order = 3
@@ -173,16 +238,9 @@ class Image2_UT < Test::Unit::TestCase
       assert_instance_of(Magick::Image, res)
       assert_not_same(@img, res)
     end
-    gravity = [
-      Magick::NorthEastGravity,
-      Magick::EastGravity,
-      Magick::SouthWestGravity,
-      Magick::SouthGravity,
-      Magick::SouthEastGravity
-    ]
 
     # 3-argument form
-    gravity.each do |grav|
+    Magick::GravityType.values do |grav|
       assert_nothing_raised { @img.crop(grav, @img.columns / 2, @img.rows / 2) }
     end
     assert_raise(TypeError) { @img.crop(2, @img.columns / 2, @img.rows / 2) }
@@ -196,7 +254,7 @@ class Image2_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.crop(0, 0, @img.columns / 2, @img.rows / 2, 2) }
 
     # 5-argument form
-    gravity.each do |grav|
+    Magick::GravityType.values do |grav|
       assert_nothing_raised { @img.crop(grav, 0, 0, @img.columns / 2, @img.rows / 2) }
     end
 
@@ -239,6 +297,7 @@ class Image2_UT < Test::Unit::TestCase
   def test_define
     assert_nothing_raised { @img.define('deskew:auto-crop', 40) }
     assert_nothing_raised { @img.undefine('deskew:auto-crop') }
+    assert_nothing_raised { @img.define('deskew:auto-crop', nil) }
   end
 
   def test_deskew
@@ -266,11 +325,7 @@ class Image2_UT < Test::Unit::TestCase
   # ensure methods detect destroyed images
   def test_destroy
     methods = Magick::Image.instance_methods(false).sort
-    methods -= if RUBY_VERSION[/^1\.9|^2/]
-                 %i[__display__ destroy! destroyed? inspect cur_image marshal_load]
-               else
-                 %w[__display__ destroy! destroyed? inspect cur_image marshal_load]
-               end
+    methods -= %i[__display__ destroy! destroyed? inspect cur_image marshal_load]
 
     assert_equal(false, @img.destroyed?)
     @img.destroy!
@@ -288,8 +343,6 @@ class Image2_UT < Test::Unit::TestCase
         assert_raises(Magick::DestroyedImageError) { @img.difference(other) }
       elsif method == 'channel_entropy' && IM_VERSION < Gem::Version.new('6.9')
         assert_raises(NotImplementedError) { @img.channel_entropy }
-      elsif %w[morphology morphology_channel].include?(method)
-        warn "skipped testing `#destroy` against `##{method}`"
       elsif method == 'get_iptc_dataset'
         assert_raises(Magick::DestroyedImageError) { @img.get_iptc_dataset('x') }
       elsif method == 'profile!'
@@ -396,6 +449,7 @@ class Image2_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.dissolve(src, 0.50, 0.10, Magick::NorthEastGravity, 10) }
     assert_nothing_raised { @img.dissolve(src, 0.50, 0.10, Magick::NorthEastGravity, 10, 10) }
 
+    assert_raise(ArgumentError) { @img.dissolve }
     assert_raise(ArgumentError) { @img.dissolve(src, 'x') }
     assert_raise(ArgumentError) { @img.dissolve(src, 0.50, 'x') }
     assert_raise(TypeError) { @img.dissolve(src, 0.50, Magick::NorthEastGravity, 'x') }
@@ -412,9 +466,11 @@ class Image2_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.distort(Magick::BilinearDistortion, [7, 40, 4, 30, 4, 124, 4, 123, 85, 122, 100, 123, 85, 2, 100, 30]) }
     assert_nothing_raised { @img.distort(Magick::PerspectiveDistortion, [7, 40, 4, 30,   4, 124, 4, 123, 85, 122, 100, 123, 85, 2, 100, 30]) }
     assert_nothing_raised { @img.distort(Magick::ScaleRotateTranslateDistortion, [28, 24, 0.4, 0.8 - 110, 37.5, 60]) }
+    assert_nothing_raised { @img.distort(Magick::ScaleRotateTranslateDistortion, [28, 24, 0.4, 0.8 - 110, 37.5, 60], true) }
     assert_raise(ArgumentError) { @img.distort }
     assert_raise(ArgumentError) { @img.distort(Magick::AffineDistortion) }
     assert_raise(TypeError) { @img.distort(1, [1]) }
+    assert_raise(TypeError) { @img.distort(Magick::AffineDistortion, [2, 60, 2, 60, 32, 60, 32, 60, 2, 30, 17, 'x']) }
   end
 
   def test_distortion_channel
@@ -425,7 +481,7 @@ class Image2_UT < Test::Unit::TestCase
     end
     assert_nothing_raised { @img.distortion_channel(@img, Magick::MeanSquaredErrorMetric) }
     assert_nothing_raised { @img.distortion_channel(@img, Magick::PeakAbsoluteErrorMetric) }
-    assert_nothing_raised { @img.distortion_channel(@img, Magick::PeakSignalToNoiseRatioMetric) }
+    assert_nothing_raised { @img.distortion_channel(@img, Magick::PeakSignalToNoiseRatioErrorMetric) }
     assert_nothing_raised { @img.distortion_channel(@img, Magick::RootMeanSquaredErrorMetric) }
     assert_nothing_raised { @img.distortion_channel(@img, Magick::MeanSquaredErrorMetric, Magick::RedChannel, Magick:: BlueChannel) }
     assert_nothing_raised { @img.distortion_channel(@img, Magick::NormalizedCrossCorrelationErrorMetric) }
@@ -440,6 +496,18 @@ class Image2_UT < Test::Unit::TestCase
     assert_raise(Magick::DestroyedImageError) { @img.distortion_channel(img, Magick::MeanSquaredErrorMetric) }
   end
 
+  def test__dump
+    img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
+    assert_instance_of(String, img._dump(10))
+  end
+
+  def test__load
+    img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
+    res = img._dump(10)
+
+    assert_instance_of(Magick::Image, Magick::Image._load(res))
+  end
+
   def test_dup
     assert_nothing_raised do
       ditto = @img.dup
@@ -620,8 +688,11 @@ class Image2_UT < Test::Unit::TestCase
     assert_equal(40, res.rows)
     assert_nothing_raised { @img.extent(40, 40, 5) }
     assert_nothing_raised { @img.extent(40, 40, 5, 5) }
+    assert_raises(ArgumentError) { @img.extent(-40) }
     assert_raises(ArgumentError) { @img.extent(-40, 40) }
     assert_raises(ArgumentError) { @img.extent(40, -40) }
+    assert_raises(ArgumentError) { @img.extent(40, 40, 5, 5, 0) }
+    assert_raises(ArgumentError) { @img.extent(0, 0, 5, 5) }
     assert_raises(TypeError) { @img.extent('x', 40) }
     assert_raises(TypeError) { @img.extent(40, 'x') }
     assert_raises(TypeError) { @img.extent(40, 40, 'x') }
@@ -714,6 +785,7 @@ class Image2_UT < Test::Unit::TestCase
     red = Magick::Pixel.new(Magick::QuantumRange)
     assert_nothing_raised { @img.frame(50, 50, 25, 25, 6, 6, red) }
     assert_raise(TypeError) { @img.frame(50, 50, 25, 25, 6, 6, 2) }
+    assert_raise(ArgumentError) { @img.frame(50, 50, 25, 25, 6, 6, red, 2) }
   end
 
   def test_fx
@@ -862,6 +934,7 @@ class Image2_UT < Test::Unit::TestCase
       assert_instance_of(Magick::Image, res)
       assert_not_same(@img, res)
     end
+    assert_raise(ArgumentError) { @img.implode(0.5, 0.5) }
   end
 
   def test_import_pixels
@@ -917,6 +990,12 @@ class Image2_UT < Test::Unit::TestCase
     # Ensure that level2 uses new arg order
     img1 = @img.level2(10, 200, 2)
     assert_equal(img2, img1)
+
+    assert_nothing_raised { @img.level2 }
+    assert_nothing_raised { @img.level2(10) }
+    assert_nothing_raised { @img.level2(10, 10) }
+    assert_nothing_raised { @img.level2(10, 10, 10) }
+    assert_raise(ArgumentError) { @img.level2(10, 10, 10, 10) }
   end
 
   def test_level_channel
@@ -938,7 +1017,7 @@ class Image2_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.level_channel(Magick::RedChannel, 0.0, 1.0, 'x') }
   end
 
-  def level_colors
+  def test_level_colors
     res = nil
     assert_nothing_raised do
       res = @img.level_colors
@@ -947,19 +1026,17 @@ class Image2_UT < Test::Unit::TestCase
     assert_not_same(@img, res)
 
     assert_nothing_raised { @img.level_colors('black') }
-    assert_nothing_raised { @img.level_colors('black', Pixel.new(0, 0, 0)) }
-    assert_nothing_raised { @img.level_colors(Pixel.new(0, 0, 0), Pixel.new(Magick::QuantumRange, Magick::QuantumRange, Magick::QuantumRange)) }
+    assert_nothing_raised { @img.level_colors('black', Magick::Pixel.new(0, 0, 0)) }
+    assert_nothing_raised { @img.level_colors(Magick::Pixel.new(0, 0, 0), Magick::Pixel.new(Magick::QuantumRange, Magick::QuantumRange, Magick::QuantumRange)) }
     assert_nothing_raised { @img.level_colors('black', 'white') }
     assert_nothing_raised { @img.level_colors('black', 'white', false) }
-    # too many arguments
-    assert_raises(ArgumentError) { @img.level_colors('black', 'white', false, 1) }
-    # not a pixel or a string
-    assert_raises(ArgumentError) { @img.level_colors([]) }
-    # not a color name
+
+    assert_raises(TypeError) { @img.level_colors('black', 'white', false, 1) }
+    assert_raises(TypeError) { @img.level_colors([]) }
     assert_raises(ArgumentError) { @img.level_colors('xxx') }
   end
 
-  def levelize_channel
+  def test_levelize_channel
     res = nil
     assert_nothing_raised do
       res = @img.levelize_channel(0, Magick::QuantumRange)
@@ -967,12 +1044,13 @@ class Image2_UT < Test::Unit::TestCase
     assert_instance_of(Magick::Image, res)
     assert_not_same(@img, res)
 
+    assert_nothing_raised { @img.levelize_channel(0) }
+    assert_nothing_raised { @img.levelize_channel(0, Magick::QuantumRange) }
     assert_nothing_raised { @img.levelize_channel(0, Magick::QuantumRange, 0.5) }
     assert_nothing_raised { @img.levelize_channel(0, Magick::QuantumRange, 0.5, Magick::RedChannel) }
     assert_nothing_raised { @img.levelize_channel(0, Magick::QuantumRange, 0.5, Magick::RedChannel, Magick::BlueChannel) }
-    # too many arguments
-    assert_raise(ArgumentError) { @img.levelize_channel(0, Magick::QuantumRange, 0.5, 1, Magick::RedChannel) }
-    # not enough arguments
+
+    assert_raise(TypeError) { @img.levelize_channel(0, Magick::QuantumRange, 0.5, 1, Magick::RedChannel) }
     assert_raise(ArgumentError) { @img.levelize_channel }
   end
 
@@ -1044,6 +1122,7 @@ class Image2_UT < Test::Unit::TestCase
     assert_equal(20, res.columns)
     assert_equal(20, res.rows)
 
+    assert_raise(ArgumentError) { @img.mask(cimg, 'x') }
     # mask expects an Image and calls `cur_image'
     assert_raise(NoMethodError) { @img.mask = 2 }
 
@@ -1072,8 +1151,16 @@ class Image2_UT < Test::Unit::TestCase
       assert_not_same(@img, res)
     end
     assert_nothing_raised { @img.matte_floodfill(@img.columns, @img.rows) }
+
+    Magick::PaintMethod.values do |method|
+      next if [Magick::FillToBorderMethod, Magick::FloodfillMethod].include?(method)
+
+      assert_raise(ArgumentError) { @img.matte_flood_fill('blue', Magick::TransparentAlpha, @img.columns, @img.rows, method) }
+    end
     assert_raise(ArgumentError) { @img.matte_floodfill(@img.columns + 1, @img.rows) }
     assert_raise(ArgumentError) { @img.matte_floodfill(@img.columns, @img.rows + 1) }
+    assert_nothing_raised { @img.matte_flood_fill('blue', @img.columns, @img.rows, Magick::FloodfillMethod, alpha: Magick::TransparentAlpha) }
+    assert_raise(ArgumentError) { @img.matte_flood_fill('blue', @img.columns, @img.rows, Magick::FloodfillMethod, wrong: Magick::TransparentAlpha) }
   end
 
   def test_matte_replace
@@ -1122,6 +1209,7 @@ class Image2_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.modulate(0.5) }
     assert_nothing_raised { @img.modulate(0.5, 0.5) }
     assert_nothing_raised { @img.modulate(0.5, 0.5, 0.5) }
+    assert_raise(ArgumentError) { @img.modulate(0.0, 0.5, 0.5) }
     assert_raise(ArgumentError) { @img.modulate(0.5, 0.5, 0.5, 0.5) }
     assert_raise(TypeError) { @img.modulate('x', 0.5, 0.5) }
     assert_raise(TypeError) { @img.modulate(0.5, 'x', 0.5) }
@@ -1225,6 +1313,7 @@ class Image2_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.opaque_channel('red', 'blue', true, 50, 50) }
     assert_raise(TypeError) { @img.opaque_channel('red', 'blue', true, []) }
     assert_raise(ArgumentError) { @img.opaque_channel('red') }
+    assert_raise(ArgumentError) { @img.opaque_channel('red', 'blue', true, -0.1) }
     assert_raise(TypeError) { @img.opaque_channel('red', []) }
   end
 
@@ -1232,7 +1321,7 @@ class Image2_UT < Test::Unit::TestCase
     assert_nothing_raised do
       assert_block { @img.opaque? }
     end
-    @img.opacity = Magick::TransparentOpacity
+    @img.alpha(Magick::TransparentAlphaChannel)
     assert_block { !@img.opaque? }
   end
 
@@ -1242,6 +1331,7 @@ class Image2_UT < Test::Unit::TestCase
       assert_instance_of(Magick::Image, res)
       assert_not_same(@img, res)
     end
+    assert_nothing_raised { @img.ordered_dither('3x3') }
     assert_nothing_raised { @img.ordered_dither(2) }
     assert_nothing_raised { @img.ordered_dither(3) }
     assert_nothing_raised { @img.ordered_dither(4) }
@@ -1256,8 +1346,15 @@ class Image2_UT < Test::Unit::TestCase
     assert_instance_of(Magick::Image, res)
     assert_not_same(res, @img)
     assert_nothing_raised { @img.paint_transparent('red', Magick::TransparentOpacity) }
+    assert_nothing_raised { @img.paint_transparent('red', alpha: Magick::TransparentAlpha) }
+    assert_raise(ArgumentError) { @img.paint_transparent('red', wrong: Magick::TransparentAlpha) }
     assert_nothing_raised { @img.paint_transparent('red', Magick::TransparentOpacity, true) }
+    assert_nothing_raised { @img.paint_transparent('red', true, alpha: Magick::TransparentAlpha) }
+    assert_raise(ArgumentError) { @img.paint_transparent('red', true, wrong: Magick::TransparentAlpha) }
+    assert_raise(ArgumentError) { @img.paint_transparent('red', true, alpha: Magick::TransparentAlpha, extra: Magick::TransparentAlpha) }
     assert_nothing_raised { @img.paint_transparent('red', Magick::TransparentOpacity, true, 50) }
+    assert_nothing_raised { @img.paint_transparent('red', true, 50, alpha: Magick::TransparentAlpha) }
+    assert_raise(ArgumentError) { @img.paint_transparent('red', true, 50, wrong: Magick::TransparentAlpha) }
 
     # Too many arguments
     assert_raise(ArgumentError) { @img.paint_transparent('red', Magick::TransparentOpacity, true, 50, 50) }
@@ -1294,6 +1391,12 @@ class Image2_UT < Test::Unit::TestCase
     # If args are out-of-bounds return the background color
     img = Magick::Image.new(10, 10) { self.background_color = 'blue' }
     assert_equal('blue', img.pixel_color(50, 50).to_color)
+
+    assert_nothing_raised do
+      @img.class_type = Magick::PseudoClass
+      res = @img.pixel_color(0, 0, 'red')
+      assert_equal('blue', res.to_color)
+    end
   end
 
   def test_polaroid
@@ -1301,6 +1404,7 @@ class Image2_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.polaroid(5) }
     assert_instance_of(Magick::Image, @img.polaroid)
     assert_raises(TypeError) { @img.polaroid('x') }
+    assert_raises(ArgumentError) { @img.polaroid(5, 'x') }
   end
 
   def test_posterize
@@ -1318,5 +1422,5 @@ end
 if $PROGRAM_NAME == __FILE__
   IMAGES_DIR = '../doc/ex/images'
   FILES = Dir[IMAGES_DIR + '/Button_*.gif']
-  Test::Unit::UI::Console::TestRunner.run(Image2UT) unless RUBY_VERSION[/^1\.9|^2/]
+  Test::Unit::UI::Console::TestRunner.run(Image2UT)
 end