rmagick 4.1.0.rc2 → 4.1.0

data/spec/rmagick/image/blue_shift_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe Magick::Image, '#blue_shift' do
-  let(:img) { Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first }
-
-  it 'returns a new Image' do
-    res = img.blue_shift
-    expect(res).to be_instance_of(Magick::Image)
-    expect(res).not_to eq img
-  end
-
-  it 'accepts one argument' do
-    expect { img.blue_shift(2) }.not_to raise_error
-    expect { img.blue_shift(2, 3) }.to raise_error(ArgumentError)
-  end
-end

data/spec/rmagick/image/channel_entropy_spec.rb

@@ -1,9 +0,0 @@
-RSpec.describe Magick::Image, '#channel_entropy' do
-  let(:img) { Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first }
-
-  it 'returns a channel entropy', supported_after('6.9.0') do
-    res = img.channel_entropy
-    puts "res = #{res.inspect}"
-    expect(res).to eq([0.5285857222715863])
-  end
-end

data/spec/rmagick/image/composite_spec.rb

@@ -1,72 +0,0 @@
-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 }
-
-  it 'raises an error given invalid arguments' do
-    expect { img1.composite }.to raise_error(ArgumentError)
-    expect { img1.composite(img2) }.to raise_error(ArgumentError)
-    expect do
-      img1.composite(img2, Magick::NorthWestGravity)
-    end.to raise_error(ArgumentError)
-    expect { img1.composite(2) }.to raise_error(ArgumentError)
-    expect { img1.composite(img2, 2) }.to raise_error(ArgumentError)
-  end
-
-  context 'when given 3 arguments' do
-    it 'works when 2nd argument is a gravity' do
-      Magick::CompositeOperator.values do |op|
-        Magick::GravityType.values do |grav|
-          expect { img1.composite(img2, grav, op) }.not_to raise_error
-        end
-      end
-    end
-
-    it 'raises an error when 2nd argument is not a gravity' do
-      expect do
-        img1.composite(img2, 2, Magick::OverCompositeOp)
-      end.to raise_error(TypeError)
-    end
-  end
-
-  context 'when given 4 arguments' 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
-      Magick::CompositeOperator.values do |op|
-        expect { img1.composite(img2, 0, 0, op) }.not_to raise_error
-      end
-    end
-
-    it 'returns a new Magick::Image object' do
-      res = img1.composite(img2, 0, 0, Magick::OverCompositeOp)
-      expect(res).to be_instance_of(Magick::Image)
-    end
-
-    it 'raises an error when 4th argument is not a composite operator' do
-      expect { img1.composite(img2, 0, 0, 2) }.to raise_error(TypeError)
-    end
-  end
-
-  context 'when given 5 arguments' do
-    it 'works when 2nd argument is gravity and 5th is a composite operator' do
-      Magick::CompositeOperator.values do |op|
-        Magick::GravityType.values do |grav|
-          expect { img1.composite(img2, grav, 0, 0, op) }.not_to raise_error
-        end
-      end
-    end
-
-    it 'raises an error when 2nd argument is not a gravity' do
-      expect do
-        img1.composite(img2, 0, 0, 2, Magick::OverCompositeOp)
-      end.to raise_error(TypeError)
-    end
-  end
-
-  it 'raises an error when the image has been destroyed' do
-    img2.destroy!
-    expect do
-      img1.composite(img2, Magick::CenterGravity, Magick::OverCompositeOp)
-    end.to raise_error(Magick::DestroyedImageError)
-  end
-end

data/spec/rmagick/image/constitute_spec.rb

@@ -1,13 +0,0 @@
-RSpec.describe Magick::Image, '#constitute' do
-  let(:img) { Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first }
-  let(:pixels) { img.dispatch(0, 0, img.columns, img.rows, 'RGBA') }
-
-  it 'returns an equivalent image to the given pixels' do
-    res = Magick::Image.constitute(img.columns, img.rows, 'RGBA', pixels)
-    # The constituted image is in MIFF format so we
-    # can't compare it directly to the original image.
-    expect(res.columns).to eq img.columns
-    expect(res.rows).to eq img.rows
-    expect(pixels.all? { |v| v >= 0 && v <= Magick::QuantumRange }).to be true
-  end
-end

data/spec/rmagick/image/dispatch_spec.rb

