rmagick 3.1.0 → 3.2.0

data/spec/rmagick/image/composite_spec.rb

@@ -1,77 +1,6 @@
 RSpec.describe Magick::Image, '#composite' do
   let(:img1) { Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first }
   let(:img2) { Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first }
-  let(:composite_ops) do
-    [
-      Magick::UndefinedCompositeOp,
-      Magick::NoCompositeOp,
-      Magick::AddCompositeOp,
-      Magick::AtopCompositeOp,
-      Magick::BumpmapCompositeOp,
-      Magick::ClearCompositeOp,
-      Magick::ColorizeCompositeOp,
-      Magick::CopyBlueCompositeOp,
-      Magick::CopyCompositeOp,
-      Magick::CopyGreenCompositeOp,
-      Magick::CopyOpacityCompositeOp,
-      Magick::CopyRedCompositeOp,
-      Magick::CopyCyanCompositeOp,
-      Magick::CopyMagentaCompositeOp,
-      Magick::CopyYellowCompositeOp,
-      Magick::CopyBlackCompositeOp,
-      Magick::DarkenCompositeOp,
-      Magick::DifferenceCompositeOp,
-      Magick::DisplaceCompositeOp,
-      Magick::DissolveCompositeOp,
-      Magick::DstAtopCompositeOp,
-      Magick::DstCompositeOp,
-      Magick::DstInCompositeOp,
-      Magick::DstOutCompositeOp,
-      Magick::DstOverCompositeOp,
-      Magick::HueCompositeOp,
-      Magick::InCompositeOp,
-      Magick::LightenCompositeOp,
-      Magick::LuminizeCompositeOp,
-      Magick::MinusCompositeOp,
-      Magick::ModulateCompositeOp,
-      Magick::MultiplyCompositeOp,
-      Magick::OutCompositeOp,
-      Magick::OverCompositeOp,
-      Magick::OverlayCompositeOp,
-      Magick::PlusCompositeOp,
-      Magick::ReplaceCompositeOp,
-      Magick::SaturateCompositeOp,
-      Magick::ScreenCompositeOp,
-      Magick::SrcAtopCompositeOp,
-      Magick::SrcCompositeOp,
-      Magick::SrcInCompositeOp,
-      Magick::SrcOutCompositeOp,
-      Magick::SrcOverCompositeOp,
-      Magick::SubtractCompositeOp,
-      Magick::ThresholdCompositeOp,
-      Magick::XorCompositeOp,
-      Magick::BlendCompositeOp,
-      Magick::ColorBurnCompositeOp,
-      Magick::ColorDodgeCompositeOp,
-      Magick::ExclusionCompositeOp,
-      Magick::HardLightCompositeOp,
-      Magick::SoftLightCompositeOp,
-      Magick::MathematicsCompositeOp,
-      Magick::DivideSrcCompositeOp,
-      Magick::MinusSrcCompositeOp,
-      Magick::DarkenIntensityCompositeOp,
-      Magick::LightenIntensityCompositeOp
-    ]
-  end
-  let(:gravity) do
-    [
-      Magick::NorthEastGravity,
-      Magick::EastGravity,
-      Magick::SouthWestGravity,
-      Magick::SouthGravity,
-      Magick::SouthEastGravity
-    ]
-  end
 
   it 'raises an error given invalid arguments' do
     expect { img1.composite }.to raise_error(ArgumentError)
@@ -85,8 +14,8 @@ RSpec.describe Magick::Image, '#composite' do
 
   context 'when given 3 arguments' do
     it 'works when 2nd argument is a gravity' do
-      composite_ops.each do |op|
-        gravity.each do |grav|
+      Magick::CompositeOperator.values do |op|
+        Magick::GravityType.values do |grav|
           expect { img1.composite(img2, grav, op) }.not_to raise_error
         end
       end
@@ -103,7 +32,7 @@ RSpec.describe Magick::Image, '#composite' do
     it 'works when 4th argument is a composite operator' do
       # there are way too many CompositeOperators to test them all, so just try
       # few representative ops
