rmagick 4.1.0.rc2 → 4.1.0

data/test/PolaroidOptions.rb

@@ -1,23 +0,0 @@
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class PolaroidOptionsUT < Test::Unit::TestCase
-  def setup
-    @options = Magick::Image::PolaroidOptions.new
-  end
-
-  def test_shadow_color
-    assert_nothing_raised { @options.shadow_color = "gray50" }
-
-    @options.freeze
-    assert_raise(FreezeError) { @options.shadow_color = "gray50" }
-  end
-
-  def test_border_color
-    assert_nothing_raised { @options.border_color = "gray50" }
-
-    @options.freeze
-    assert_raise(FreezeError) { @options.border_color = "gray50" }
-  end
-end

data/test/Preview.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class PreviewUT < Test::Unit::TestCase
-  def test_preview
-    hat = Magick::Image.read(IMAGES_DIR + '/Flower_Hat.jpg').first
-    assert_nothing_raised do
-      prev = hat.preview(Magick::RotatePreview)
-      assert_instance_of(Magick::Image, prev)
-    end
-    puts "\n"
-    Magick::PreviewType.values do |type|
-      puts "testing #{type}..."
-      assert_nothing_raised { hat.preview(type) }
-    end
-    assert_raise(TypeError) { hat.preview(2) }
-  end
-end
-
-if $PROGRAM_NAME == __FILE__
-  IMAGES_DIR = '../doc/ex/images'
-  Test::Unit::UI::Console::TestRunner.run(PreviewUT)
-end

data/test/Struct.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class StructUT < Test::Unit::TestCase
-  def test_chromaticity_to_s
-    image = Magick::Image.new(10, 10)
-    assert_match(/red_primary=\(x=.+,y=.+\) green_primary=\(x=.+,y=.+\) blue_primary=\(x=.+,y=.+\) white_point=\(x=.+,y=.+\)/, image.chromaticity.to_s)
-  end
-
-  def test_export_color_info
-    color = Magick.colors[0]
-    assert_instance_of(Magick::Color, color)
-    assert_match(/name=.+, compliance=.+, color.red=.+, color.green=.+, color.blue=.+, color.alpha=.+/, color.to_s)
-  end
-
-  def test_export_type_info
-    font = Magick.fonts[0]
-    assert_match(/^name=.+, description=.+, family=.+, style=.+, stretch=.+, weight=.+, encoding=.*, foundry=.*, format=.*$/, font.to_s)
-  end
-
-  def test_export_point_info
-    draw = Magick::Draw.new
-    metric = draw.get_type_metrics('ABCDEF')
-    assert_match(/^pixels_per_em=\(x=.+,y=.+\) ascent=.+ descent=.+ width=.+ height=.+ max_advance=.+ bounds.x1=.+ bounds.y1=.+ bounds.x2=.+ bounds.y2=.+ underline_position=.+ underline_thickness=.+$/, metric.to_s)
-  end
-
-  def test_primary_info_to_s
-    chrom = Magick::Image.new(10, 10).chromaticity
-    red_primary = chrom.red_primary
-    assert_match(/^x=.+, y=.+, z=.+$/, red_primary.to_s)
-  end
-
-  def test_rectangle_info_to_s
-    rect = Magick::Rectangle.new(10, 20, 30, 40)
-    assert_equal('width=10, height=20, x=30, y=40', rect.to_s)
-  end
-
-  def test_segment_info_to_s
-    segment = Magick::Segment.new(10, 20, 30, 40)
-    assert_equal('x1=10, y1=20, x2=30, y2=40', segment.to_s)
-  end
-end

