rmagick 4.1.0.rc2 → 4.1.0

data/test/Enum.rb

@@ -1,228 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class EnumUT < Test::Unit::TestCase
-  def test_new
-    assert_nothing_raised { Magick::Enum.new(:foo, 42) }
-    assert_nothing_raised { Magick::Enum.new('foo', 42) }
-
-    assert_raise(TypeError) { Magick::Enum.new(Object.new, 42) }
-    assert_raise(TypeError) { Magick::Enum.new(:foo, 'x') }
-  end
-
-  def test_to_s
-    enum = Magick::Enum.new(:foo, 42)
-    assert_equal('foo', enum.to_s)
-
-    enum = Magick::Enum.new('foo', 42)
-    assert_equal('foo', enum.to_s)
-  end
-
-  def test_to_i
-    enum = Magick::Enum.new(:foo, 42)
-    assert_equal(42, enum.to_i)
-  end
-
-  def test_spaceship
-    enum1 = Magick::Enum.new(:foo, 42)
-    enum2 = Magick::Enum.new(:foo, 56)
-    enum3 = Magick::Enum.new(:foo, 36)
-    enum4 = Magick::Enum.new(:foo, 42)
-
-    assert_equal(-1, enum1 <=> enum2)
-    assert_equal(0, enum1 <=> enum4)
-    assert_equal(1, enum1 <=> enum3)
-    assert_nil(enum1 <=> 'x')
-  end
-
-  def test_case_eq
-    enum1 = Magick::Enum.new(:foo, 42)
-    enum2 = Magick::Enum.new(:foo, 56)
-
-    assert_true(enum1 === enum1)
-    assert_false(enum1 === enum2)
-    assert_false(enum1 === 'x')
-  end
-
-  def test_bitwise_or
-    enum1 = Magick::Enum.new(:foo, 42)
-    enum2 = Magick::Enum.new(:bar, 56)
-
-    enum = enum1 | enum2
-    assert_equal(58, enum.to_i)
-    assert_equal('foo|bar', enum.to_s)
-
-    assert_raise(ArgumentError) { enum1 | 'x' }
-  end
-
-  def test_type_values
-    assert_instance_of(Array, Magick::AlignType.values)
-
-    assert_equal('UndefinedAlign', Magick::AlignType.values[0].to_s)
-    assert_equal(0, Magick::AlignType.values[0].to_i)
-
-    Magick::AlignType.values do |enum|
-      assert_kind_of(Magick::Enum, enum)
-      assert_instance_of(Magick::AlignType, enum)
-    end
-  end
-
-  def test_type_inspect
-    assert_equal('UndefinedAlign=0', Magick::AlignType.values[0].inspect)
-  end
-
-  def test_using_compose_does_not_cause_endless_loop
-    img = Magick::Image.new(10, 10)
-    Magick::CompositeOperator.values do |op|
-      img.compose = op
-      assert_equal(op, img.compose)
-    end
-  end
-
-  def test_using_class_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::ClassType.values do |value|
-      next if value == Magick::UndefinedClass
-
-      img.class_type = value
-      assert_equal(value, img.class_type)
-    end
-  end
-
-  def test_using_colorspace_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::ColorspaceType.values do |value|
-      next if value == Magick::SRGBColorspace
-
-      assert_not_equal(value, img.colorspace)
-    end
-  end
-
-  def test_using_compression_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::CompressionType.values do |value|
-      img.compression = value
-      assert_equal(value, img.compression)
-    end
-  end
-
-  def test_using_dispose_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::DisposeType.values do |value|
-      img.dispose = value
-      assert_equal(value, img.dispose)
-    end
-  end
-
-  def test_using_endian_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::EndianType.values do |value|
-      img.endian = value
-      assert_equal(value, img.endian)
-    end
-  end
-
-  def test_using_filter_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::FilterType.values do |value|
-      img.filter = value
-      assert_equal(value, img.filter)
-    end
-  end
-
-  def test_using_gravity_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::GravityType.values do |value|
-      img.gravity = value
-      assert_equal(value, img.gravity)
-    end
-  end
-
-  def test_using_image_type_does_not_cause_endless_loop
-    info = Magick::Image::Info.new
-    Magick::ImageType.values do |value|
-      info.image_type = value
-      assert_equal(value, info.image_type)
-    end
-  end
-
-  def test_using_orientation_type_does_not_cause_endless_loop
-    info = Magick::Image::Info.new
-    Magick::OrientationType.values do |value|
-      info.orientation = value
-      assert_equal(value, info.orientation)
-    end
-  end
-
-  def test_using_interlace_type_does_not_cause_endless_loop
-    info = Magick::Image::Info.new
-    Magick::InterlaceType.values do |value|
-      info.interlace = value
-      assert_equal(value, info.interlace)
-    end
-  end
-
-  def test_using_pixel_interpolation_method_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::PixelInterpolateMethod.values do |value|
-      img.pixel_interpolation_method = value
-      assert_equal(value, img.pixel_interpolation_method)
-    end
-  end
-
-  def test_using_rendering_intent_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::RenderingIntent.values do |value|
-      img.rendering_intent = value
-      assert_equal(value, img.rendering_intent)
-    end
-  end
-
-  def test_using_resolution_type_does_not_cause_endless_loop
-    info = Magick::Image::Info.new
-    Magick::ResolutionType.values do |value|
-      info.units = value
-      assert_equal(value, info.units)
-    end
-  end
-
-  def test_using_virtual_pixel_method_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::VirtualPixelMethod.values do |value|
-      img.virtual_pixel_method = value
-      assert_equal(value, img.virtual_pixel_method)
-    end
-  end
-
-  def test_storage_type_name
-    img = Magick::Image.new(20, 20)
-    pixels = img.export_pixels(0, 0, 20, 20, 'RGB').pack('D*')
-
-    assert_raise_message(/UndefinedPixel/) do
-      img.import_pixels(0, 0, 20, 20, 'RGB', pixels, Magick::UndefinedPixel)
-    end
-  end
-
-  def test_stretch_type_name
-    Magick::StretchType.values do |stretch|
-      font = Magick::Font.new('Arial', 'font test', 'Arial family', Magick::NormalStyle, stretch, 400, nil, 'test foundry', 'test format')
-      assert_match(/stretch=#{stretch.to_s}/, font.to_s)
-    end
-
-    font = Magick::Font.new('Arial', 'font test', 'Arial family', Magick::NormalStyle, nil, 400, nil, 'test foundry', 'test format')
-    assert_match(/stretch=UndefinedStretch/, font.to_s)
-  end
-
-  def test_style_type_name
-    Magick::StyleType.values do |style|
-      font = Magick::Font.new('Arial', 'font test', 'Arial family', style, Magick::NormalStretch, 400, nil, 'test foundry', 'test format')
-      assert_match(/style=#{style.to_s}/, font.to_s)
-    end
-
-    font = Magick::Font.new('Arial', 'font test', 'Arial family', nil, Magick::NormalStretch, 400, nil, 'test foundry', 'test format')
-    assert_match(/style=UndefinedStyle/, font.to_s)
-  end
-end

data/test/Fill.rb

@@ -1,93 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class GradientFillUT < Test::Unit::TestCase
-  def test_new
-    assert_instance_of(Magick::GradientFill, Magick::GradientFill.new(0, 0, 0, 100, '#900', '#000'))
-    assert_instance_of(Magick::GradientFill, Magick::GradientFill.new(0, 0, 0, 100, 'white', 'red'))
-
-    assert_raise(ArgumentError) { Magick::GradientFill.new(0, 0, 0, 100, 'foo', '#000') }
-    assert_raise(ArgumentError) { Magick::GradientFill.new(0, 0, 0, 100, '#900', 'bar') }
-    assert_raise(TypeError) { Magick::GradientFill.new('x1', 0, 0, 100, '#900', '#000') }
-    assert_raise(TypeError) { Magick::GradientFill.new(0, 'y1', 0, 100, '#900', '#000') }
-    assert_raise(TypeError) { Magick::GradientFill.new(0, 0, 'x2', 100, '#900', '#000') }
-    assert_raise(TypeError) { Magick::GradientFill.new(0, 0, 0, 'y2', '#900', '#000') }
-  end
-
-  def test_fill
-    img = Magick::Image.new(10, 10)
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 0, 0, 0, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 0, 0, 10, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 0, 10, 0, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 0, 10, 10, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 0, 5, 20, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(-10, 0, -10, 10, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, -10, 10, -10, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, -10, 10, -20, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 100, 100, 200, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-  end
-end
-
-class TextureFillUT < Test::Unit::TestCase
-  def test_new
-    granite = Magick::Image.read('granite:').first
-    assert_instance_of(Magick::TextureFill, Magick::TextureFill.new(granite))
-  end
-
-  def test_fill
-    granite = Magick::Image.read('granite:').first
-    texture = Magick::TextureFill.new(granite)
-
-    img = Magick::Image.new(10, 10)
-    obj = texture.fill(img)
-    assert_equal(texture, obj)
-  end
-end

data/test/Image1.rb

@@ -1,606 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-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
-    encoded = [blob].pack('m*')
-    res = Magick::Image.read_inline(encoded)
-    assert_instance_of(Array, res)
-    assert_instance_of(Magick::Image, res[0])
-    assert_equal(img, res[0])
-    assert_raise(ArgumentError) { Magick::Image.read(nil) }
-    assert_raise(ArgumentError) { Magick::Image.read("") }
-  end
-
-  def test_spaceship
-    img0 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
-    img1 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first
-    sig0 = img0.signature
-    sig1 = img1.signature
-    # since <=> is based on the signature, the images should
-    # have the same relationship to each other as their
-    # signatures have to each other.
-    assert_equal(sig0 <=> sig1, img0 <=> img1)
-    assert_equal(sig1 <=> sig0, img1 <=> img0)
-    assert_equal(img0, img0)
-    assert_not_equal(img0, img1)
-    assert_nil(img0 <=> nil)
-  end
-
-  def test_adaptive_blur
-    assert_nothing_raised do
-      res = @img.adaptive_blur
-      assert_instance_of(Magick::Image, res)
-    end
-    assert_nothing_raised { @img.adaptive_blur(2) }
-    assert_nothing_raised { @img.adaptive_blur(3, 2) }
-    assert_raise(ArgumentError) { @img.adaptive_blur(3, 2, 2) }
-  end
-
-  def test_adaptive_blur_channel
-    assert_nothing_raised do
-      res = @img.adaptive_blur_channel
-      assert_instance_of(Magick::Image, res)
-    end
-    assert_nothing_raised { @img.adaptive_blur_channel(2) }
-    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(TypeError) { @img.adaptive_blur_channel(3, 2, 2) }
-  end
-
-  def test_adaptive_resize
-    assert_nothing_raised do
-      res = @img.adaptive_resize(10, 10)
-      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
-    assert_nothing_raised do
-      res = @img.adaptive_sharpen
-      assert_instance_of(Magick::Image, res)
-    end
-    assert_nothing_raised { @img.adaptive_sharpen(2) }
-    assert_nothing_raised { @img.adaptive_sharpen(3, 2) }
-    assert_raise(ArgumentError) { @img.adaptive_sharpen(3, 2, 2) }
-  end
-
-  def test_adaptive_sharpen_channel
-    assert_nothing_raised do
-      res = @img.adaptive_sharpen_channel
-      assert_instance_of(Magick::Image, res)
-    end
-    assert_nothing_raised { @img.adaptive_sharpen_channel(2) }
-    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(TypeError) { @img.adaptive_sharpen_channel(3, 2, 2) }
-  end
-
-  def test_adaptive_threshold
-    assert_nothing_raised do
-      res = @img.adaptive_threshold
-      assert_instance_of(Magick::Image, res)
-    end
-    assert_nothing_raised { @img.adaptive_threshold(2) }
-    assert_nothing_raised { @img.adaptive_threshold(2, 4) }
-    assert_nothing_raised { @img.adaptive_threshold(2, 4, 1) }
-    assert_raise(ArgumentError) { @img.adaptive_threshold(2, 4, 1, 2) }
-  end
-
-  def test_add_compose_mask
-    mask = Magick::Image.new(20, 20)
-    assert_nothing_raised { @img.add_compose_mask(mask) }
-    assert_nothing_raised { @img.delete_compose_mask }
-    assert_nothing_raised { @img.add_compose_mask(mask) }
-    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
-    Magick::NoiseType.values do |noise|
-      assert_nothing_raised { @img.add_noise(noise) }
-    end
-    assert_raise(TypeError) { @img.add_noise(0) }
-  end
-
-  def test_add_noise_channel
-    assert_nothing_raised { @img.add_noise_channel(Magick::UniformNoise) }
-    assert_nothing_raised { @img.add_noise_channel(Magick::UniformNoise, Magick::RedChannel) }
-    assert_nothing_raised { @img.add_noise_channel(Magick::GaussianNoise, Magick::BlueChannel) }
-    assert_nothing_raised { @img.add_noise_channel(Magick::ImpulseNoise, Magick::GreenChannel) }
-    assert_nothing_raised { @img.add_noise_channel(Magick::LaplacianNoise, Magick::RedChannel, Magick::GreenChannel) }
-    assert_nothing_raised { @img.add_noise_channel(Magick::PoissonNoise, Magick::RedChannel, Magick::GreenChannel, Magick::BlueChannel) }
-
-    # Not a NoiseType
-    assert_raise(TypeError) { @img.add_noise_channel(1) }
-    # Not a ChannelType
-    assert_raise(TypeError) { @img.add_noise_channel(Magick::UniformNoise, Magick::RedChannel, 1) }
-    # Too few arguments
-    assert_raise(ArgumentError) { @img.add_noise_channel }
-  end
-
-  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
-
-  def test_affine_matrix
-    affine = Magick::AffineMatrix.new(1, Math::PI / 6, Math::PI / 6, 1, 0, 0)
-    assert_nothing_raised { @img.affine_transform(affine) }
-    assert_raise(TypeError) { @img.affine_transform(0) }
-    res = @img.affine_transform(affine)
-    assert_instance_of(Magick::Image,  res)
-  end
-
-  # test alpha backward compatibility. Image#alpha w/o arguments acts like alpha?
-  def test_alpha_compat
-    assert_nothing_raised { @img.alpha }
-    assert !@img.alpha
-    assert_nothing_raised { @img.alpha Magick::ActivateAlphaChannel }
-    assert @img.alpha
-  end
-
-  def test_alpha
-    assert_nothing_raised { @img.alpha? }
-    assert !@img.alpha?
-    assert_nothing_raised { @img.alpha Magick::ActivateAlphaChannel }
-    assert @img.alpha?
-    assert_nothing_raised { @img.alpha Magick::DeactivateAlphaChannel }
-    assert !@img.alpha?
-    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 }
-    assert_instance_of(Magick::Image, res)
-    assert_not_same(@img, res)
-    assert_nothing_raised { res = @img.auto_gamma_channel Magick::RedChannel }
-    assert_nothing_raised { res = @img.auto_gamma_channel Magick::RedChannel, Magick::BlueChannel }
-    assert_raise(TypeError) { @img.auto_gamma_channel(1) }
-  end
-
-  def test_auto_level
-    res = nil
-    assert_nothing_raised { res = @img.auto_level_channel }
-    assert_instance_of(Magick::Image, res)
-    assert_not_same(@img, res)
-    assert_nothing_raised { res = @img.auto_level_channel Magick::RedChannel }
-    assert_nothing_raised { res = @img.auto_level_channel Magick::RedChannel, Magick::BlueChannel }
-    assert_raise(TypeError) { @img.auto_level_channel(1) }
-  end
-
-  def test_auto_orient
-    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
-      res = @img.auto_orient!
-      # When not changed, returns nil
-      assert_nil(res)
-    end
-  end
-
-  def test_bilevel_channel
-    assert_raise(ArgumentError) { @img.bilevel_channel }
-    assert_nothing_raised { @img.bilevel_channel(100) }
-    assert_nothing_raised { @img.bilevel_channel(100, Magick::RedChannel) }
-    assert_nothing_raised { @img.bilevel_channel(100, Magick::RedChannel, Magick::BlueChannel, Magick::GreenChannel, Magick::OpacityChannel) }
-    assert_nothing_raised { @img.bilevel_channel(100, Magick::CyanChannel, Magick::MagentaChannel, Magick::YellowChannel, Magick::BlackChannel) }
-    assert_nothing_raised { @img.bilevel_channel(100, Magick::GrayChannel) }
-    assert_nothing_raised { @img.bilevel_channel(100, Magick::AllChannels) }
-    assert_raise(TypeError) { @img.bilevel_channel(100, 2) }
-    res = @img.bilevel_channel(100)
-    assert_instance_of(Magick::Image, res)
-  end
-
-  def test_blend
-    @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_raise(ArgumentError) { @img.blend }
-    assert_raise(ArgumentError) { @img.blend(@img2, 'x') }
-    assert_raise(TypeError) { @img.blend(@img2, 0.25, []) }
-    assert_raise(TypeError) { @img.blend(@img2, 0.25, 0.75, 'x') }
-    assert_raise(TypeError) { @img.blend(@img2, 0.25, 0.75, Magick::CenterGravity, 'x') }
-    assert_raise(TypeError) { @img.blend(@img2, 0.25, 0.75, Magick::CenterGravity, 10, []) }
-
-    @img2.destroy!
-    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) }
-    assert_nothing_raised { @img.blur_channel(1, 2) }
-    assert_nothing_raised { @img.blur_channel(1, 2, Magick::RedChannel) }
-    assert_nothing_raised { @img.blur_channel(1, 2, Magick::RedChannel, Magick::BlueChannel, Magick::GreenChannel, Magick::OpacityChannel) }
-    assert_nothing_raised { @img.blur_channel(1, 2, Magick::CyanChannel, Magick::MagentaChannel, Magick::YellowChannel, Magick::BlackChannel) }
-    assert_nothing_raised { @img.blur_channel(1, 2, Magick::GrayChannel) }
-    assert_nothing_raised { @img.blur_channel(1, 2, Magick::AllChannels) }
-    assert_raise(TypeError) { @img.blur_channel(1, 2, 2) }
-    res = @img.blur_channel
-    assert_instance_of(Magick::Image, res)
-  end
-
-  def test_blur_image
-    assert_nothing_raised { @img.blur_image }
-    assert_nothing_raised { @img.blur_image(1) }
-    assert_nothing_raised { @img.blur_image(1, 2) }
-    assert_raise(ArgumentError) { @img.blur_image(1, 2, 3) }
-    res = @img.blur_image
-    assert_instance_of(Magick::Image, res)
-  end
-
-  def test_black_threshold
-    assert_raise(ArgumentError) { @img.black_threshold }
-    assert_nothing_raised { @img.black_threshold(50) }
-    assert_nothing_raised { @img.black_threshold(50, 50) }
-    assert_nothing_raised { @img.black_threshold(50, 50, 50) }
-    assert_raise(ArgumentError) { @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)
-  end
-
-  def test_border
-    assert_nothing_raised { @img.border(2, 2, 'red') }
-    assert_nothing_raised { @img.border!(2, 2, 'red') }
-    res = @img.border(2, 2, 'red')
-    assert_instance_of(Magick::Image, res)
-    @img.freeze
-    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') }
-    assert_nothing_raised do
-      res = @img.change_geometry('100x100') { 1 }
-      assert_equal(1, res)
-    end
-    assert_raise(ArgumentError) { @img.change_geometry([]) }
-  end
-
-  def test_changed?
-    #        assert_block { !@img.changed? }
-    #        @img.pixel_color(0,0,'red')
-    #        assert_block { @img.changed? }
-  end
-
-  def test_channel
-    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
-
-  def test_channel_depth
-    assert_nothing_raised { @img.channel_depth }
-    assert_nothing_raised { @img.channel_depth(Magick::RedChannel) }
-    assert_nothing_raised { @img.channel_depth(Magick::RedChannel, Magick::BlueChannel) }
-    assert_nothing_raised { @img.channel_depth(Magick::GreenChannel, Magick::OpacityChannel) }
-    assert_nothing_raised { @img.channel_depth(Magick::MagentaChannel, Magick::CyanChannel) }
-    assert_nothing_raised { @img.channel_depth(Magick::CyanChannel, Magick::BlackChannel) }
-    assert_nothing_raised { @img.channel_depth(Magick::GrayChannel) }
-    assert_raise(TypeError) { @img.channel_depth(2) }
-    assert_kind_of(Integer, @img.channel_depth(Magick::RedChannel))
-  end
-
-  def test_channel_extrema
-    assert_nothing_raised do
-      res = @img.channel_extrema
-      assert_instance_of(Array, res)
-      assert_equal(2, res.length)
-      assert_kind_of(Integer, res[0])
-      assert_kind_of(Integer, res[1])
-    end
-    assert_nothing_raised { @img.channel_extrema(Magick::RedChannel) }
-    assert_nothing_raised { @img.channel_extrema(Magick::RedChannel, Magick::BlueChannel) }
-    assert_nothing_raised { @img.channel_extrema(Magick::GreenChannel, Magick::OpacityChannel) }
-    assert_nothing_raised { @img.channel_extrema(Magick::MagentaChannel, Magick::CyanChannel) }
-    assert_nothing_raised { @img.channel_extrema(Magick::CyanChannel, Magick::BlackChannel) }
-    assert_nothing_raised { @img.channel_extrema(Magick::GrayChannel) }
-    assert_raise(TypeError) { @img.channel_extrema(2) }
-  end
-
-  def test_channel_mean
-    assert_nothing_raised do
-      res = @img.channel_mean
-      assert_instance_of(Array, res)
-      assert_equal(2, res.length)
-      assert_instance_of(Float, res[0])
-      assert_instance_of(Float, res[1])
-    end
-    assert_nothing_raised { @img.channel_mean(Magick::RedChannel) }
-    assert_nothing_raised { @img.channel_mean(Magick::RedChannel, Magick::BlueChannel) }
-    assert_nothing_raised { @img.channel_mean(Magick::GreenChannel, Magick::OpacityChannel) }
-    assert_nothing_raised { @img.channel_mean(Magick::MagentaChannel, Magick::CyanChannel) }
-    assert_nothing_raised { @img.channel_mean(Magick::CyanChannel, Magick::BlackChannel) }
-    assert_nothing_raised { @img.channel_mean(Magick::GrayChannel) }
-    assert_raise(TypeError) { @img.channel_mean(2) }
-  end
-
-  def test_charcoal
-    assert_nothing_raised do
-      res = @img.charcoal
-      assert_instance_of(Magick::Image, res)
-    end
-    assert_nothing_raised { @img.charcoal(1.0) }
-    assert_nothing_raised { @img.charcoal(1.0, 2.0) }
-    assert_raise(ArgumentError) { @img.charcoal(1.0, 2.0, 3.0) }
-  end
-
-  def test_chop
-    assert_nothing_raised do
-      res = @img.chop(10, 10, 10, 10)
-      assert_instance_of(Magick::Image, res)
-    end
-  end
-
-  def test_clone
-    assert_nothing_raised do
-      res = @img.clone
-      assert_instance_of(Magick::Image, res)
-      assert_equal(res, @img)
-    end
-    res = @img.clone
-    assert_equal(res.frozen?, @img.frozen?)
-    @img.freeze
-    res = @img.clone
-    assert_equal(res.frozen?, @img.frozen?)
-  end
-
-  def test_clut_channel
-    img = Magick::Image.new(20, 20) { self.colorspace = Magick::GRAYColorspace }
-    clut = Magick::Image.new(20, 1) { self.background_color = 'red' }
-    res = nil
-    assert_nothing_raised { res = img.clut_channel(clut) }
-    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
-
-  def test_color_fill_to_border
-    assert_raise(ArgumentError) { @img.color_fill_to_border(-1, 1, 'red') }
-    assert_raise(ArgumentError) { @img.color_fill_to_border(1, 100, 'red') }
-    assert_nothing_raised do
-      res = @img.color_fill_to_border(@img.columns / 2, @img.rows / 2, 'red')
-      assert_instance_of(Magick::Image, res)
-    end
-    pixel = Magick::Pixel.new(Magick::QuantumRange)
-    assert_nothing_raised { @img.color_fill_to_border(@img.columns / 2, @img.rows / 2, pixel) }
-  end
-
-  def test_color_floodfill
-    assert_raise(ArgumentError) { @img.color_floodfill(-1, 1, 'red') }
-    assert_raise(ArgumentError) { @img.color_floodfill(1, 100, 'red') }
-    assert_nothing_raised do
-      res = @img.color_floodfill(@img.columns / 2, @img.rows / 2, 'red')
-      assert_instance_of(Magick::Image, res)
-    end
-    pixel = Magick::Pixel.new(Magick::QuantumRange)
-    assert_nothing_raised { @img.color_floodfill(@img.columns / 2, @img.rows / 2, pixel) }
-  end
-
-  def test_color_histogram
-    assert_nothing_raised do
-      res = @img.color_histogram
-      assert_instance_of(Hash, res)
-    end
-    assert_nothing_raised do
-      @img.class_type = Magick::PseudoClass
-      res = @img.color_histogram
-      assert_equal(Magick::PseudoClass, @img.class_type)
-      assert_instance_of(Hash, res)
-    end
-  end
-
-  def test_colorize
-    assert_nothing_raised do
-      res = @img.colorize(0.25, 0.25, 0.25, 'red')
-      assert_instance_of(Magick::Image, res)
-    end
-    assert_nothing_raised { @img.colorize(0.25, 0.25, 0.25, 0.25, 'red') }
-    pixel = Magick::Pixel.new(Magick::QuantumRange)
-    assert_nothing_raised { @img.colorize(0.25, 0.25, 0.25, pixel) }
-    assert_nothing_raised { @img.colorize(0.25, 0.25, 0.25, 0.25, pixel) }
-    assert_raise(ArgumentError) { @img.colorize }
-    assert_raise(ArgumentError) { @img.colorize(0.25) }
-    assert_raise(ArgumentError) { @img.colorize(0.25, 0.25) }
-    assert_raise(ArgumentError) { @img.colorize(0.25, 0.25, 0.25) }
-    assert_raise(ArgumentError) { @img.colorize(0.25, 0.25, 0.25, 'X') }
-    # last argument must be a color name or pixel
-    assert_raise(TypeError) { @img.colorize(0.25, 0.25, 0.25, 0.25) }
-    assert_raise(ArgumentError) { @img.colorize(0.25, 0.25, 0.25, 0.25, 'X') }
-    assert_raise(TypeError) { @img.colorize(0.25, 0.25, 0.25, 0.25, [2]) }
-  end
-
-  def test_colormap
-    # IndexError b/c @img is DirectClass
-    assert_raise(IndexError) { @img.colormap(0) }
-    # Read PseudoClass image
-    pc_img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
-    assert_nothing_raised { pc_img.colormap(0) }
-    ncolors = pc_img.colors
-    assert_raise(IndexError) { pc_img.colormap(ncolors + 1) }
-    assert_raise(IndexError) { pc_img.colormap(-1) }
-    assert_nothing_raised { pc_img.colormap(ncolors - 1) }
-    res = pc_img.colormap(0)
-    assert_instance_of(String, res)
-
-    # test 'set' operation
-    assert_nothing_raised do
-      old_color = pc_img.colormap(0)
-      res = pc_img.colormap(0, 'red')
-      assert_equal(old_color, res)
-      res = pc_img.colormap(0)
-      assert_equal('red', res)
-    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') }
-  end
-
-  def test_color_point
-    assert_nothing_raised do
-      res = @img.color_point(0, 0, 'red')
-      assert_instance_of(Magick::Image, res)
-      assert_not_same(@img, res)
-    end
-    pixel = Magick::Pixel.new(Magick::QuantumRange)
-    assert_nothing_raised { @img.color_point(0, 0, pixel) }
-  end
-
-  def test_color_reset!
-    assert_nothing_raised do
-      res = @img.color_reset!('red')
-      assert_same(@img, res)
-    end
-    pixel = Magick::Pixel.new(Magick::QuantumRange)
-    assert_nothing_raised { @img.color_reset!(pixel) }
-    assert_raise(TypeError) { @img.color_reset!([2]) }
-    assert_raise(ArgumentError) { @img.color_reset!('x') }
-    @img.freeze
-    assert_raise(FreezeError) { @img.color_reset!('red') }
-  end
-
-  def test_compare_channel
-    img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
-    img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first
-
-    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 }
-
-    ilist = Magick::ImageList.new
-    ilist << img2
-    assert_nothing_raised { img1.compare_channel(ilist, Magick::MeanAbsoluteErrorMetric) }
-
-    assert_nothing_raised { img1.compare_channel(img2, Magick::MeanAbsoluteErrorMetric, Magick::RedChannel) }
-    assert_nothing_raised { img1.compare_channel(img2, Magick::MeanAbsoluteErrorMetric, Magick::RedChannel, Magick::BlueChannel) }
-    assert_raise(TypeError) { img1.compare_channel(img2, Magick::MeanAbsoluteErrorMetric, 2) }
-    assert_raise(TypeError) { img1.compare_channel(img2, Magick::MeanAbsoluteErrorMetric, Magick::RedChannel, 2) }
-
-    res = img1.compare_channel(img2, Magick::MeanAbsoluteErrorMetric)
-    assert_instance_of(Array, res)
-    assert_instance_of(Magick::Image, res[0])
-    assert_instance_of(Float, res[1])
-
-    img2.destroy!
-    assert_raise(Magick::DestroyedImageError) { img1.compare_channel(img2, Magick::MeanAbsoluteErrorMetric) }
-  end
-end
-
-if $PROGRAM_NAME == __FILE__
-  IMAGES_DIR = '../doc/ex/images'
-  FILES = Dir[IMAGES_DIR + '/Button_*.gif']
-  Test::Unit::UI::Console::TestRunner.run(Image1UT)
-end