-      composite_ops.each do |op|
+      Magick::CompositeOperator.values do |op|
         expect { img1.composite(img2, 0, 0, op) }.not_to raise_error
       end
     end
@@ -120,8 +49,8 @@ RSpec.describe Magick::Image, '#composite' do
 
   context 'when given 5 arguments' do
     it 'works when 2nd argument is gravity and 5th is a composite operator' do
-      composite_ops.each do |op|
-        gravity.each do |grav|
+      Magick::CompositeOperator.values do |op|
+        Magick::GravityType.values do |grav|
           expect { img1.composite(img2, grav, 0, 0, op) }.not_to raise_error
         end
       end

data/spec/rmagick/image/properties_spec.rb

@@ -1,6 +1,6 @@
 RSpec.describe Magick::Image, '#properties' do
   let(:img) { Magick::Image.new(20, 20) }
-  let(:freeze_error) { RUBY_VERSION[/^1\.9|^2/] ? RuntimeError : TypeError }
+  let(:freeze_error) { RuntimeError }
 
   before(:each) do
     img['comment'] = 'str_1'

data/test/Draw.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 DrawUT < Test::Unit::TestCase
   def setup
@@ -17,17 +17,15 @@ class DrawUT < Test::Unit::TestCase
   end
 
   def test_align
-    assert_nothing_raised { @draw.align = Magick::UndefinedAlign }
-    assert_nothing_raised { @draw.align = Magick::LeftAlign }
-    assert_nothing_raised { @draw.align = Magick::CenterAlign }
-    assert_nothing_raised { @draw.align = Magick::RightAlign }
+    Magick::AlignType.values do |align|
+      assert_nothing_raised { @draw.align = align }
+    end
   end
 
   def test_decorate
-    assert_nothing_raised { @draw.decorate = Magick::NoDecoration }
-    assert_nothing_raised { @draw.decorate = Magick::UnderlineDecoration }
-    assert_nothing_raised { @draw.decorate = Magick::OverlineDecoration }
-    assert_nothing_raised { @draw.decorate = Magick::LineThroughDecoration }
+    Magick::DecorationType.values do |decoration|
+      assert_nothing_raised { @draw.decorate = decoration }
+    end
   end
 
   def test_density
@@ -72,54 +70,34 @@ class DrawUT < Test::Unit::TestCase
   end
 
   def test_font_stretch
-    assert_nothing_raised { @draw.font_stretch = Magick::NormalStretch }
-    assert_nothing_raised { @draw.font_stretch = Magick::UltraCondensedStretch }
-    assert_nothing_raised { @draw.font_stretch = Magick::ExtraCondensedStretch }
-    assert_nothing_raised { @draw.font_stretch = Magick::CondensedStretch }
-    assert_nothing_raised { @draw.font_stretch = Magick::SemiCondensedStretch }
-    assert_nothing_raised { @draw.font_stretch = Magick::SemiExpandedStretch }
-    assert_nothing_raised { @draw.font_stretch = Magick::ExpandedStretch }
-    assert_nothing_raised { @draw.font_stretch = Magick::ExtraExpandedStretch }
-    assert_nothing_raised { @draw.font_stretch = Magick::UltraExpandedStretch }
-    assert_nothing_raised { @draw.font_stretch = Magick::AnyStretch }
+    Magick::StretchType.values do |stretch|
+      assert_nothing_raised { @draw.font_stretch = stretch }
+    end
 
     assert_raise(TypeError) { @draw.font_stretch = 2 }
   end
 
   def test_font_style
-    assert_nothing_raised { @draw.font_style = Magick::NormalStyle }
-    assert_nothing_raised { @draw.font_style = Magick::ItalicStyle }
-    assert_nothing_raised { @draw.font_style = Magick::ObliqueStyle }
-    assert_nothing_raised { @draw.font_style = Magick::AnyStyle }
+    Magick::StyleType.values do |style|
+      assert_nothing_raised { @draw.font_style = style }
+    end
 
     assert_raise(TypeError) { @draw.font_style = 2 }
   end
 
   def test_font_weight
