rmagick 3.0.0 → 3.1.0

data/test/Enum.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby -w
+
+require 'rmagick'
+require 'test/unit'
+require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
+
+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
+end

data/test/Fill.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby -w
+
+require 'rmagick'
+require 'test/unit'
+require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
+
+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

@@ -329,7 +329,7 @@ class Image1_UT < Test::Unit::TestCase
     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_instance_of(Fixnum, @img.channel_depth(Magick::RedChannel))
+    assert_kind_of(Integer, @img.channel_depth(Magick::RedChannel))
   end
 
   def test_channel_extrema
@@ -434,6 +434,12 @@ class Image1_UT < Test::Unit::TestCase
       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
@@ -536,6 +542,8 @@ class Image1_UT < Test::Unit::TestCase
     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) }
     assert_raise(TypeError) { img1.compare_channel(img2, 2) }
     assert_raise(ArgumentError) { img1.compare_channel }
 

data/test/Image2.rb

@@ -71,10 +71,10 @@ class Image2_UT < Test::Unit::TestCase
   end
 
   def test_compress_colormap!
-    # DirectClass images are converted to PseudoClass
+    # DirectClass images are converted to PseudoClass in older versions of ImageMagick.
     assert_equal(Magick::DirectClass, @img.class_type)
     assert_nothing_raised { @img.compress_colormap! }
-    assert_equal(Magick::PseudoClass, @img.class_type)
+    # assert_equal(Magick::PseudoClass, @img.class_type)
     @img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
     assert_equal(Magick::PseudoClass, @img.class_type)
     assert_nothing_raised { @img.compress_colormap! }
@@ -428,6 +428,8 @@ class Image2_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.distortion_channel(@img, Magick::PeakSignalToNoiseRatioMetric) }
     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) }
+    assert_nothing_raised { @img.distortion_channel(@img, Magick::FuzzErrorMetric) }
     assert_raise(TypeError) { @img.distortion_channel(@img, 2) }
     assert_raise(TypeError) { @img.distortion_channel(@img, Magick::RootMeanSquaredErrorMetric, 2) }
     assert_raise(ArgumentError) { @img.distortion_channel }
@@ -714,6 +716,16 @@ class Image2_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.frame(50, 50, 25, 25, 6, 6, 2) }
   end
 
+  def test_fx
+    assert_nothing_raised { @img.fx('1/2') }
+    assert_nothing_raised { @img.fx('1/2', Magick::BlueChannel) }
+    assert_nothing_raised { @img.fx('1/2', Magick::BlueChannel, Magick::RedChannel) }
+    assert_raise(ArgumentError) { @img.fx }
+    assert_raise(ArgumentError) { @img.fx(Magick::BlueChannel) }
+    assert_raise(TypeError) { @img.fx(1) }
+    assert_raise(TypeError) { @img.fx('1/2', 1) }
+  end
+
   def test_gamma_channel
     assert_nothing_raised do
       res = @img.gamma_channel(0.8)
@@ -765,8 +777,6 @@ class Image2_UT < Test::Unit::TestCase
 
   def test_gramma_correct
     assert_raise(ArgumentError) { @img.gamma_correct }
-    # All 4 arguments can't default to 1.0
-    assert_raise(ArgumentError) { @img.gamma_correct(1.0) }
     assert_nothing_raised do
       res = @img.gamma_correct(0.8)
       assert_instance_of(Magick::Image, res)

data/test/Image3.rb

@@ -26,7 +26,8 @@ ColorspaceTypes = [
   Magick::Rec601YCbCrColorspace,
   Magick::Rec709LumaColorspace,
   Magick::Rec709YCbCrColorspace,
-  Magick::LogColorspace
+  Magick::LogColorspace,
+  Magick::CMYColorspace
 ]
 
 Filters = [
@@ -44,7 +45,16 @@ Filters = [
   Magick::MitchellFilter,
   Magick::LanczosFilter,
   Magick::BesselFilter,
-  Magick::SincFilter
+  Magick::SincFilter,
+  Magick::JincFilter,
+  Magick::SincFastFilter,
+  Magick::LanczosSharpFilter,
+  Magick::Lanczos2Filter,
+  Magick::Lanczos2SharpFilter,
+  Magick::RobidouxFilter,
+  Magick::RobidouxSharpFilter,
+  Magick::CosineFilter,
+  Magick::SplineFilter
 ]
 
 class Image3_UT < Test::Unit::TestCase
@@ -63,6 +73,8 @@ class Image3_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.profile!('icc', nil) }
     assert_nothing_raised { @img.profile!('iptc', nil) }
 