@@ -1,16 +0,0 @@
-RSpec.describe Magick::Image, '#dispatch' do
-  let(:img) { Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first }
-
-  it 'expects exactly 5 or 6 arguments' do
-    expect { img.dispatch }.to raise_error(ArgumentError)
-    expect { img.dispatch(0) }.to raise_error(ArgumentError)
-    expect { img.dispatch(0, 0) }.to raise_error(ArgumentError)
-    expect { img.dispatch(0, 0, img.columns) }.to raise_error(ArgumentError)
-    expect do
-      img.dispatch(0, 0, img.columns, img.rows)
-    end.to raise_error(ArgumentError)
-    expect do
-      img.dispatch(0, 0, 20, 20, 'RGBA', false, false)
-    end.to raise_error(ArgumentError)
-  end
-end

data/spec/rmagick/image/dissolve_spec.rb

@@ -1,54 +0,0 @@
-RSpec.describe Magick::Image, '#dissolve' do
-  let(:img1) { Magick::Image.new(100, 100) { self.background_color = 'transparent' } }
-  let(:img2) { Magick::Image.new(100, 100) { self.background_color = 'green' }       }
-
-  it 'raises an error given invalid arguments' do
-    expect { img1.dissolve }.to raise_error(ArgumentError)
-    expect { img1.dissolve(img2, 'x') }.to raise_error(ArgumentError)
-    expect { img1.dissolve(img2, 0.50, 'x') }.to raise_error(ArgumentError)
-    expect { img1.dissolve(img2, 0.50, Magick::NorthEastGravity, 'x') }.to raise_error(TypeError)
-    expect { img1.dissolve(img2, 0.50, Magick::NorthEastGravity, 10, 'x') }.to raise_error(TypeError)
-  end
-
-  context 'when given 2 arguments' do
-    it 'works when alpha is float 0.0 to 1.0' do
-      dissolved = img1.dissolve(img2, 0.50)
-      expect(dissolved).to be_instance_of(Magick::Image)
-      expect(Float(dissolved.pixel_color(2, 2).alpha) / Magick::QuantumRange).to be_between(0.45, 0.55)
-      dissolved = img1.dissolve(img2, 0.20)
-      expect(Float(dissolved.pixel_color(2, 2).alpha) / Magick::QuantumRange).to be_between(0.15, 0.25)
-    end
-    it 'works when alpha is string percentage' do
-      dissolved = img1.dissolve(img2, '50%')
-      expect(dissolved).to be_instance_of(Magick::Image)
-      expect(Float(dissolved.pixel_color(2, 2).alpha) / Magick::QuantumRange).to be_between(0.45, 0.55)
-      dissolved = img1.dissolve(img2, '20%')
-      expect(Float(dissolved.pixel_color(2, 2).alpha) / Magick::QuantumRange).to be_between(0.15, 0.25)
-    end
-  end
-
-  context 'when given gravity' do
-    # generate an image to use with gravity
-    wk = Magick::Image.new(40, 40) { self.background_color = 'transparent' }
-    d = Magick::Draw.new
-    d.stroke('none').fill('blue')
-    d.circle(wk.columns / 2, wk.rows / 2, 4, wk.rows / 2)
-    d.draw(wk)
-
-    it 'works on colored background' do
-      # generate an image to use with gravity
-      dissolved = img2.dissolve(wk, 0.50, 1.0, Magick::CenterGravity)
-      expect(dissolved).to be_instance_of(Magick::Image)
-      expect(dissolved.pixel_color(10, 10)).to eq(img2.pixel_color(10, 10))
-      expect(Float(dissolved.pixel_color(50, 50).blue) / Magick::QuantumRange).to be_between(0.45, 0.55)
-      expect(Float(dissolved.pixel_color(50, 50).green)).to be_between(0, img2.pixel_color(2, 2).green).exclusive
-    end
-  end
-
-  # still need to test with destination percentage, offsets
-
-  it 'raises an error when the image has been destroyed' do
-    img1.destroy!
-    expect { img1.dissolve(img2, 0.50) }.to raise_error(Magick::DestroyedImageError)
-  end
-end

data/spec/rmagick/image/from_blob_spec.rb

@@ -1,12 +0,0 @@
-RSpec.describe Magick::Image, '#from_blob' do
-  let(:img) { Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first }
-  let(:blob) { img.to_blob }
-
-  it 'returns an image equal to the original' do
-    expect(blob).to be_instance_of(String)
-    res = Magick::Image.from_blob(blob)
-    expect(res).to be_instance_of(Array)
-    expect(res.first).to be_instance_of(Magick::Image)
-    expect(res.first).to eq img
-  end
-end

data/spec/rmagick/image/ping_spec.rb