-    assert_nothing_raised { @draw.font_weight = Magick::AnyWeight }
-    assert_nothing_raised { @draw.font_weight = Magick::NormalWeight }
-    assert_nothing_raised { @draw.font_weight = Magick::BoldWeight }
-    assert_nothing_raised { @draw.font_weight = Magick::BolderWeight }
-    assert_nothing_raised { @draw.font_weight = Magick::LighterWeight }
-    assert_nothing_raised { @draw.font_weight = 200 }
+    Magick::WeightType.values do |weight|
+      assert_nothing_raised { @draw.font_weight = weight }
+    end
 
     assert_raise(ArgumentError) { @draw.font_weight = 99 }
     assert_raise(ArgumentError) { @draw.font_weight = 901 }
   end
 
   def test_gravity
-    assert_nothing_raised { @draw.gravity = Magick::UndefinedGravity }
-    assert_nothing_raised { @draw.gravity = Magick::ForgetGravity }
-    assert_nothing_raised { @draw.gravity = Magick::NorthWestGravity }
-    assert_nothing_raised { @draw.gravity = Magick::NorthGravity }
-    assert_nothing_raised { @draw.gravity = Magick::NorthEastGravity }
-    assert_nothing_raised { @draw.gravity = Magick::WestGravity }
-    assert_nothing_raised { @draw.gravity = Magick::CenterGravity }
-    assert_nothing_raised { @draw.gravity = Magick::EastGravity }
-    assert_nothing_raised { @draw.gravity = Magick::SouthWestGravity }
-    assert_nothing_raised { @draw.gravity = Magick::SouthGravity }
-    assert_nothing_raised { @draw.gravity = Magick::SouthEastGravity }
-    assert_nothing_raised { @draw.gravity = Magick::StaticGravity }
+    Magick::GravityType.values do |gravity|
+      assert_nothing_raised { @draw.gravity = gravity }
+    end
 
     assert_raise(TypeError) { @draw.gravity = 2 }
   end
@@ -215,6 +193,16 @@ class DrawUT < Test::Unit::TestCase
     assert_raise(NoMethodError) { @draw.annotate('x', 0, 0, 0, 20, 'Hello world') }
   end
 
+  def test_annotate_stack_buffer_overflow
+    assert_nothing_raised do
+      if 1.size == 8
+        # 64-bit environment can use larger value for Integer and it can causes stack buffer overflow.
+        img = Magick::Image.new(10, 10)
+        @draw.annotate(img, 2**63, 2**63, 2**62, 2**62, 'Hello world')
+      end
+    end
+  end
+
   def test_dup
     @draw.path('M110,100 h-75 a75,75 0 1,0 75,-75 z')
     @draw.taint
@@ -231,82 +219,10 @@ class DrawUT < Test::Unit::TestCase
   end
 
   def test_composite