data/test/appearance/Montage.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-require_relative 'appearance_assertion'
-
-class AppearanceMontageUT < Test::Unit::TestCase
-  include AppearanceAssertion
-
-  def test_color
-    imagelist = Magick::ImageList.new(IMAGES_DIR + '/Flower_Hat.jpg')
-
-    new_imagelist = imagelist.montage do
-      self.border_width = 100
-      self.border_color = 'red'
-      self.background_color = 'blue'
-      self.matte_color = 'yellow'
-      self.frame = '10x10'
-      self.gravity = Magick::CenterGravity
-    end
-
-    # montage ../../doc/ex/images/Flower_Hat.jpg -border 100x -bordercolor red -mattecolor yellow -background blue -frame 10x10 -gravity Center expected/montage_border_color.jpg
-    assert_same_image('expected/montage_border_color.jpg', new_imagelist.first)
-  end
-end

data/test/appearance/appearance_assertion.rb

@@ -1,13 +0,0 @@
-require 'test/unit'
-
-module AppearanceAssertion
-  include Test::Unit::Assertions
-
-  def assert_same_image(expected_image_path, image_object, delta: 0.01)
-    path = File.expand_path(File.join(__dir__, expected_image_path))
-
-    expected = Magick::Image.read(path).first
-    _, error = expected.compare_channel(image_object, Magick::MeanSquaredErrorMetric)
-    assert_in_delta(0.0, error, delta)
-  end
-end

data/test/lib/internal/Draw.rb