@@ -1,12 +0,0 @@
-RSpec.describe Magick::Image, '#ping' do
-  it 'returns an image from the source, omitting pixel data' do
-    res = Magick::Image.ping(IMAGES_DIR + '/Button_0.gif')
-    expect(res).to be_instance_of(Array)
-    image = res.first
-    expect(image).to be_instance_of(Magick::Image)
-    expect(image.format).to eq 'GIF'
-    expect(image.columns).to eq 127
-    expect(image.rows).to eq 120
-    expect(image.filename).to match(/Button_0.gif/)
-  end
-end

data/spec/rmagick/image/properties_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe Magick::Image, '#properties' do
-  let(:img) { Magick::Image.new(20, 20) }
-  let(:freeze_error) { RuntimeError }
-
-  before(:each) do
-    img['comment'] = 'str_1'
-    img['label'] = 'str_2'
-    img['jpeg:sampling-factor'] = '2x1,1x1,1x1'
-  end
-
-  it 'allows assignment of arbitrary properties' do
-    expect(img['comment']).to eq 'str_1'
-    expect(img['label']).to eq 'str_2'
-    expect(img['jpeg:sampling-factor']).to eq '2x1,1x1,1x1'
-    expect(img['d']).to be nil
-  end
-
-  it 'returns a hash of assigned properties' do
-    expected_properties = { 'comment' => 'str_1', 'label' => 'str_2', 'jpeg:sampling-factor' => '2x1,1x1,1x1' }
-    expect(img.properties).to eq(expected_properties)
-  end
-
-  it 'raises an error when trying to assign properties to a frozen image' do
-    img.freeze
-    expect { img['comment'] = 'str_4' }.to raise_error(freeze_error)
-  end
-end

data/spec/rmagick/image/read_spec.rb

@@ -1,28 +0,0 @@
-require 'timeout'
-
-RSpec.describe Magick::Image, '#read' do
-  describe 'issue #200' do
-    before do
-      # pid = Process.spawn File.join(SUPPORT_DIR, 'issue_200', 'app.rb'), err: :close, out: :close
-      # begin
-      #   Timeout.timeout(1) do
-      #     _, @status = Process.waitpid2 pid
-      #   end
-      # rescue Timeout::Error
-      #   Process.kill('KILL', pid)
-      #   _, @status = Process.waitpid2 pid
-      # end
-    end
-
-    it 'not hangs with nil argument' do
-      skip
-      expect(@status.signaled?).to be_falsey
-    end
-
-    it 'raise error with nil argument' do
-      skip
-      expect(@status.success?).to be_truthy
-      expect { Magick::Image.read(nil) }.to raise_error(Magick::ImageMagickError, /unable to open image nil/)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,9 +0,0 @@
-require 'rmagick'
-
-root_dir = File.expand_path('..', __dir__)
-IMAGES_DIR = File.join(root_dir, 'doc/ex/images')
-SUPPORT_DIR = File.join(root_dir, 'spec', 'support')
-
-def supported_after(version)
-  :skip if Gem::Version.new(Magick::IMAGEMAGICK_VERSION) < Gem::Version.new(version)
-end

data/spec/support/issue_200/app.rb

@@ -1,8 +0,0 @@
-#!/usr/bin/env ruby
-require 'rmagick'
-
-begin
-  Magick::Image.read(nil)
-rescue StandardError
-  nil
-end

data/test/Draw.rb