-    composite_operators = [
-      Magick::AddCompositeOp,
-      Magick::AtopCompositeOp,
-      Magick::BlendCompositeOp,
-      Magick::BlurCompositeOp,
-      Magick::BumpmapCompositeOp,
-      Magick::ChangeMaskCompositeOp,
-      Magick::ClearCompositeOp,
-      Magick::ColorBurnCompositeOp,
-      Magick::ColorDodgeCompositeOp,
-      Magick::ColorizeCompositeOp,
-      Magick::CopyBlackCompositeOp,
-      Magick::CopyBlueCompositeOp,
-      Magick::CopyCompositeOp,
-      Magick::CopyCyanCompositeOp,
-      Magick::CopyGreenCompositeOp,
-      Magick::CopyMagentaCompositeOp,
-      Magick::CopyOpacityCompositeOp,
-      Magick::CopyRedCompositeOp,
-      Magick::CopyYellowCompositeOp,
-      Magick::DarkenCompositeOp,
-      Magick::DarkenIntensityCompositeOp,
-      Magick::DistortCompositeOp,
-      Magick::DivideCompositeOp,
-      Magick::DivideSrcCompositeOp,
-      Magick::DstAtopCompositeOp,
-      Magick::DstCompositeOp,
-      Magick::DstInCompositeOp,
-      Magick::DstOutCompositeOp,
-      Magick::DstOverCompositeOp,
-      Magick::DifferenceCompositeOp,
-      Magick::DisplaceCompositeOp,
-      Magick::DissolveCompositeOp,
-      Magick::ExclusionCompositeOp,
-      Magick::HardLightCompositeOp,
-      Magick::HueCompositeOp,
-      Magick::InCompositeOp,
-      Magick::LightenCompositeOp,
-      Magick::LightenIntensityCompositeOp,
-      Magick::LinearBurnCompositeOp,
-      Magick::LinearDodgeCompositeOp,
-      Magick::LinearLightCompositeOp,
-      Magick::LuminizeCompositeOp,
-      Magick::MathematicsCompositeOp,
-      Magick::MinusCompositeOp,
-      Magick::MinusSrcCompositeOp,
-      Magick::ModulateCompositeOp,
-      Magick::MultiplyCompositeOp,
-      Magick::NoCompositeOp,
-      Magick::OutCompositeOp,
-      Magick::OverCompositeOp,
-      Magick::OverlayCompositeOp,
-      Magick::PegtopLightCompositeOp,
-      Magick::PinLightCompositeOp,
-      Magick::PlusCompositeOp,
-      Magick::ReplaceCompositeOp,
-      Magick::SaturateCompositeOp,
-      Magick::ScreenCompositeOp,
-      Magick::SoftLightCompositeOp,
-      Magick::SrcAtopCompositeOp,
-      Magick::SrcCompositeOp,
-      Magick::SrcInCompositeOp,
-      Magick::SrcOutCompositeOp,
-      Magick::SrcOverCompositeOp,
-      Magick::SubtractCompositeOp,
-      Magick::ThresholdCompositeOp,
-      Magick::UndefinedCompositeOp,
-      Magick::VividLightCompositeOp,
-      Magick::XorCompositeOp
-    ]
-    composite_operators << Magick::HardMixCompositeOp if Gem::Version.new('6.8.9') <= Gem::Version.new(IM_VERSION)
-
     img = Magick::Image.new(10, 10)
     assert_nothing_raised { @draw.composite(0, 0, 10, 10, img) }
 
-    composite_operators.each do |op|
+    Magick::CompositeOperator.values do |op|
       assert_nothing_raised { @draw.composite(0, 0, 10, 10, img, op) }
     end
 
@@ -317,7 +233,7 @@ class DrawUT < Test::Unit::TestCase
     assert_raise(TypeError) { @draw.composite(0, 0, 10, 10, img, Magick::CenterAlign) }
     assert_raise(NoMethodError) { @draw.composite(0, 0, 10, 10, 'image') }
     assert_raise(ArgumentError) { @draw.composite(0, 0, 10, 10) }
-    assert_raise(ArgumentError) { @draw.composite(0, 0, 10, 10, img, Magick::AddCompositeOp, 'x') }
+    assert_raise(ArgumentError) { @draw.composite(0, 0, 10, 10, img, Magick::ModulusAddCompositeOp, 'x') }
   end
 
   def test_draw
@@ -411,4 +327,25 @@ class DrawUT < Test::Unit::TestCase
       assert_instance_of(Magick::Image::DrawOptions, yield_obj)
     end
   end
+
+  def test_issue_604
+    points = [0, 0, 1, 1, 2, 2]
+
+    pr = Magick::Draw.new
+
+    pr.define_clip_path('example') do
+      pr.polygon(*points)
+    end
+
+    pr.push
+    pr.clip_path('example')
+
+    composite = Magick::Image.new(10, 10)
+    pr.composite(0, 0, 10, 10, composite)
+
+    pr.pop
+
+    canvas = Magick::Image.new(10, 10)
+    pr.draw(canvas)
+  end
 end

data/test/Enum.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 EnumUT < Test::Unit::TestCase
   def test_new
@@ -73,4 +73,156 @@ class EnumUT < Test::Unit::TestCase
   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