@@ -1,811 +0,0 @@
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class LibDrawUT < Test::Unit::TestCase
-  def setup
-    @draw = Magick::Draw.new
-    @img = Magick::Image.new(200, 200)
-  end
-
-  def test_affine
-    @draw.affine(10.5, 12, 15, 20, 22, 25)
-    assert_equal('affine 10.5,12,15,20,22,25', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.affine('x', 12, 15, 20, 22, 25) }
-    assert_raise(ArgumentError) { @draw.affine(10, 'x', 15, 20, 22, 25) }
-    assert_raise(ArgumentError) { @draw.affine(10, 12, 'x', 20, 22, 25) }
-    assert_raise(ArgumentError) { @draw.affine(10, 12, 15, 'x', 22, 25) }
-    assert_raise(ArgumentError) { @draw.affine(10, 12, 15, 20, 'x', 25) }
-    assert_raise(ArgumentError) { @draw.affine(10, 12, 15, 20, 22, 'x') }
-  end
-
-  def test_alpha
-    Magick::PaintMethod.values do |method|
-      draw = Magick::Draw.new
-      draw.alpha(10, '20.5', method)
-      assert_nothing_raised { draw.draw(@img) }
-    end
-
-    assert_raise(ArgumentError) { @draw.alpha(10, '20.5', 'xxx') }
-    assert_raise(ArgumentError) { @draw.alpha('x', 10, Magick::PointMethod) }
-    assert_raise(ArgumentError) { @draw.alpha(10, 'x', Magick::PointMethod) }
-  end
-
-  def test_arc
-    @draw.arc(100.5, 120.5, 200, 250, 20, 370)
-    assert_equal('arc 100.5,120.5 200,250 20,370', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.arc('x', 120.5, 200, 250, 20, 370) }
-    assert_raise(ArgumentError) { @draw.arc(100.5, 'x', 200, 250, 20, 370) }
-    assert_raise(ArgumentError) { @draw.arc(100.5, 120.5, 'x', 250, 20, 370) }
-    assert_raise(ArgumentError) { @draw.arc(100.5, 120.5, 200, 'x', 20, 370) }
-    assert_raise(ArgumentError) { @draw.arc(100.5, 120.5, 200, 250, 'x', 370) }
-    assert_raise(ArgumentError) { @draw.arc(100.5, 120.5, 200, 250, 20, 'x') }
-  end
-
-  def test_bezier
-    @draw.bezier(10, '20', '20.5', 30, 40.5, 50)
-    assert_equal('bezier 10,20,20.5,30,40.5,50', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.bezier }
-    assert_raise(ArgumentError) { @draw.bezier(1) }
-    assert_raise(ArgumentError) { @draw.bezier('x', 20, 30, 40.5) }
-  end
-
-  def test_circle
-    @draw.circle(10, '20.5', 30, 40.5)
-    assert_equal('circle 10,20.5 30,40.5', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.circle('x', 20, 30, 40) }
-    assert_raise(ArgumentError) { @draw.circle(10, 'x', 30, 40) }
-    assert_raise(ArgumentError) { @draw.circle(10, 20, 'x', 40) }
-    assert_raise(ArgumentError) { @draw.circle(10, 20, 30, 'x') }
-  end
-
-  def test_clip_path
-    @draw.clip_path('test')
-    assert_equal('clip-path test', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-  end
-
-  def test_clip_rule
-    draw = Magick::Draw.new
-    draw.clip_rule('evenodd')
-    assert_equal('clip-rule evenodd', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.clip_rule('nonzero')
-    assert_equal('clip-rule nonzero', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.clip_rule('foo') }
-  end
-
-  def test_clip_units
-    draw = Magick::Draw.new
-    draw.clip_units('userspace')
-    assert_equal('clip-units userspace', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.clip_units('userspaceonuse')
-    assert_equal('clip-units userspaceonuse', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.clip_units('objectboundingbox')
-    assert_equal('clip-units objectboundingbox', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.clip_units('foo') }
-  end
-
-  def test_color
-    draw = Magick::Draw.new
-    draw.color(50.5, 50, Magick::PointMethod)
-    assert_equal('color 50.5,50,point', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.color(50.5, 50, Magick::ReplaceMethod)
-    assert_equal('color 50.5,50,replace', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.color(50.5, 50, Magick::FloodfillMethod)
-    assert_equal('color 50.5,50,floodfill', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.color(50.5, 50, Magick::FillToBorderMethod)
-    assert_equal('color 50.5,50,filltoborder', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.color(50.5, 50, Magick::ResetMethod)
-    assert_equal('color 50.5,50,reset', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.color(10, 20, 'unknown') }
-    assert_raise(ArgumentError) { @draw.color('x', 20, Magick::PointMethod) }
-    assert_raise(ArgumentError) { @draw.color(10, 'x', Magick::PointMethod) }
-  end
-
-  def test_decorate
-    draw = Magick::Draw.new
-    draw.decorate(Magick::NoDecoration)
-    assert_equal('decorate none', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.decorate(Magick::UnderlineDecoration)
-    assert_equal('decorate underline', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.decorate(Magick::OverlineDecoration)
-    assert_equal('decorate overline', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.decorate(Magick::OverlineDecoration)
-    assert_equal('decorate overline', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    # draw = Magick::Draw.new
-    # draw.decorate('tomato')
-    # assert_equal('decorate "tomato"', draw.inspect)
-    # draw.text(50, 50, 'Hello world')
-    # assert_nothing_raised { draw.draw(@img) }
-  end
-
-  def test_define_clip_path
-    assert_nothing_raised { @draw.define_clip_path('test') { @draw } }
-    assert_equal("push defs\npush clip-path \"test\"\npush graphic-context\npop graphic-context\npop clip-path\npop defs", @draw.inspect)
-  end
-
-  def test_ellipse
-    @draw.ellipse(50.5, 30, 25, 25, 60, 120)
-    assert_equal('ellipse 50.5,30 25,25 60,120', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.ellipse('x', 20, 30, 40, 50, 60) }
-    assert_raise(ArgumentError) { @draw.ellipse(10, 'x', 30, 40, 50, 60) }
-    assert_raise(ArgumentError) { @draw.ellipse(10, 20, 'x', 40, 50, 60) }
-    assert_raise(ArgumentError) { @draw.ellipse(10, 20, 30, 'x', 50, 60) }
-    assert_raise(ArgumentError) { @draw.ellipse(10, 20, 30, 40, 'x', 60) }
-    assert_raise(ArgumentError) { @draw.ellipse(10, 20, 30, 40, 50, 'x') }
-  end
-
-  def test_encoding
-    @draw.encoding('UTF-8')
-    assert_equal('encoding UTF-8', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-  end
-
-  def test_fill
-    draw = Magick::Draw.new
-    draw.fill('tomato')
-    assert_equal('fill "tomato"', draw.inspect)
-    draw.circle(10, '20.5', 30, 40.5)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.fill_color('tomato')
-    assert_equal('fill "tomato"', draw.inspect)
-    draw.circle(10, '20.5', 30, 40.5)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.fill_pattern('tomato')
-    assert_equal('fill "tomato"', draw.inspect)
-    draw.circle(10, '20.5', 30, 40.5)
-    assert_nothing_raised { draw.draw(@img) }
-
-    # draw = Magick::Draw.new
-    # draw.fill_pattern('foo')
-    # assert_nothing_raised { draw.draw(@img) }
-  end
-
-  def test_fill_opacity
-    draw = Magick::Draw.new
-    draw.fill_opacity(0.5)
-    assert_equal('fill-opacity 0.5', draw.inspect)
-    draw.circle(10, '20.5', 30, 40.5)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.fill_opacity('50%')
-    assert_equal('fill-opacity 50%', draw.inspect)
-    draw.circle(10, '20.5', 30, 40.5)
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_nothing_raised { @draw.fill_opacity(0.0) }
-    assert_nothing_raised { @draw.fill_opacity(1.0) }
-    assert_nothing_raised { @draw.fill_opacity('0.0') }
-    assert_nothing_raised { @draw.fill_opacity('1.0') }
-    assert_nothing_raised { @draw.fill_opacity('20%') }
-
-    assert_raise(ArgumentError) { @draw.fill_opacity(-0.01) }
-    assert_raise(ArgumentError) { @draw.fill_opacity(1.01) }
-    assert_raise(ArgumentError) { @draw.fill_opacity('-0.01') }
-    assert_raise(ArgumentError) { @draw.fill_opacity('1.01') }
-    assert_raise(ArgumentError) { @draw.fill_opacity('xxx') }
-  end
-
-  def test_fill_rule
-    draw = Magick::Draw.new
-    draw.fill_rule('evenodd')
-    assert_equal('fill-rule evenodd', draw.inspect)
-    draw.circle(10, '20.5', 30, 40.5)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.fill_rule('nonzero')
-    assert_equal('fill-rule nonzero', draw.inspect)
-    draw.circle(10, '20.5', 30, 40.5)
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.fill_rule('zero') }
-  end
-
-  def test_font
-    draw = Magick::Draw.new
-    draw.font('Arial')
-    assert_equal("font 'Arial'", draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-  end
-
-  def test_font_family
-    draw = Magick::Draw.new
-    draw.font_family('sans-serif')
-    assert_equal("font-family 'sans-serif'", draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-  end
-
-  def test_font_stretch
-    Magick::StretchType.values do |stretch|
-      next if stretch == Magick::AnyStretch
-
-      draw = Magick::Draw.new
-      draw.font_stretch(stretch)
-      draw.text(50, 50, 'Hello world')
-      assert_nothing_raised { draw.draw(@img) }
-    end
-
-    assert_raise(ArgumentError) { @draw.font_stretch('xxx') }
-  end
-
-  def test_font_style
-    draw = Magick::Draw.new
-    draw.font_style(Magick::NormalStyle)
-    assert_equal('font-style normal', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.font_style(Magick::ItalicStyle)
-    assert_equal('font-style italic', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.font_style(Magick::ObliqueStyle)
-    assert_equal('font-style oblique', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.font_style('xxx') }
-  end
-
-  def test_font_weight
-    Magick::WeightType.values do |weight|
-      draw = Magick::Draw.new
-      draw.font_weight(weight)
-      draw.text(50, 50, 'Hello world')
-      assert_nothing_raised { draw.draw(@img) }
-    end
-
-    draw = Magick::Draw.new
-    draw.font_weight(400)
-    assert_equal('font-weight 400', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.font_weight('xxx') }
-  end
-
-  def test_gravity
-    Magick::GravityType.values do |gravity|
-      next if [Magick::UndefinedGravity].include?(gravity)
-
-      draw = Magick::Draw.new
-      draw.gravity(gravity)
-      draw.circle(10, '20.5', 30, 40.5)
-      assert_nothing_raised { draw.draw(@img) }
-    end
-
-    assert_raise(ArgumentError) { @draw.gravity('xxx') }
-  end
-
-  def test_image
-    Magick::CompositeOperator.values do |composite|
-      next if [Magick::CopyAlphaCompositeOp, Magick::NoCompositeOp].include?(composite)
-
-      draw = Magick::Draw.new
-      draw.image(composite, 10, 10, 200, 100, "#{IMAGES_DIR}/Flower_Hat.jpg")
-      assert_nothing_raised { draw.draw(@img) }
-    end
-
-    assert_raise(ArgumentError) { @draw.image('xxx', 10, 10, 200, 100, "#{IMAGES_DIR}/Flower_Hat.jpg") }
-    assert_raise(ArgumentError) { @draw.image(Magick::AtopCompositeOp, 'x', 100, 200, 100, "#{IMAGES_DIR}/Flower_Hat.jpg") }
-    assert_raise(ArgumentError) { @draw.image(Magick::AtopCompositeOp, 100, 'x', 200, 100, "#{IMAGES_DIR}/Flower_Hat.jpg") }
-    assert_raise(ArgumentError) { @draw.image(Magick::AtopCompositeOp, 100, 100, 'x', 100, "#{IMAGES_DIR}/Flower_Hat.jpg") }
-    assert_raise(ArgumentError) { @draw.image(Magick::AtopCompositeOp, 100, 100, 200, 'x', "#{IMAGES_DIR}/Flower_Hat.jpg") }
-  end
-
-  def test_interline_spacing
-    draw = Magick::Draw.new
-    draw.interline_spacing(40.5)
-    assert_equal('interline-spacing 40.5', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.interline_spacing('40.5')
-    assert_equal('interline-spacing 40.5', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    # assert_raise(ArgumentError) { @draw.interline_spacing(Float::NAN) }
-    assert_raise(ArgumentError) { @draw.interline_spacing('nan') }
-    assert_raise(ArgumentError) { @draw.interline_spacing('xxx') }
-    assert_raise(TypeError) { @draw.interline_spacing(nil) }
-  end
-
-  def test_interword_spacing
-    draw = Magick::Draw.new
-    draw.interword_spacing(40.5)
-    assert_equal('interword-spacing 40.5', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.interword_spacing('40.5')
-    assert_equal('interword-spacing 40.5', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    # assert_raise(ArgumentError) { @draw.interword_spacing(Float::NAN) }
-    assert_raise(ArgumentError) { @draw.interword_spacing('nan') }
-    assert_raise(ArgumentError) { @draw.interword_spacing('xxx') }
-    assert_raise(TypeError) { @draw.interword_spacing(nil) }
-  end
-
-  def test_kerning
-    draw = Magick::Draw.new
-    draw.kerning(40.5)
-    assert_equal('kerning 40.5', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.kerning('40.5')
-    assert_equal('kerning 40.5', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    # assert_raise(ArgumentError) { @draw.kerning(Float::NAN) }
-    assert_raise(ArgumentError) { @draw.kerning('nan') }
-    assert_raise(ArgumentError) { @draw.kerning('xxx') }
-    assert_raise(TypeError) { @draw.kerning(nil) }
-  end
-
-  def test_line
-    @draw.line(10, '20.5', 30, 40.5)
-    assert_equal('line 10,20.5 30,40.5', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.line('x', '20.5', 30, 40.5) }
-    assert_raise(ArgumentError) { @draw.line(10, 'x', 30, 40.5) }
-    assert_raise(ArgumentError) { @draw.line(10, '20.5', 'x', 40.5) }
-    assert_raise(ArgumentError) { @draw.line(10, '20.5', 30, 'x') }
-  end
-
-  def test_opacity
-    @draw.opacity(0.8)
-    assert_equal('opacity 0.8', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_nothing_raised { @draw.opacity(0.0) }
-    assert_nothing_raised { @draw.opacity(1.0) }
-    assert_nothing_raised { @draw.opacity('0.0') }
-    assert_nothing_raised { @draw.opacity('1.0') }
-    assert_nothing_raised { @draw.opacity('20%') }
-
-    assert_raise(ArgumentError) { @draw.opacity(-0.01) }
-    assert_raise(ArgumentError) { @draw.opacity(1.01) }
-    assert_raise(ArgumentError) { @draw.opacity('-0.01') }
-    assert_raise(ArgumentError) { @draw.opacity('1.01') }
-    assert_raise(ArgumentError) { @draw.opacity('xxx') }
-  end
-
-  def test_path
-    @draw.path('M110,100 h-75 a75,75 0 1,0 75,-75 z')
-    assert_equal("path 'M110,100 h-75 a75,75 0 1,0 75,-75 z'", @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-  end
-
-  def test_pattern
-    @draw.pattern('hat', 0, 10.5, 20, '20') {}
-    assert_equal("push defs\npush pattern hat 0 10.5 20 20\npush graphic-context\npop graphic-context\npop pattern\npop defs", @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.pattern('hat', 'x', 0, 20, 20) {} }
-    assert_raise(ArgumentError) { @draw.pattern('hat', 0, 'x', 20, 20) {} }
-    assert_raise(ArgumentError) { @draw.pattern('hat', 0, 0, 'x', 20) {} }
-    assert_raise(ArgumentError) { @draw.pattern('hat', 0, 0, 20, 'x') {} }
-  end
-
-  def test_point
-    @draw.point(10.5, '20')
-    assert_equal('point 10.5,20', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.point('x', 20) }
-    assert_raise(ArgumentError) { @draw.point(10, 'x') }
-  end
-
-  def test_pointsize
-    @draw.pointsize(20.5)
-    assert_equal('font-size 20.5', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.pointsize('x') }
-  end
-
-  def test_font_size
-    @draw.font_size(20)
-    assert_equal('font-size 20', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.font_size('x') }
-  end
-
-  def test_polygon
-    @draw.polygon(0, '0.5', 8.5, 16, 16, 0, 0, 0)
-    assert_equal('polygon 0,0.5,8.5,16,16,0,0,0', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.polygon }
-    assert_raise(ArgumentError) { @draw.polygon(0) }
-    assert_raise(ArgumentError) { @draw.polygon('x', 0, 8, 16, 16, 0, 0, 0) }
-  end
-
-  def test_polyline
-    @draw.polyline(0, '0.5', 16.5, 16)
-    assert_equal('polyline 0,0.5,16.5,16', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.polyline }
-    assert_raise(ArgumentError) { @draw.polyline(0) }
-    assert_raise(ArgumentError) { @draw.polyline('x', 0, 16, 16) }
-  end
-
-  def test_rectangle
-    @draw.rectangle(10, '10', 100, 100)
-    assert_equal('rectangle 10,10 100,100', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.rectangle('x', 10, 20, 20) }
-    assert_raise(ArgumentError) { @draw.rectangle(10, 'x', 20, 20) }
-    assert_raise(ArgumentError) { @draw.rectangle(10, 10, 'x', 20) }
-    assert_raise(ArgumentError) { @draw.rectangle(10, 10, 20, 'x') }
-  end
-
-  def test_rotate
-    @draw.rotate(45)
-    assert_equal('rotate 45', @draw.inspect)
-    @draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.rotate('x') }
-  end
-
-  def test_roundrectangle
-    @draw.roundrectangle(10, '10', 100, 100, 20, 20)
-    assert_equal('roundrectangle 10,10,100,100,20,20', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.roundrectangle('x', '10', 100, 100, 20, 20) }
-    assert_raise(ArgumentError) { @draw.roundrectangle(10, 'x', 100, 100, 20, 20) }
-    assert_raise(ArgumentError) { @draw.roundrectangle(10, '10', 'x', 100, 20, 20) }
-    assert_raise(ArgumentError) { @draw.roundrectangle(10, '10', 100, 'x', 20, 20) }
-    assert_raise(ArgumentError) { @draw.roundrectangle(10, '10', 100, 100, 'x', 20) }
-    assert_raise(ArgumentError) { @draw.roundrectangle(10, '10', 100, 100, 20, 'x') }
-  end
-
-  def test_scale
-    @draw.scale('0.5', 1.5)
-    assert_equal('scale 0.5,1.5', @draw.inspect)
-    @draw.rectangle(10, '10', 100, 100)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.scale('x', 1.5) }
-    assert_raise(ArgumentError) { @draw.scale(0.5, 'x') }
-  end
-
-  def test_skewx
-    @draw.skewx(45)
-    assert_equal('skewX 45', @draw.inspect)
-    @draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.skewx('x') }
-  end
-
-  def test_skewy
-    @draw.skewy(45)
-    assert_equal('skewY 45', @draw.inspect)
-    @draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.skewy('x') }
-  end
-
-  def test_stroke
-    @draw.stroke('red')
-    assert_equal('stroke "red"', @draw.inspect)
-    @draw.rectangle(10, '10', 100, 100)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    # assert_raise(ArgumentError) { @draw.stroke(100) }
-  end
-
-  def test_stroke_color
-    @draw.stroke_color('red')
-    assert_equal('stroke "red"', @draw.inspect)
-    @draw.rectangle(10, '10', 100, 100)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    # assert_raise(ArgumentError) { @draw.stroke_color(100) }
-  end
-
-  def test_stroke_pattern
-    @draw.stroke_pattern('red')
-    assert_equal('stroke "red"', @draw.inspect)
-    @draw.rectangle(10, '10', 100, 100)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    # assert_raise(ArgumentError) { @draw.stroke_pattern(100) }
-  end
-
-  def test_stroke_antialias
-    draw = Magick::Draw.new
-    draw.stroke_antialias(true)
-    assert_equal('stroke-antialias 1', draw.inspect)
-    draw.stroke_pattern('red')
-    draw.stroke_width(5)
-    draw.circle(10, '20.5', 30, 40.5)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.stroke_antialias(false)
-    assert_equal('stroke-antialias 0', draw.inspect)
-    draw.stroke_pattern('red')
-    draw.stroke_width(5)
-    draw.circle(10, '20.5', 30, 40.5)
-    assert_nothing_raised { draw.draw(@img) }
-  end
-
-  def test_stroke_dasharray
-    draw = Magick::Draw.new
-    draw.stroke_dasharray(2, 2)
-    assert_equal('stroke-dasharray 2,2', draw.inspect)
-    draw.stroke_pattern('red')
-    draw.stroke_width(2)
-    draw.rectangle(10, '10', 100, 100)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.stroke_dasharray
-    assert_equal('stroke-dasharray none', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.stroke_dasharray(-0.1) }
-    assert_raise(ArgumentError) { @draw.stroke_dasharray('x') }
-  end
-
-  def test_stroke_dashoffset
-    @draw.stroke_dashoffset(10)
-    assert_equal('stroke-dashoffset 10', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.stroke_dashoffset('x') }
-  end
-
-  def test_stroke_linecap
-    draw = Magick::Draw.new
-    draw.stroke_linecap('butt')
-    assert_equal('stroke-linecap butt', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.stroke_linecap('round')
-    assert_equal('stroke-linecap round', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.stroke_linecap('square')
-    assert_equal('stroke-linecap square', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.stroke_linecap('foo') }
-  end
-
-  def test_stroke_linejoin
-    draw = Magick::Draw.new
-    draw.stroke_linejoin('round')
-    assert_equal('stroke-linejoin round', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.stroke_linejoin('miter')
-    assert_equal('stroke-linejoin miter', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.stroke_linejoin('bevel')
-    assert_equal('stroke-linejoin bevel', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.stroke_linejoin('foo') }
-  end
-
-  def test_stroke_miterlimit
-    draw = Magick::Draw.new
-    draw.stroke_miterlimit(1.0)
-    assert_equal('stroke-miterlimit 1.0', draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.stroke_miterlimit(0.9) }
-    assert_raise(ArgumentError) { @draw.stroke_miterlimit('foo') }
-  end
-
-  def test_stroke_opacity
-    @draw.stroke_opacity(0.8)
-    assert_equal('stroke-opacity 0.8', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_nothing_raised { @draw.stroke_opacity(0.0) }
-    assert_nothing_raised { @draw.stroke_opacity(1.0) }
-    assert_nothing_raised { @draw.stroke_opacity('0.0') }
-    assert_nothing_raised { @draw.stroke_opacity('1.0') }
-    assert_nothing_raised { @draw.stroke_opacity('20%') }
-
-    assert_raise(ArgumentError) { @draw.stroke_opacity(-0.01) }
-    assert_raise(ArgumentError) { @draw.stroke_opacity(1.01) }
-    assert_raise(ArgumentError) { @draw.stroke_opacity('-0.01') }
-    assert_raise(ArgumentError) { @draw.stroke_opacity('1.01') }
-    assert_raise(ArgumentError) { @draw.stroke_opacity('xxx') }
-  end
-
-  def test_stroke_width
-    @draw.stroke_width(2.5)
-    assert_equal('stroke-width 2.5', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.stroke_width('xxx') }
-  end
-
-  def test_text
-    draw = Magick::Draw.new
-    draw.text(50, 50, 'Hello world')
-    assert_equal("text 50,50 'Hello world'", draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.text(50, 50, "Hello 'world'")
-    assert_equal("text 50,50 \"Hello 'world'\"", draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.text(50, 50, 'Hello "world"')
-    assert_equal("text 50,50 'Hello \"world\"'", draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.text(50, 50, "Hello 'world\"")
-    assert_equal("text 50,50 {Hello 'world\"}", draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.text(50, 50, "Hello {'world\"")
-    assert_equal("text 50,50 {Hello {'world\"}", draw.inspect)
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.text(50, 50, '') }
-    assert_raise(ArgumentError) { @draw.text('x', 50, 'Hello world') }
-    assert_raise(ArgumentError) { @draw.text(50, 'x', 'Hello world') }
-  end
-
-  def test_text_align
-    draw = Magick::Draw.new
-    draw.text_align(Magick::LeftAlign)
-    assert_equal('text-align left', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.text_align(Magick::RightAlign)
-    assert_equal('text-align right', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.text_align(Magick::CenterAlign)
-    assert_equal('text-align center', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.text_align('x') }
-  end
-
-  def test_text_anchor
-    draw = Magick::Draw.new
-    draw.text_anchor(Magick::StartAnchor)
-    assert_equal('text-anchor start', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.text_anchor(Magick::MiddleAnchor)
-    assert_equal('text-anchor middle', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.text_anchor(Magick::EndAnchor)
-    assert_equal('text-anchor end', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.text_anchor('x') }
-  end
-
-  def test_text_antialias
-    draw = Magick::Draw.new
-    draw.text_antialias(true)
-    assert_equal('text-antialias 1', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-
-    draw = Magick::Draw.new
-    draw.text_antialias(false)
-    assert_equal('text-antialias 0', draw.inspect)
-    draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { draw.draw(@img) }
-  end
-
-  def test_text_undercolor
-    @draw.text_undercolor('red')
-    assert_equal('text-undercolor "red"', @draw.inspect)
-    @draw.text(50, 50, 'Hello world')
-    assert_nothing_raised { @draw.draw(@img) }
-  end
-
-  def test_translate
-    @draw.translate('200', 300)
-    assert_equal('translate 200,300', @draw.inspect)
-    assert_nothing_raised { @draw.draw(@img) }
-
-    assert_raise(ArgumentError) { @draw.translate('x', 300) }
-    assert_raise(ArgumentError) { @draw.translate(200, 'x') }
-  end
-end