+    assert_raise(ArgumentError) { @img.profile!('test', 'foobarbaz') }
+
     @img.freeze
     assert_raise(FreezeError) { @img.profile!('icc', 'xxx') }
     assert_raise(FreezeError) { @img.profile!('*', nil) }
@@ -99,7 +111,26 @@ class Image3_UT < Test::Unit::TestCase
       Magick::OrQuantumOperator,
       Magick::RShiftQuantumOperator,
       Magick::SubtractQuantumOperator,
-      Magick::XorQuantumOperator
+      Magick::XorQuantumOperator,
+      Magick::PowQuantumOperator,
+      Magick::LogQuantumOperator,
+      Magick::ThresholdQuantumOperator,
+      Magick::ThresholdBlackQuantumOperator,
+      Magick::ThresholdWhiteQuantumOperator,
+      Magick::GaussianNoiseQuantumOperator,
+      Magick::ImpulseNoiseQuantumOperator,
+      Magick::LaplacianNoiseQuantumOperator,
+      Magick::MultiplicativeNoiseQuantumOperator,
+      Magick::PoissonNoiseQuantumOperator,
+      Magick::UniformNoiseQuantumOperator,
+      Magick::CosineQuantumOperator,
+      Magick::SineQuantumOperator,
+      Magick::AddModulusQuantumOperator,
+      Magick::MeanQuantumOperator,
+      Magick::AbsQuantumOperator,
+      Magick::ExponentialQuantumOperator,
+      Magick::MedianQuantumOperator,
+      Magick::SumQuantumOperator
     ]
 
     assert_nothing_raised do
@@ -161,6 +192,10 @@ class Image3_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.random_threshold_channel('20%', 2) }
   end
 
+  def test_recolor
+    assert_raise(TypeError) { @img.recolor('x') }
+  end
+
   def test_reduce_noise
     assert_nothing_raised do
       res = @img.reduce_noise(0)
@@ -785,6 +820,26 @@ class Image3_UT < Test::Unit::TestCase
     assert_raise(FreezeError) { @img.thumbnail!(0.50) }
   end
 
+  def test_tint
+    assert_nothing_raised do
+      pixels = @img.get_pixels(0, 0, 1, 1)
+      @img.tint(pixels[0], 1.0)
+    end
+    assert_nothing_raised { @img.tint('red', 1.0) }
+    assert_nothing_raised { @img.tint('red', 1.0, 1.0) }
+    assert_nothing_raised { @img.tint('red', 1.0, 1.0, 1.0) }
+    assert_nothing_raised { @img.tint('red', 1.0, 1.0, 1.0, 1.0) }
+    assert_raise(ArgumentError) { @img.tint }
+    assert_raise(ArgumentError) { @img.tint('red') }
+    assert_raise(ArgumentError) { @img.tint('red', 1.0, 1.0, 1.0, 1.0, 1.0) }
+    assert_raise(ArgumentError) { @img.tint('x', 1.0) }
+    assert_raise(TypeError) { @img.tint(1.0, 1.0) }
+    assert_raise(TypeError) { @img.tint('red', 'green') }
+    assert_raise(TypeError) { @img.tint('red', 1.0, 'green') }
+    assert_raise(TypeError) { @img.tint('red', 1.0, 1.0, 'green') }
+    assert_raise(TypeError) { @img.tint('red', 1.0, 1.0, 1.0, 'green') }
+  end
+
   def test_to_blob
     res = nil
     assert_nothing_raised { res = @img.to_blob { self.format = 'miff' } }
@@ -1021,6 +1076,21 @@ class Image3_UT < Test::Unit::TestCase
     img = Magick::Image.read('test.0')
     assert_equal('JPEG', img.first.format)
     FileUtils.rm('test.0')
+
+    @img.write('test.webp')
+    img = Magick::Image.read('test.webp')
+    assert_equal('WEBP', img.first.format)
+    FileUtils.rm('test.webp') rescue nil # Avoid failure on AppVeyor
+
+    f = File.new('test.0', 'w')
+    Magick::Image.new(100, 100).write(f) do
+      self.format = 'JPEG'
+      self.colorspace = Magick::CMYKColorspace
+    end
+    f.close
+    img = Magick::Image.read('test.0')
+    assert_equal('JPEG', img.first.format)
+    FileUtils.rm('test.0')
   end
 end
 

data/test/ImageList1.rb

@@ -15,6 +15,15 @@ class ImageList1UT < Test::Unit::TestCase
     @list2 << @list[9]
   end
 
+  def test_composite_layers
+    assert_nothing_raised { @list.composite_layers(@list2) }
+    Magick::CompositeOperator.values do |op|
+      assert_nothing_raised { @list.composite_layers(@list2, op) }
+    end
+
+    assert_raise(ArgumentError) { @list.composite_layers(@list2, Magick::AddCompositeOp, 42) }
+  end
+
   def test_delay
     assert_nothing_raised { @list.delay }
     assert_equal(0, @list.delay)
