rmagick 3.0.0 → 3.1.0

data/lib/rmagick/version.rb

@@ -1,6 +1,5 @@
 module Magick
-  VERSION = '3.0.0'
+  VERSION = '3.1.0'
   MIN_RUBY_VERSION = '2.3.0'
-  MIN_IM_VERSION = '6.8.9'
-  MIN_WAND_VERSION = '6.9.0'
+  MIN_IM_VERSION = '6.7.7'
 end

data/lib/rvg/deep_equal.rb

@@ -30,7 +30,7 @@ module Magick
               end
             else
               case itv
-              when Float, Symbol, TrueClass, FalseClass, Fixnum, NilClass
+              when Float, Symbol, TrueClass, FalseClass, Integer, NilClass
                 return false if itv != otv
               else
                 if itv.equal?(otv)

data/lib/rvg/misc.rb

@@ -14,7 +14,7 @@ module Magick
           ivars = instance_variables
           ivars.each do |ivar|
             ivalue = instance_variable_get(ivar)
-            cvalue = if ivalue.is_a?(NilClass) || ivalue.is_a?(Symbol) || ivalue.is_a?(Float) || ivalue.is_a?(Fixnum) || ivalue.is_a?(FalseClass) || ivalue.is_a?(TrueClass)
+            cvalue = if ivalue.is_a?(NilClass) || ivalue.is_a?(Symbol) || ivalue.is_a?(Float) || ivalue.is_a?(Integer) || ivalue.is_a?(FalseClass) || ivalue.is_a?(TrueClass)
                        ivalue
                      elsif ivalue.respond_to?(:deep_copy)
                        ivalue.deep_copy(h)
@@ -452,9 +452,9 @@ module Magick
         }
 
         FONT_WEIGHT = {
-          'normal'  => Magick::NormalWeight,
-          'bold'    => Magick::BoldWeight,
-          'bolder'  => Magick::BolderWeight,
+          'normal' => Magick::NormalWeight,
+          'bold' => Magick::BoldWeight,
+          'bolder' => Magick::BolderWeight,
           'lighter' => Magick::LighterWeight
         }
 

data/lib/rvg/units.rb

@@ -2,12 +2,12 @@
 # Copyright (C) 2009 Timothy P. Hunter
 module Magick
   class RVG
-    # Define RVG.dpi and RVG.dpi=. Add conversions to Fixnum and Float classes
+    # Define RVG.dpi and RVG.dpi=. Add conversions to Integer and Float classes
     class << self
       attr_reader :dpi
       def dpi=(n)
         unless defined?(@dpi)
-          [Float, Fixnum].each do |c|
+          [Float, Integer].each do |c|
             c.class_eval <<-END_DEFS
               # the default measurement - 1px is 1 pixel
               def px

data/rmagick.gemspec

@@ -26,14 +26,14 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = 'rmagick'
   s.extensions = %w[ext/RMagick/extconf.rb]
-  s.has_rdoc = false
   s.required_ruby_version = ">= #{Magick::MIN_RUBY_VERSION}"
   s.requirements << "ImageMagick #{Magick::MIN_IM_VERSION} or later"
 
   s.add_development_dependency 'rake-compiler', '~> 1.0'
   s.add_development_dependency 'rspec', '~> 3.8'
   s.add_development_dependency 'rspec_junit_formatter', '~> 0.4.1'
-  s.add_development_dependency 'rubocop', '0.64.0'
+  s.add_development_dependency 'rubocop', '~> 0.64.0'
+  s.add_development_dependency 'rubocop-rspec', '~> 1.32.0'
   s.add_development_dependency 'simplecov', '~> 0.16.1'
   s.add_development_dependency 'test-unit', '~> 2.5'
 end

data/spec/rmagick/ImageList1_spec.rb

@@ -3,7 +3,7 @@ RSpec.describe Magick::ImageList do
     it 'works with identical instances' do
       expect do
         img = Magick::Image.new(1, 1)
-        list = Magick::ImageList.new
+        list = described_class.new
         list << img << img
         res = list.append(false)
         expect(res.columns).to eq(2)
@@ -13,7 +13,7 @@ RSpec.describe Magick::ImageList do
       expect do
         img = Magick::Image.new(1, 1)
         img2 = Magick::Image.new(3, 3)
-        list = Magick::ImageList.new
+        list = described_class.new
         list.concat([img, img2, img, img2, img])
         res = list.append(false)
         expect(res.columns).to eq(9)

data/spec/rmagick/draw_spec.rb

@@ -5,24 +5,24 @@ class Magick::Draw
 end
 
 RSpec.describe Magick::Draw do
-  let(:draw) { Magick::Draw.new }
+  let(:draw) { described_class.new }
 
   describe '._dummy_img_' do
     it 'works' do
       # initially this variable is not defined.
-      expect { Magick::Draw._dummy_img_ }.to raise_error(NameError)
+      expect { described_class._dummy_img_ }.to raise_error(NameError)
 
       # cause it to become defined. save the object id.
       draw.get_type_metrics('ABCDEF')
       dummy = nil
-      expect { dummy = Magick::Draw._dummy_img_ }.not_to raise_error
+      expect { dummy = described_class._dummy_img_ }.not_to raise_error
 
       expect(dummy).to be_instance_of(Magick::Image)
 
       # ensure that it is always the same object
       draw.get_type_metrics('ABCDEF')
       dummy2 = nil
-      expect { dummy2 = Magick::Draw._dummy_img_ }.not_to raise_error
+      expect { dummy2 = described_class._dummy_img_ }.not_to raise_error
       expect(dummy).to eq dummy2
     end
   end

data/spec/rmagick/image/composite_spec.rb

@@ -55,7 +55,12 @@ RSpec.describe Magick::Image, '#composite' do
       Magick::ColorDodgeCompositeOp,
       Magick::ExclusionCompositeOp,
       Magick::HardLightCompositeOp,
-      Magick::SoftLightCompositeOp
+      Magick::SoftLightCompositeOp,
+      Magick::MathematicsCompositeOp,
+      Magick::DivideSrcCompositeOp,
+      Magick::MinusSrcCompositeOp,
+      Magick::DarkenIntensityCompositeOp,
+      Magick::LightenIntensityCompositeOp
     ]
   end
   let(:gravity) do

data/spec/rmagick/image/properties_spec.rb

@@ -3,25 +3,25 @@ RSpec.describe Magick::Image, '#properties' do
   let(:freeze_error) { RUBY_VERSION[/^1\.9|^2/] ? RuntimeError : TypeError }
 
   before(:each) do
-    img['a'] = 'str_1'
-    img['b'] = 'str_2'
-    img['c'] = 'str_3'
+    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['a']).to eq 'str_1'
-    expect(img['b']).to eq 'str_2'
-    expect(img['c']).to eq 'str_3'
+    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 = { 'a' => 'str_1', 'b' => 'str_2', 'c' => 'str_3' }
+    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['d'] = 'str_4' }.to raise_error(freeze_error)
+    expect { img['comment'] = 'str_4' }.to raise_error(freeze_error)
   end
 end

data/test/Draw.rb

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