@@ -1,351 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class DrawUT < Test::Unit::TestCase
-  def setup
-    @draw = Magick::Draw.new
-  end
-
-  def test_affine
-    assert_nothing_raised do
-      @draw.affine = Magick::AffineMatrix.new(1, 2, 3, 4, 5, 6)
-    end
-    assert_raise(TypeError) { @draw.affine = [1, 2, 3, 4, 5, 6] }
-  end
-
-  def test_align
-    Magick::AlignType.values do |align|
-      assert_nothing_raised { @draw.align = align }
-    end
-  end
-
-  def test_decorate
-    Magick::DecorationType.values do |decoration|
-      assert_nothing_raised { @draw.decorate = decoration }
-    end
-  end
-
-  def test_density
-    assert_nothing_raised { @draw.density = '90x90' }
-    assert_nothing_raised { @draw.density = 'x90' }
-    assert_nothing_raised { @draw.density = '90' }
-    assert_raise(TypeError) { @draw.density = 2 }
-  end
-
-  def test_encoding
-    assert_nothing_raised { @draw.encoding = 'AdobeCustom' }
-    assert_raise(TypeError) { @draw.encoding = 2 }
-  end
-
-  def test_fill
-    assert_nothing_raised { @draw.fill = 'white' }
-    assert_nothing_raised { @draw.fill = Magick::Pixel.from_color('white') }
-    assert_raise(TypeError) { @draw.fill = 2 }
-  end
-
-  def test_fill_pattern
-    assert_nothing_raised { @draw.fill_pattern = nil }
-    assert_nothing_raised do
-      img1 = Magick::Image.new(10, 10)
-      img2 = Magick::Image.new(20, 20)
-
-      @draw.fill_pattern = img1
-      @draw.fill_pattern = img2
-    end
-
-    assert_raise(NoMethodError) { @draw.fill_pattern = 'x' }
-  end
-
-  def test_font
-    assert_nothing_raised { @draw.font = 'Arial-Bold' }
-    assert_raise(TypeError) { @draw.font = 2 }
-  end
-
-  def test_font_family
-    assert_nothing_raised { @draw.font_family = 'Arial' }
-    assert_raise(TypeError) { @draw.font_family = 2 }
-  end
-
-  def test_font_stretch
-    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
-    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
-    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
-    Magick::GravityType.values do |gravity|
-      assert_nothing_raised { @draw.gravity = gravity }
-    end
-
-    assert_raise(TypeError) { @draw.gravity = 2 }
-  end
-
-  def test_interline_spacing
-    assert_nothing_raised { @draw.interline_spacing = 2 }
-    assert_raise(TypeError) { @draw.interline_spacing = 'x' }
-  end
-
-  def test_interword_spacing
-    assert_nothing_raised { @draw.interword_spacing = 2 }
-    assert_raise(TypeError) { @draw.interword_spacing = 'x' }
-  end
-
-  def test_kerning
-    assert_nothing_raised { @draw.kerning = 2 }
-    assert_raise(TypeError) { @draw.kerning = 'x' }
-  end
-
-  def test_pointsize
-    assert_nothing_raised { @draw.pointsize = 2 }
-    assert_raise(TypeError) { @draw.pointsize = 'x' }
-  end
-
-  def test_rotation
-    assert_nothing_raised { @draw.rotation = 15 }
-    assert_raise(TypeError) { @draw.rotation = 'x' }
-  end
-
-  def test_stroke
-    assert_nothing_raised { @draw.stroke = Magick::Pixel.from_color('white') }
-    assert_nothing_raised { @draw.stroke = 'white' }
-    assert_raise(TypeError) { @draw.stroke = 2 }
-  end
-
-  def test_stroke_pattern
-    assert_nothing_raised { @draw.stroke_pattern = nil }
-    assert_nothing_raised do
-      img1 = Magick::Image.new(10, 10)
-      img2 = Magick::Image.new(20, 20)
-
-      @draw.stroke_pattern = img1
-      @draw.stroke_pattern = img2
-    end
-
-    assert_raise(NoMethodError) { @draw.stroke_pattern = 'x' }
-  end
-
-  def test_stroke_width
-    assert_nothing_raised { @draw.stroke_width = 15 }
-    assert_raise(TypeError) { @draw.stroke_width = 'x' }
-  end
-
-  def test_text_antialias
-    assert_nothing_raised { @draw.text_antialias = true }
-    assert_nothing_raised { @draw.text_antialias = false }
-  end
-
-  def test_tile
-    assert_nothing_raised { @draw.tile = nil }
-    assert_nothing_raised do
-      img1 = Magick::Image.new(10, 10)
-      img2 = Magick::Image.new(20, 20)
-
-      @draw.tile = img1
-      @draw.tile = img2
-    end
-  end
-
-  def test_undercolor
-    assert_nothing_raised { @draw.undercolor = Magick::Pixel.from_color('white') }
-    assert_nothing_raised { @draw.undercolor = 'white' }
-    assert_raise(TypeError) { @draw.undercolor = 2 }
-  end
-
-  def test_annotate
-    assert_nothing_raised do
-      img = Magick::Image.new(10, 10)
-      @draw.annotate(img, 0, 0, 0, 20, 'Hello world')
-
-      yield_obj = nil
-      @draw.annotate(img, 100, 100, 20, 20, 'Hello world 2') do |draw|
-        yield_obj = draw
-      end
-      assert_instance_of(Magick::Draw, yield_obj)
-    end
-
-    assert_raise(TypeError) do
-      img = Magick::Image.new(10, 10)
-      @draw.annotate(img, 0, 0, 0, 20, nil)
-    end
-
-    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
-    @draw.freeze
-    dup = @draw.dup
-    assert_instance_of(Magick::Draw, dup)
-  end
-
-  def test_clone
-    @draw.taint
-    @draw.freeze
-    clone = @draw.clone
-    assert_instance_of(Magick::Draw, clone)
-  end
-
-  def test_composite
-    img = Magick::Image.new(10, 10)
-    assert_nothing_raised { @draw.composite(0, 0, 10, 10, img) }
-
-    Magick::CompositeOperator.values do |op|
-      assert_nothing_raised { @draw.composite(0, 0, 10, 10, img, op) }
-    end
-
-    assert_raise(TypeError) { @draw.composite('x', 0, 10, 10, img) }
-    assert_raise(TypeError) { @draw.composite(0, 'y', 10, 10, img) }
-    assert_raise(TypeError) { @draw.composite(0, 0, 'w', 10, img) }
-    assert_raise(TypeError) { @draw.composite(0, 0, 10, 'h', img) }
-    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::ModulusAddCompositeOp, 'x') }
-  end
-
-  def test_draw
-    draw = @draw.dup
-
-    img = Magick::Image.new(10, 10)
-    @draw.path('M110,100 h-75 a75,75 0 1,0 75,-75 z')
-    assert_nothing_raised { @draw.draw(img) }
-
-    assert_raise(ArgumentError) { draw.draw(img) }
-    assert_raise(NoMethodError) { draw.draw('x') }
-  end
-
-  def test_get_type_metrics
-    img = Magick::Image.new(10, 10)
-    assert_nothing_raised { @draw.get_type_metrics('ABCDEF') }
-    assert_nothing_raised { @draw.get_type_metrics(img, 'ABCDEF') }
-
-    assert_raise(ArgumentError) { @draw.get_type_metrics }
-    assert_raise(ArgumentError) { @draw.get_type_metrics(img, 'ABCDEF', 20) }
-    assert_raise(ArgumentError) { @draw.get_type_metrics(img, '') }
-    assert_raise(NoMethodError) { @draw.get_type_metrics('x', 'ABCDEF') }
-  end
-
-  def test_get_multiline_type_metrics
-    img = Magick::Image.new(10, 10)
-    assert_nothing_raised { @draw.get_multiline_type_metrics('ABCDEF') }
-    assert_nothing_raised { @draw.get_multiline_type_metrics(img, 'ABCDEF') }
-
-    assert_raise(ArgumentError) { @draw.get_multiline_type_metrics }
-    assert_raise(ArgumentError) { @draw.get_multiline_type_metrics(img, 'ABCDEF', 20) }
-    assert_raise(ArgumentError) { @draw.get_multiline_type_metrics(img, '') }
-  end
-
-  def test_inspect
-    assert_equal('(no primitives defined)', @draw.inspect)
-
-    @draw.path('M110,100 h-75 a75,75 0 1,0 75,-75 z')
-    @draw.fill('yellow')
-    assert_equal("path 'M110,100 h-75 a75,75 0 1,0 75,-75 z'\nfill \"yellow\"", @draw.inspect)
-  end
-
-  def test_marshal
-    draw = @draw.dup
-    draw.affine = Magick::AffineMatrix.new(1, 2, 3, 4, 5, 6)
-    draw.decorate = Magick::LineThroughDecoration
-    draw.encoding = 'AdobeCustom'
-    draw.gravity = Magick::CenterGravity
-    draw.fill = Magick::Pixel.from_color('red')
-    draw.fill_pattern = Magick::Image.new(10, 10) { self.format = 'miff' }
-    draw.stroke = Magick::Pixel.from_color('blue')
-    draw.stroke_width = 5
-    draw.text_antialias = true
-    draw.font = 'Arial-Bold'
-    draw.font_family = 'arial'
-    draw.font_style = Magick::ItalicStyle
-    draw.font_stretch = Magick::CondensedStretch
-    draw.font_weight = Magick::BoldWeight
-    draw.pointsize = 12
-    draw.density = '72x72'
-    draw.align = Magick::CenterAlign
-    draw.undercolor = Magick::Pixel.from_color('green')
-    draw.kerning = 10.5
-    draw.interword_spacing = 3.75
-
-    draw.circle(20, 25, 20, 28)
-
-    dumped = nil
-    assert_nothing_raised { dumped = draw.marshal_dump }
-
-    draw2 = @draw.dup
-    assert_nothing_raised do
-      draw2.marshal_load(dumped)
-    end
-    assert_equal(draw.inspect, draw2.inspect)
-  end
-
-  def test_primitive
-    assert_nothing_raised { @draw.primitive('ABCDEF') }
-    assert_nothing_raised { @draw.primitive('12345') }
-    assert_raise(TypeError) { @draw.primitive(nil) }
-  end
-
-  def test_draw_options
-    assert_nothing_raised do
-      yield_obj = nil
-
-      Magick::Draw.new do |option|
-        yield_obj = option
-      end
-      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