@@ -23,6 +32,10 @@ class ImageList1UT < Test::Unit::TestCase
     assert_raise(ArgumentError) { @list.delay = 'x' }
   end
 
+  def test_flatten_images
+    assert_nothing_raised { @list.flatten_images }
+  end
+
   def test_ticks_per_second
     assert_nothing_raised { @list.ticks_per_second }
     assert_equal(100, @list.ticks_per_second)
@@ -33,7 +46,7 @@ class ImageList1UT < Test::Unit::TestCase
 
   def test_iterations
     assert_nothing_raised { @list.iterations }
-    assert_equal(1, @list.iterations)
+    assert_kind_of(Integer, @list.iterations)
     assert_nothing_raised { @list.iterations = 20 }
     assert_equal(20, @list.iterations)
     assert_raise(ArgumentError) { @list.iterations = 'x' }
@@ -370,7 +383,7 @@ class ImageList1UT < Test::Unit::TestCase
     @list.scene = 7
     cur = @list.cur_image
     assert_nothing_raised do
-      @list.delete_if { |img| img.filename =~ /5/ }
+      @list.delete_if { |img| File.basename(img.filename) =~ /5/ }
       assert_instance_of(Magick::ImageList, @list)
       assert_equal(9, @list.length)
       assert_same(cur, @list.cur_image)
@@ -378,7 +391,7 @@ class ImageList1UT < Test::Unit::TestCase
 
     # Delete the current image
     assert_nothing_raised do
-      @list.delete_if { |img| img.filename =~ /7/ }
+      @list.delete_if { |img| File.basename(img.filename) =~ /7/ }
       assert_instance_of(Magick::ImageList, @list)
       assert_equal(8, @list.length)
       assert_same(@list[-1], @list.cur_image)
@@ -441,7 +454,7 @@ class ImageList1UT < Test::Unit::TestCase
 
   def find_all
     assert_nothing_raised do
-      res = @list.select { |img| img.filename =~ /Button_2/ }
+      res = @list.select { |img| File.basename(img.filename) =~ /Button_2/ }
       assert_instance_of(Magick::ImageList, res)
       assert_equal(1, res.length)
       assert_same(res[0], @list[2])
@@ -552,7 +565,7 @@ class ImageList1UT < Test::Unit::TestCase
     cur = @list.cur_image
     list = @list
     assert_nothing_raised do
-      res = @list.reject { |img| img.filename =~ /Button_9/ }
+      res = @list.reject { |img| File.basename(img.filename) =~ /Button_9/ }
       assert_equal(9, res.length)
       assert_instance_of(Magick::ImageList, res)
       assert_same(cur, res.cur_image)
@@ -561,7 +574,7 @@ class ImageList1UT < Test::Unit::TestCase
     assert_same(cur, @list.cur_image)
 
     # Omit current image from result list - result cur_image s/b last image
-    res = @list.reject { |img| img.filename =~ /Button_7/ }
+    res = @list.reject { |img| File.basename(img.filename) =~ /Button_7/ }
     assert_equal(9, res.length)
     assert_same(res[-1], res.cur_image)
     assert_same(cur, @list.cur_image)
@@ -571,7 +584,7 @@ class ImageList1UT < Test::Unit::TestCase
     @list.scene = 7
     cur = @list.cur_image
     assert_nothing_raised do
-      @list.reject! { |img| img.filename =~ /5/ }
+      @list.reject! { |img| File.basename(img.filename) =~ /5/ }
       assert_instance_of(Magick::ImageList, @list)
       assert_equal(9, @list.length)
       assert_same(cur, @list.cur_image)
@@ -579,7 +592,7 @@ class ImageList1UT < Test::Unit::TestCase
 
     # Delete the current image
     assert_nothing_raised do
-      @list.reject! { |img| img.filename =~ /7/ }
+      @list.reject! { |img| File.basename(img.filename) =~ /7/ }
       assert_instance_of(Magick::ImageList, @list)
       assert_equal(8, @list.length)
       assert_same(@list[-1], @list.cur_image)
@@ -668,7 +681,7 @@ class ImageList1UT < Test::Unit::TestCase
 
   def test_select
     assert_nothing_raised do
-      res = @list.select { |img| img.filename =~ /Button_2/ }
+      res = @list.select { |img| File.basename(img.filename) =~ /Button_2/ }
       assert_instance_of(Magick::ImageList, res)
       assert_equal(1, res.length)
       assert_same(res[0], @list[2])