magickwand 0.1.0

data/lib/magickwand.rb

@@ -0,0 +1,28 @@
+# $Id: magickwand.rb 128 2009-05-31 13:12:51Z rmagick $
+# Copyright (C) 2009 Timothy P. Hunter
+
+require 'magickwand.so'
+
+module MagickWand
+   class Wand
+
+      # options are :filter, :blur
+      def resize_to_fit(width, height=nil, options=nil)
+         height ||= width
+         new_width, new_height = get_resize_geometry("#{width}x#{height}")
+         resize(new_width, new_height, options)
+      end
+
+      # options are :filter, :blur, :gravity, :repage
+      def resize_to_fill(width, height=nil, options=nil)
+         height ||= width
+         options ||= Hash.new
+         new_width, new_height = get_resize_geometry("#{width}x#{height}^")
+         resize(new_width, new_height, options)
+         options[:gravity] ||= "center"
+         crop(width, height, options)
+      end
+
+   end
+end
+

data/test/test_magickwand.rb

@@ -0,0 +1,1100 @@
+require 'test/unit'
+require 'magickwand'
+
+# The test images are in the same directory as this file.
+BUTTON_IMAGES = Dir[File.dirname(__FILE__) + "/Button_*.gif"].freeze
+
+# Determine what exception is raised when you try to modify a frozen object
+begin
+   f = "string"
+   f.freeze
+   f[0] = "x"
+rescue TypeError
+   FreezeError = TypeError
+rescue RuntimeError
+   FreezeError = RuntimeError
+end
+
+
+class TestMagickWand < Test::Unit::TestCase
+
+   # Very basic tests
+   def test_aaaaaaaaaa
+      assert_not_nil(MagickWand::Wand)
+      assert_kind_of(Class, MagickWand::Wand)
+      assert_kind_of(Class, MagickWand::ImageMagickError)
+      assert_kind_of(Class, MagickWand::FatalImageMagickError)
+
+      assert_kind_of(String, MagickWand::VERSION)
+      assert MagickWand::VERSION.frozen?
+      assert_kind_of(Hash, MagickWand::IMAGEMAGICK_CONFIG)
+      assert MagickWand::IMAGEMAGICK_CONFIG.frozen?
+      assert_kind_of(String, MagickWand::IMAGEMAGICK_CONFIG['VERSION'])
+      assert MagickWand::IMAGEMAGICK_CONFIG['VERSION'].frozen?
+
+      wand = nil
+      assert_nothing_raised { wand = MagickWand::Wand.new }
+      assert_instance_of(MagickWand::Wand, wand)
+      assert_equal(0, wand.length)    # length is a synonym for size
+   end
+
+   # tests wand.background, too
+   def test_add_canvas
+      wand = MagickWand::Wand.new
+      assert_nothing_raised { wand.add_canvas(100) }
+      assert_equal([100, 100], wand.dimensions)
+      assert_equal("#FFFFFFFFFFFF", wand.background)
+      wand.add_canvas(100, 200, "red")
+      assert_equal([100, 200], wand[1].dimensions)
+      assert_equal("#FFFF00000000", wand[1].background)
+      wand.add_canvas(100, 250, "rgb(0,255,0)")
+      assert_equal([100, 250], wand[2].dimensions)
+      assert_equal("#0000FFFF0000", wand[2].background)
+   end
+
+   # :xyzzy=>false suppresses the actual animation
+   # all we can do is ensure the options are handled
+   def test_animate
+      wand = MagickWand::Wand.new
+      BUTTON_IMAGES.sort.each { |file| wand.read file }
+      assert_nothing_raised { wand.animate :xyzzy=>false }
+      assert_nothing_raised { wand.animate :delay=>50, :xyzzy=>false }
+      assert_nothing_raised { wand.animate :delay=>[50], :xyzzy=>false }
+      assert_nothing_raised { wand.animate :delay=>[50,50], :xyzzy=>false }
+      assert_nothing_raised { wand.animate :iterations=>10, :xyzzy=>false }
+   end
+
+   def test_annotate
+      wand = MagickWand::Wand.new
+      wand.add_canvas(200, 200)
+      assert_nothing_raised { wand.annotate "hello!" }
+      assert_nothing_raised { wand.annotate "hello!", :angle=>90, :fill=>"red", :stroke=>"black", :pointsize=>24 }
+      assert_nothing_raised { wand.annotate "hello!", :undercolor=>"cyan", :decoration=>"underline", :strokewidth=>3 }
+      assert_nothing_raised { wand.annotate "hello!", :family=>"arial", :stretch=>"condensed", :fill_opacity=>0.5, :style=>"italic" }
+      assert_nothing_raised { wand.annotate "hello!", :stroke_opacity=>0.05, :weight=>400, :antialias=>false, :undercolor=>"red" }
+      assert_nothing_raised { wand.annotate "hello!", :interword_spacing=>15, :kerning=>15 }
+      assert_nothing_raised { wand.annotate "hello!", :gravity=>"none", :x=>100, :y=>100, :align=>"left" }
+
+      # option errors - IM doesn't diagnose invalid colors, presumably because they
+      # could be pattern names. Don't test simple type errors. That's Ruby's job.
+      assert_raise(ArgumentError) { wand.annotate "hello", :align=>"xxx"             }
+      #assert_raise(TypeError)     { wand.annotate "hello", :angle=>"xxx"             }
+      assert_raise(ArgumentError) { wand.annotate "hello", :decoration=>"xxx"        }
+      assert_raise(ArgumentError) { wand.annotate "hello", :gravity=>"xxx"           }
+      #assert_raise(ArgumentError) { wand.annotate "hello", :fill=>"xxx"              }
+      #assert_raise(TypeError)     { wand.annotate "hello", :fill_opacity=>"xxx"      }
+      assert_raise(ArgumentError) { wand.annotate "hello", :gravity=>"xxx"           }
+      #assert_raise(TypeError)     { wand.annotate "hello", :interword_spacing=>"xxx" }
+      #assert_raise(TypeError)     { wand.annotate "hello", :kerning=>"xxx"           }
+      #assert_raise(TypeError)     { wand.annotate "hello", :pointsize=>"xxx"         }
+      assert_raise(ArgumentError) { wand.annotate "hello", :stretch=>"xxx"           }
+      #assert_raise(ArgumentError) { wand.annotate "hello", :stroke=>"xxx"            }
+      #assert_raise(TypeError)     { wand.annotate "hello", :stroke_opacity=>"xxx"    }
+      #assert_raise(TypeError)     { wand.annotate "hello", :strokewidth=>"xxx"       }
+      assert_raise(ArgumentError) { wand.annotate "hello", :style=>"xxx"             }
+      #assert_raise(ArgumentError) { wand.annotate "hello", :undercolor=>"xxx"        }
+      assert_raise(ArgumentError) { wand.annotate "hello", :weight=>"xxx"            }
+      #assert_raise(TypeError)     { wand.annotate "hello", :x=>"xxx"                 }
+      #assert_raise(TypeError)     { wand.annotate "hello", :y=>"xxx"                 }
+
+      wand.freeze
+      assert_raise(FreezeError) { wand.annotate "hello" }
+   end
+
+   def test_aref
+      wand = MagickWand::Wand.new
+      BUTTON_IMAGES.sort.each { |file| wand.read file }
+      assert_equal(BUTTON_IMAGES.length, wand.size)
+
+      t = nil
+      assert_nothing_raised { t = wand[0]}
+      assert_instance_of(MagickWand::Wand, t)
+      assert_equal(1, t.size)
+      assert_not_same(t, wand, "subset wand is not a new wand!")
+      assert_match(/Button_0/, t.filename)
+
+      t = wand[1]
+      assert_equal(1, t.size);
+      assert_match(/Button_1/, t.filename)
+
+      t = wand[-1]
+      assert_equal(1, t.size);
+      assert_match(/Button_9/, t.filename)
+
+      t = wand[2, 3]
+      assert_equal(3, t.size);
+      assert_match(/Button_2/, t.filename)
+      assert_match(/Button_2/, t[0].filename)
+      assert_match(/Button_3/, t[1].filename)
+      assert_match(/Button_4/, t[2].filename)
+
+      t = wand[-3, 2]
+      assert_equal(2, t.size);
+      assert_match(/Button_7/, t.filename)
+      assert_match(/Button_8/, t[1].filename)
+
+      t = wand[0..-1]
+      assert_equal(wand.size, t.size)
+      inspect_string = t.inspect
+      t.size.times do |n|
+         assert_match(/Button_#{n}/, inspect_string)
+      end
+
+      # out-of-range returns empty object
+      assert_nothing_raised { t = wand[10]}
+      assert_instance_of(MagickWand::Wand, t)
+      assert_equal(0, t.size)
+      assert_not_same(t, wand, "subset wand is not a new wand!")
+      assert_equal("()", t.inspect)
+
+      assert_nothing_raised { t = wand[10..12]}
+      assert_instance_of(MagickWand::Wand, t)
+      assert_equal(0, t.size)
+      assert_not_same(t, wand, "subset wand is not a new wand!")
+      assert_equal("()", t.inspect)
+
+      assert_nothing_raised { t = wand[-13..-1]}
+      assert_instance_of(MagickWand::Wand, t)
+      assert_equal(0, t.size)
+      assert_not_same(t, wand, "subset wand is not a new wand!")
+      assert_equal("()", t.inspect)
+
+      assert_raise(TypeError) { wand[10.2] }
+   end
+
+   def test_aset
+      wand = MagickWand::Wand.new
+      wand2 = MagickWand::Wand.new
+      # wand gets images 0-4
+      # wand2 gets images 5-9
+      sorted_images = BUTTON_IMAGES.sort
+      5.times {|n| wand.read sorted_images.sort[n]}
+      5.times {|n| wand2.read sorted_images.sort[n+5]}
+
+      assert_nothing_raised { wand[0] = wand2[0] }
+      assert_match(/Button_5.gif/, wand[0].filename)
+
+      # replace wand[0] with all images in wand2
+      wand = MagickWand::Wand.new
+      5.times {|n| wand.read sorted_images[n]}
+      assert_nothing_raised { wand[0] = wand2 }
+      assert_equal(9, wand.length)
+      [5, 6, 7, 8, 9, 1, 2, 3, 4].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      # replace wand[1] with all images in wand2
+      wand = MagickWand::Wand.new
+      5.times {|n| wand.read sorted_images[n]}
+      assert_nothing_raised { wand[1] = wand2 }
+      assert_equal(9, wand.length)
+      [0, 5, 6, 7, 8, 9, 2, 3, 4].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      # replace sorted_images 1 and 2 in wand with all images in wand2
+      wand = MagickWand::Wand.new
+      5.times {|n| wand.read sorted_images[n]}
+      assert_nothing_raised { wand[1, 2] = wand2 }
+      assert_equal(8, wand.length)
+      [0, 5, 6, 7, 8, 9, 3, 4].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      # replace wand[0] with an empty wand - deletes the first image
+      empty = MagickWand::Wand.new
+      wand = MagickWand::Wand.new
+      5.times {|n| wand.read sorted_images[n]}
+      assert_nothing_raised { wand[0] = empty }
+      assert_equal(4, wand.length)
+      [1, 2, 3, 4].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      # reduce the length to the number of images remaining in the wand
+      # extend the length of the receiving wand
+      wand = MagickWand::Wand.new
+      5.times {|n| wand.read sorted_images[n]}
+      assert_nothing_raised { wand[1,5] = wand2 }
+      assert_equal(6, wand.length)
+      [0, 5, 6, 7, 8, 9].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      # An index equal to the #images is okay. It appends wand2 to wand
+      wand = MagickWand::Wand.new
+      5.times {|n| wand.read sorted_images[n]}
+      assert_nothing_raised { wand[wand.length,1] = wand2 }
+      assert_equal(10, wand.length)
+      10.times do |n|
+         assert_match(/Button_#{n}.gif/, wand[n].filename)
+      end
+
+      # Same as previous test but with negative index.
+      # _Replaces_ the 0th image with the images in wand2 (same as String[-5,1])
+      wand = MagickWand::Wand.new
+      5.times {|n| wand.read sorted_images[n]}
+      assert_nothing_raised { wand[-wand.length,1] = wand2 }
+      assert_equal(9, wand.length)
+      [5, 6, 7, 8, 9, 1, 2, 3, 4].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      # Replace wand[-1] (i.e. the 4th image)
+      wand = MagickWand::Wand.new
+      5.times {|n| wand.read sorted_images[n]}
+      assert_nothing_raised { wand[-1] = wand2 }
+      [0, 1, 2, 3, 5, 6, 7, 8, 9].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      # Replace 2 images at -3 (i.e. the 2nd and 3rd image)
+      wand = MagickWand::Wand.new
+      5.times {|n| wand.read sorted_images[n]}
+      assert_nothing_raised { wand[-3, 2] = wand2 }
+      [0, 1, 5, 6, 7, 8, 9, 4].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      # An index > # of images raises IndexError
+      wand = MagickWand::Wand.new
+      5.times {|n| wand.read sorted_images[n]}
+      assert_raise(IndexError) { wand[wand.length+1,1] = wand2 }
+
+      # Same as previous test but with negative index.
+      assert_raise(IndexError) { wand[-(wand.length+1),1] = wand2 }
+
+      # Frozen?
+      wand.freeze
+      assert_raise(FreezeError) { wand[0] = wand2 }
+   end
+
+   def test_blur
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      assert_nothing_raised {wand.blur 0,3}
+      assert_nothing_raised {wand.blur 0,3, :channel=>"red"}
+      assert_raise(ArgumentError) { wand.blur 0,3, :channel=>"xxx" }
+
+      wand.freeze
+      assert_raise(FreezeError) {wand.blur 0,3}
+   end
+
+   def test_border
+      wand = MagickWand::Wand.new
+      wand.add_canvas(100, 100)
+      assert_nothing_raised { wand.border("black") }
+      # default width and height is 1
+      assert_equal([102, 102], wand.dimensions)
+      # default height = width
+      assert_nothing_raised { wand.border("red", 5) }
+      assert_equal([112, 112], wand.dimensions)
+      # no defaults
+      assert_nothing_raised { wand.border("red", 5, 10) }
+      assert_equal([122, 132], wand.dimensions)
+
+      wand.freeze
+      assert_raise(FreezeError) { wand.border("black") }
+   end
+
+   def test_clone
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      wand2 = nil
+      assert_nothing_raised { wand2 = wand.clone }
+      assert_not_same(wand, wand2)
+      assert_equal(wand.length, wand2.length)
+      assert_equal(wand.signature, wand2.signature)
+
+      # Identical objects but not the same MagickWand
+      wand.comment = "Comment A"
+      wand2.comment = "Comment B"
+      assert_equal("Comment A", wand.comment)
+
+      assert_nothing_raised { wand2 = wand.dup }
+      assert_not_same(wand, wand2)
+      assert_equal(wand.length, wand2.length)
+      assert_equal(wand.signature, wand2.signature)
+   end
+
+   def test_colors
+      wand = MagickWand::Wand.new
+      assert_nil(wand.colors)
+      wand.read BUTTON_IMAGES[0]
+      assert_equal(135, wand.colors)
+   end
+
+   # test #signature too
+   def test_cmp
+      awand = MagickWand::Wand.new
+      awand.read BUTTON_IMAGES[0]
+      bwand = MagickWand::Wand.new
+      bwand.read BUTTON_IMAGES[1]
+
+      asig = nil
+      assert_nothing_raised { asig = awand.signature }
+      assert_instance_of(String, asig)
+      assert_equal(64, asig.length)
+
+      bsig = bwand.signature
+      assert_not_equal(asig, bsig)
+      assert_equal(asig <=> bsig, awand <=> bwand)
+      assert_equal(bsig <=> asig, bwand <=> awand)
+
+      assert_instance_of(Fixnum, awand <=> bwand)
+
+      # equal
+      assert_equal(0, awand <=> awand)
+      # not equal
+      assert_not_equal(0, awand <=> bwand)
+      # different
+      assert_not_equal(awand <=> bwand, bwand <=> awand)
+   end
+
+   def test_comment
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES.first
+      assert_nothing_raised { wand.comment = "A comment" }
+      assert_equal("A comment", wand.comment)
+
+      # Comment must be a string!
+      assert_raise(TypeError) { wand.comment = 123 }
+
+      wand.freeze
+      assert_raise(FreezeError) { wand.comment = "A comment" }
+   end
+
+   def test_compare
+      awand = MagickWand::Wand.new
+      awand.read BUTTON_IMAGES[0]
+      bwand = MagickWand::Wand.new
+      bwand.read BUTTON_IMAGES[1]
+
+      #compare a to a should be equal
+      diff, dist = nil
+      assert_nothing_raised { diff, dist = awand.compare(awand) }
+      assert_instance_of(MagickWand::Wand, diff)
+      assert_equal(0.0, dist)
+
+      # compare a to be should not be equal
+      _, dist = awand.compare(bwand)
+      assert_not_equal(0.0, dist)
+
+      dist2 = nil
+      assert_nothing_raised { _, dist2 = awand.compare(bwand, :metric=>"rmse") }
+      # different metric
+      assert_not_equal(dist, dist2)
+
+      assert_nothing_raised { _, dist = awand.compare(bwand, :channel=>"red", :metric=>"rmse") }
+      _, dist2 = awand.compare(bwand, :channel=>"green", :metric=>"rmse")
+      # different channel
+      assert_not_equal(dist, dist2)
+
+      _, dist = awand.compare(bwand)
+      assert_nothing_raised { _, dist2 = awand.compare(bwand, :fuzz=>"10%") }
+      # different fuzz
+      assert_not_equal(dist, dist2)
+
+      # fuzz can be a string as well as a number
+      assert_nothing_raised { _, dist2 = awand.compare(bwand, :fuzz=>50) }
+
+   end
+
+   def test_composite
+      wand = MagickWand::Wand.new
+      wand.add_canvas(200, 200)
+      comp_wand = MagickWand::Wand.new
+      comp_wand.add_canvas(50, 50, "blue")
+      assert_nothing_raised { wand.composite comp_wand }
+      assert_equal(1, wand.length)
+      assert_equal([200, 200], wand.dimensions)
+
+      # test multiple images
+      wand.add_canvas(300, 300)
+      comp_wand.add_canvas(50, 50, "blue")
+      assert_nothing_raised { wand.composite comp_wand }
+      assert_equal(2, wand.length)
+      assert_equal([300, 300], wand[1].dimensions)
+
+      # test unequal numbers of images
+      wand.add_canvas(200, 200)
+      assert_nothing_raised { wand.composite comp_wand }
+      assert_equal(3, wand.length)
+
+      comp_wand.add_canvas(50, 50, "blue")
+      comp_wand.add_canvas(50, 50, "blue")
+      assert_nothing_raised { wand.composite comp_wand }
+      assert_equal(3, wand.length)
+
+      comp_wand.add_canvas(50, 50, "blue")
+      assert_nothing_raised { wand.composite comp_wand }
+      assert_equal(3, wand.length)
+
+      # test optional arguments
+      wand = MagickWand::Wand.new
+      wand.add_canvas(200, 200)
+      comp_wand = MagickWand::Wand.new
+      comp_wand.add_canvas(50, 50, "blue")
+      assert_nothing_raised { wand.composite comp_wand, :gravity => "north" }
+      assert_nothing_raised { wand.composite comp_wand, :x => 5, :y => 5 }
+      assert_nothing_raised { wand.composite comp_wand, :x=> 5, :y => 5, :gravity => "north" }
+      assert_raise(ArgumentError) { wand.composite comp_wand, :gravity=>"xyzzy" }
+
+      wand.freeze
+      assert_raise(FreezeError) { wand.composite comp_wand }
+   end
+
+   # concat is an alias for <<
+   def test_concat
+      wand = MagickWand::Wand.new
+      wand2 = MagickWand::Wand.new
+      5.times {|n| wand.read BUTTON_IMAGES[n]}
+      5.times {|n| wand2.read BUTTON_IMAGES[5+n]}
+      assert_equal(5, wand.size)
+      assert_equal(5, wand2.size)
+      assert_nothing_raised { wand << wand2 }
+      assert_equal(10, wand.size)
+
+      wand = MagickWand::Wand.new
+      wand2 = MagickWand::Wand.new
+      5.times {|n| wand.read BUTTON_IMAGES[n]}
+      5.times {|n| wand2.read BUTTON_IMAGES[5+n]}
+      assert_nothing_raised { wand.concat wand2 }
+      assert_equal(10, wand.size)
+
+      wand.freeze
+      assert_raise(FreezeError) { wand.concat wand2 }
+   end
+
+   def test_crop
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      wand2 = wand[0]
+      assert_nothing_raised { wand2.crop(50) }
+      assert_equal([50, 50], wand2.dimensions)
+
+      wand2 = wand[0]
+      assert_nothing_raised { wand2.crop(50, 35) }
+      assert_equal([50, 35], wand2.dimensions)
+
+      wand2 = wand[0]
+      assert_nothing_raised { wand2.crop(50, 35, :x=>5, :y=>5, :repage=>false) }
+      assert_equal([50, 35], wand2.dimensions)
+      assert_match(/\+5\+5 /, wand2.inspect)
+
+      wand2 = wand[0]
+      assert_nothing_raised { wand2.crop(50, 35, :gravity=>"center", :repage=>false) }
+      assert_equal([50, 35], wand2.dimensions)
+      assert_match(/\+38\+43 /, wand2.inspect)
+
+      # test all possible gravities
+      %w[northwest north  northeast
+         west      center east
+         southwest south  southeast].each do |gravity|
+            wand2 = wand[0]
+            assert_nothing_raised { wand2.crop(50, 35, :gravity=>gravity) }
+         end
+   end
+
+   def test_dimensions
+      wand = MagickWand::Wand.new
+      assert_nil(wand.dimensions)
+
+      wand.read BUTTON_IMAGES[0]
+      dim = nil
+      assert_nothing_raised { dim = wand.dimensions }
+      assert_equal([127, 120], dim)
+   end
+
+   def test_depth
+      wand = MagickWand::Wand.new
+      assert_nil(wand.depth)
+      wand.read BUTTON_IMAGES[0]
+      assert_equal(8, wand.depth)
+   end
+
+   def test_each
+      wand = MagickWand::Wand.new
+      BUTTON_IMAGES.sort.each { |f| wand.read f }
+      wand.each_with_index do |w, n|
+         assert_match(/Button_#{n}/, w.filename)
+      end
+
+      # Handle empty wands
+      wand = MagickWand::Wand.new
+      assert_nothing_raised { wand.each {|w| } }
+
+      # In >= 1.8.7 return an Enumerator if no block
+      # In 1.8.6 return self
+      if RUBY_VERSION == "1.8.7" || RUBY_VERSION == "1.9.1"
+         enum = nil
+         assert_nothing_raised { enum = wand.each }
+         assert_instance_of(Enumerable::Enumerator, enum) if RUBY_VERSION == "1.8.7"
+         assert_instance_of(Enumerator, enum) if RUBY_VERSION == "1.9.1"
+      else
+         enum = wand.each
+         assert_same(wand, enum)
+      end
+   end
+
+   def test_empty?
+      wand = MagickWand::Wand.new
+      assert_nothing_raised { wand.empty? }
+      assert( wand.empty? )
+      wand.read BUTTON_IMAGES[0]
+      assert( !wand.empty? )
+   end
+
+   def test_export_pixels
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      cols, rows = wand.dimensions
+      pixels = nil
+      assert_nothing_raised { pixels = wand.export_pixels(0, 0, cols, rows) }
+      assert_equal(cols*rows*3, pixels.size)
+      assert_nothing_raised { pixels = wand.export_pixels(0, 0, cols, rows, :map=>"I") }
+      assert_equal(cols*rows*1, pixels.size)
+      assert_nothing_raised { pixels = wand.export_pixels(0, 0, cols, rows, :map=>"I", :storage_type=>"char") }
+      assert_equal(cols*rows*1*1, pixels.size)
+      assert_nothing_raised { pixels = wand.export_pixels(0, 0, cols, rows, :map=>"I", :storage_type=>"short") }
+      assert_equal(cols*rows*1*2, pixels.size)
+      assert_nothing_raised { pixels = wand.export_pixels(0, 0, cols, rows, :map=>"I", :storage_type=>"integer") }
+      assert_equal(cols*rows*1*4, pixels.size)
+      assert_nothing_raised { pixels = wand.export_pixels(0, 0, cols, rows, :map=>"I", :storage_type=>"long") }
+      assert_equal(cols*rows*1*4, pixels.size)
+      assert_nothing_raised { pixels = wand.export_pixels(0, 0, cols, rows, :map=>"I", :storage_type=>"float") }
+      assert_equal(cols*rows*1*4, pixels.size)
+      assert_nothing_raised { pixels = wand.export_pixels(0, 0, cols, rows, :map=>"I", :storage_type=>"double") }
+      assert_equal(cols*rows*1*8, pixels.size)
+      assert_nothing_raised { pixels = wand.export_pixels(0, 0, cols, rows, :storage_type=>"quantum") }
+      assert_equal(cols*rows*3*MagickWand::QUANTUM_SIZE, pixels.size)
+
+      assert_raise(ArgumentError) { pixels = wand.export_pixels(0, 0, cols, rows, :map=>"I", :storage_type=>"int") }
+
+   end
+
+   def test_filename
+      wand = MagickWand::Wand.new
+      assert_nil(wand.filename)
+      wand.read BUTTON_IMAGES[0]
+      assert_nothing_raised { wand.filename }
+      assert_equal(BUTTON_IMAGES[0], wand.filename)
+   end
+
+   def test_format
+      wand = MagickWand::Wand.new
+      assert_nil(wand.format)
+      wand.read BUTTON_IMAGES[0]
+      assert_nothing_raised { wand.format }
+      assert_equal("GIF", wand.format)
+   end
+
+   # test eql? too
+   def test_hash
+      wand = MagickWand::Wand.new
+      wand2 = MagickWand::Wand.new
+      wand3 = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      wand2.read BUTTON_IMAGES[1]      # different than wand
+      wand3.read BUTTON_IMAGES[0]      # same as wand
+
+      assert_nothing_raised { wand.hash }
+      assert_equal(wand.hash, wand3.hash)
+      assert_not_equal(wand.hash, wand2.hash)
+
+      assert_nothing_raised { wand.eql?(wand2) }
+      assert(!wand.eql?(wand2))
+      assert(wand.eql?(wand3))
+   end
+
+   def test_import_pixels
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      cols, rows = wand.dimensions
+      pixels = wand.export_pixels(0, 0, cols, rows)
+      wand2 = MagickWand::Wand.new
+      wand2.add_canvas(cols, rows)
+      assert_nothing_raised { wand2.import_pixels(0, 0, cols, rows, pixels) }
+      _, dist = wand.compare(wand2)
+      assert_in_delta(0, dist, 10e-6)
+
+      # pixel array too small
+      wand2 = MagickWand::Wand.new
+      wand2.add_canvas(cols, rows)
+      assert_raise(ArgumentError) { wand2.import_pixels(0, 0, cols, rows, pixels[0..-2]) }
+
+      wand2.freeze
+      assert_raise(FreezeError) { wand2.import_pixels(0, 0, cols, rows, pixels) }
+   end
+
+   def test_insert
+      wand = MagickWand::Wand.new
+      wand2 = MagickWand::Wand.new
+
+      images = BUTTON_IMAGES.sort
+
+      5.times { |n| wand.read images[n] }
+      wand2.read images[9]
+
+      assert_nothing_raised { wand.insert(0, wand2) }
+      [9, 0, 1, 2, 3, 4].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      wand = MagickWand::Wand.new
+      5.times { |n| wand.read images[n] }
+      assert_nothing_raised { wand.insert(3, wand2) }
+      [0, 1, 2, 9, 3, 4].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      wand = MagickWand::Wand.new
+      5.times { |n| wand.read images[n] }
+      assert_nothing_raised { wand.insert(5, wand2) }
+      [0, 1, 2, 3, 4, 9].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      wand = MagickWand::Wand.new
+      5.times { |n| wand.read images[n] }
+      assert_nothing_raised { wand.insert(-1, wand2) }
+      [0, 1, 2, 3, 4, 9].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      wand = MagickWand::Wand.new
+      5.times { |n| wand.read images[n] }
+      assert_nothing_raised { wand.insert(-3, wand2) }
+      [0, 1, 2, 9, 3, 4].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      wand2.read images[8]
+      wand = MagickWand::Wand.new
+      5.times { |n| wand.read images[n] }
+      assert_nothing_raised { wand.insert(-3, wand2) }
+      [0, 1, 2, 9, 8, 3, 4].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand[n].filename)
+      end
+
+      wand.freeze
+      assert_raise(FreezeError) { wand.insert(-3, wand2) }
+   end
+
+   # need more
+   def test_inspect
+      wand = MagickWand::Wand.new
+      wand.add_canvas(200, 200)
+      wand.add_canvas(300, 300)
+      assert_match(/200x200/, wand[0].inspect)
+      assert_match(/300x300/, wand[1].inspect)
+      assert_match(/DirectClass/, wand[0].inspect)
+
+      wand = MagickWand::Wand.new
+      wand.read "test/Button_0.gif"
+      assert_match(/test\/Button_0.gif/, wand.inspect)
+      assert_match(/ GIF /, wand.inspect)
+      assert_match(/ 127x120\+0\+0 /, wand.inspect)
+      assert_match(/ 8-bit PaletteType PseudoClass /, wand.inspect)
+      assert_match(/ 256c /, wand.inspect)
+   end
+
+   def test_list_fonts
+      fonts = nil
+      assert_nothing_raised { fonts = MagickWand.list_fonts }
+      assert_instance_of(Array, fonts)
+      assert(fonts.size > 1)
+      fonts.each do |font|
+         assert_instance_of(String, font)
+      end
+   end
+
+   def test_modulate
+      wand = MagickWand::Wand.new
+      assert_nothing_raised { wand.modulate(50) }
+      assert_nothing_raised { wand.modulate(50, 50) }
+      assert_nothing_raised { wand.modulate(50, 50, 50) }
+      wand.freeze
+      assert_raise(FreezeError) { wand.modulate(50) }
+   end
+
+   # option_values returns a hash. The keys are symbols and the values are arrays.
+   # Each element in the array is a string.
+   def test_option_values
+      values = nil
+      assert_nothing_raised { values = MagickWand.option_values }
+      assert_instance_of(Hash, values)
+      assert(values.frozen?)
+
+      values.each_pair do |key, value|
+         assert_instance_of(Symbol, key)
+         assert_instance_of(Array, value)
+         assert(value.frozen?)
+         value.each do |v|
+            assert_instance_of(String, v)
+            assert(v.frozen?)
+         end
+      end
+
+      assert(values.has_key?(:channel))
+      assert(values.has_key?(:colorspace))
+      assert(values.has_key?(:compose))
+      assert(values.has_key?(:gravity))
+      assert(values.has_key?(:compress))
+      assert(values.has_key?(:filter))
+
+   end
+
+   def test_page
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      wand.crop(20, 20, :x=>5, :y=>7, :repage=>false)
+      assert_equal([127, 120, 5, 7], wand.page)
+   end
+
+   # ping and read share the same code so there's not much to do here
+   def test_ping
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+
+      wand2 = MagickWand::Wand.new
+      assert_nothing_raised { wand2.ping BUTTON_IMAGES[0] }
+
+      assert_equal(wand.dimensions, wand2.dimensions)
+      assert_equal(wand.filename, wand2.filename)
+
+      wand2.freeze
+      assert_raise(FreezeError) { wand2.ping BUTTON_IMAGES[0] }
+   end
+
+   def test_ping_string
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      image = wand.write_string
+
+      wand = MagickWand::Wand.new
+      wand2 = MagickWand::Wand.new
+      wand.read_string image
+      wand2.ping_string image
+
+      assert_equal(wand.dimensions, wand2.dimensions)
+      assert_equal(wand.filename, wand2.filename)
+
+      wand2.freeze
+      assert_raise(FreezeError) { wand2.ping_string image }
+   end
+
+   def test_plus
+      wand = MagickWand::Wand.new
+      wand2 = MagickWand::Wand.new
+      5.times {|n| wand.read BUTTON_IMAGES[n]}
+      5.times {|n| wand2.read BUTTON_IMAGES[5+n]}
+      assert_equal(5, wand.size)
+      assert_equal(5, wand2.size)
+      wand3 = nil
+      assert_nothing_raised { wand3 = wand + wand2 }
+      assert_equal(10, wand3.size)
+      assert_not_same(wand, wand3)
+      assert_not_same(wand2, wand3)
+   end
+
+   # Each read adds the new image(s) to the end of the list.
+   def test_read
+      wand = MagickWand::Wand.new
+
+      BUTTON_IMAGES.each_with_index do |file, n|
+         assert_nothing_raised { wand.read file }
+         assert_equal(1+n, wand.size)
+      end
+
+      # :size option
+      wand = MagickWand::Wand.new
+      assert_nothing_raised { wand.read("xc:white", :size=>'100x100') }
+      assert_equal([100, 100], wand.dimensions)
+
+      wand.freeze
+      assert_raise(FreezeError) { wand.read BUTTON_IMAGES[0] }
+   end
+
+   def test_read_errors
+      wand = MagickWand::Wand.new
+
+      # unknown option is NOT diagnosed
+      assert_nothing_raised { wand.read(BUTTON_IMAGES[0], :xyzzy => 1) }
+      # file not found
+      assert_raise(MagickWand::ImageMagickError) { wand.read("does_not_exist.jpg") }
+      # invalid value for :size
+      assert_raise(ArgumentError) { wand.read("xc:white", :size=>'x') }
+   end
+
+   def test_resize
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+
+      # implicit clone
+      wand2 = wand[0]
+      assert_nothing_raised { wand2.resize(254, 240) }
+      assert_equal([254, 240], wand2.dimensions)
+
+      # default height = width
+      wand2 = wand[0]
+      assert_nothing_raised { wand2.resize(254) }
+      assert_equal([254, 254], wand2.dimensions)
+
+      # legal options
+      wand2 = wand[0]
+      assert_nothing_raised { wand2.resize(254, 240, :filter=>"hanning", :blur => 1.5) }
+      # illegal option is ignored!
+      assert_nothing_raised { wand2.resize(254, 240, :xyzzy => 1) }
+
+      # known filters
+      wand = MagickWand::Wand.new
+      wand.add_canvas(20)
+      %w[bartlett bessel blackman bohman box catrom cubic gaussian hamming hanning hermite
+         kaiser lagrange lanczos mitchell parzen point quadratic sinc triangle welsh]. each do |filter|
+         assert_nothing_raised { wand.resize(20, 20, :filter => filter) }
+      end
+      # unknown filter
+      assert_raise(ArgumentError) { wand.resize(20, 20, :filter=>"xyzzy") }
+
+      wand.freeze
+      assert_raise(FreezeError) { wand.resize(20) }
+   end
+
+   def test_resize_to_fill
+      wand = MagickWand::Wand.new
+      wand.add_canvas(200, 200)
+      assert_nothing_raised { wand.resize_to_fill(200, 200) }
+      assert_equal([200, 200], wand.dimensions)
+
+      # height defaults to width
+      wand.resize_to_fill(100)
+      assert_equal([100, 100], wand.dimensions)
+
+      wand = MagickWand::Wand.new.add_canvas(200, 250)
+      wand.resize_to_fill(300, 100)
+      assert_equal([300, 100], wand.dimensions)
+
+      wand = MagickWand::Wand.new.add_canvas(200, 250)
+      wand.resize_to_fill(100, 300)
+      assert_equal([100, 300], wand.dimensions)
+
+      wand = MagickWand::Wand.new.add_canvas(200, 250)
+      wand.resize_to_fill(20, 400)
+      assert_equal([20, 400], wand.dimensions)
+
+      wand = MagickWand::Wand.new.add_canvas(200, 250)
+      wand.resize_to_fill(1000, 400)
+      assert_equal([1000, 400], wand.dimensions)
+   end
+
+   def test_resize_to_fit
+      wand = MagickWand::Wand.new
+      wand.add_canvas(40, 30)
+      # default height = width
+      assert_nothing_raised { wand.resize_to_fit(20) }
+      assert_equal([20, 15], wand.dimensions)
+
+      wand = MagickWand::Wand.new
+      wand.add_canvas(40, 30)
+      # explicit height
+      assert_nothing_raised { wand.resize_to_fit(80, 30) }
+      assert_equal([40, 30], wand.dimensions)
+
+      # Ensure options get passed by passing an unknown filter
+      assert_raise(ArgumentError) { wand.resize_to_fit(80, 30, :filter=>"xyzzy") }
+   end
+
+   def test_resize_many
+      wand = MagickWand::Wand.new
+      BUTTON_IMAGES.each {|f| wand.read f}
+      assert_nothing_raised { wand.resize(254, 240) }
+      assert_equal(BUTTON_IMAGES.length, wand.length)
+      wand.each do |w|
+         assert_equal([254, 240], wand.dimensions)
+      end
+   end
+
+   def test_resolution
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      assert_equal([72, 72], wand.resolution)
+   end
+
+   def test_rotate
+      wand = MagickWand::Wand.new
+      BUTTON_IMAGES.sort.each {|f| wand. read f }
+      assert_nothing_raised { wand.rotate(30) }
+      wand.each do |w|
+         assert_equal([169, 168], wand.dimensions)
+      end
+
+      # ensure it accepts a background color argument
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      assert_nothing_raised { wand.rotate(30, "black") }
+
+      wand.freeze
+      assert_raise(FreezeError) { wand.rotate(10) }
+   end
+
+
+   def test_sharpen
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+      assert_nothing_raised {wand.sharpen 0, 0.5}
+      assert_nothing_raised {wand.sharpen 1, 2, :channel=>"red"}
+      assert_raise(ArgumentError) { wand.sharpen 1, 2, :channel=>"xxx" }
+
+      wand.freeze
+      assert_raise(FreezeError) {wand.sharpen 0, 0.5}
+   end
+
+   # slice is a synonym for []
+   def test_slice
+      wand = MagickWand::Wand.new
+      wand2 = nil
+
+      BUTTON_IMAGES.sort.each {|f| wand. read f }
+      assert_nothing_raised { wand2 = wand.slice(0) }
+      assert_instance_of(MagickWand::Wand, wand2)
+      assert_not_same(wand, wand2)
+      assert_equal(1, wand2.length)
+      assert_match(/Button_0.gif/, wand2.filename)
+
+      assert_nothing_raised { wand2 = wand.slice(1..3) }
+      assert_equal(3, wand2.length)
+      [1, 2, 3].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand2[n].filename)
+      end
+   end
+
+   def test_slice!
+      wand = MagickWand::Wand.new
+      BUTTON_IMAGES.sort.each {|f| wand.read f }
+      initial_length = wand.length
+
+      wand2 = nil
+      assert_nothing_raised { wand2 = wand.slice!(2) }
+      assert_instance_of(MagickWand::Wand, wand2)
+      assert_not_same(wand, wand2)
+      assert_equal(1, wand2.length)
+      assert_equal(initial_length-1, wand.length)
+
+      # image #2 in wand2
+      assert_match(/Button_2.gif/, wand2.filename)
+      # image #2 gone from wand
+      assert_no_match(/Button_2.gif/, wand.filename)
+
+      wand = MagickWand::Wand.new
+      BUTTON_IMAGES.sort.each {|f| wand.read f }
+      initial_length = wand.length
+
+      wand2 = nil
+      assert_nothing_raised { wand2 = wand.slice!(3..6) }
+      assert_not_same(wand, wand2)
+      assert_equal(4, wand2.length)
+      assert_equal(initial_length-4, wand.length)
+
+      # images moved to wand2
+      [3, 4, 5, 6].each_with_index do |m, n|
+         assert_match(/Button_#{m}.gif/, wand2[n].filename)
+      end
+      # images no longer present in wand
+      [3, 4, 5, 6].each_with_index do |m, n|
+         assert_no_match(/Button_#{m}.gif/, wand.filename)
+      end
+
+      wand.freeze
+      assert_raise(FreezeError) { wand.slice!(0) }
+   end
+
+   def test_strip
+      wand = MagickWand::Wand.new
+      wand.add_canvas(20, 20)
+      assert_nothing_raised { wand.strip }
+      wand.freeze
+      assert_raise(FreezeError) { wand.strip }
+   end
+
+   def test_type
+      wand = MagickWand::Wand.new
+      assert_nil(wand.type)
+      wand.read BUTTON_IMAGES[0]
+      assert_equal("PaletteType", wand.type)
+      if RUBY_VERSION != '1.9.1'
+         assert_respond_to(wand, :__type__)
+         # this assertion produces an unsuppressable warning message.
+         #assert_equal("MagickWand::Wand", wand.__type__)
+      end
+   end
+
+   def test_write
+      begin
+         wand = MagickWand::Wand.new
+         wand.read BUTTON_IMAGES[0]
+         assert_nothing_raised { wand.write "#{ENV['TMP']}/test_write.jpg" }
+         File.delete "#{ENV['TMP']}/test_write.jpg"
+
+         wand = MagickWand::Wand.new
+         BUTTON_IMAGES.each {|f| wand.read f}
+         length = wand.length
+         assert_nothing_raised { wand.write("#{ENV['TMP']}/test_write.gif", :adjoin=>true) }
+
+         wand = MagickWand::Wand.new
+         wand.read "#{ENV['TMP']}/test_write.gif"
+         assert_equal(length, wand.length)
+         File.delete "#{ENV['TMP']}/test_write.gif"
+
+         # Write 10 separate files
+         assert_nothing_raised { wand.write "#{ENV['TMP']}/test_write%d.gif", :adjoin=>false }
+         files = Dir["#{ENV['TMP']}/test_write*.gif"]
+         assert_equal(length, files.length)
+
+      ensure
+         File.delete "#{ENV['TMP']}/test_write.gif" rescue nil
+         File.delete(*files) rescue nil
+      end
+   end
+
+   def test_write_errors
+      wand = MagickWand::Wand.new
+      wand.read BUTTON_IMAGES[0]
+
+      # unknown option NOT diagnosed
+      assert_nothing_raised { wand.write "tmp/test_write_errors.gif", :xyzzy=>1 }
+
+      # Write to R/O directory
+      assert_raise(MagickWand::ImageMagickError) { wand.write "/usr/test.jpg" }
+      # bad compression
+      assert_raise(ArgumentError) { wand.write "test.gif", :compress=>"zzz" }
+      # can't convert nil into string
+      assert_raise(TypeError) { wand.write nil }
+      # ensure :type option is accepted and validated
+      assert_raise(ArgumentError) { wand.write "test.gif", :type=>"zzzz" }
+   end
+
+   # test read_string too
+   def test_write_string
+      wand = MagickWand::Wand.new
+      BUTTON_IMAGES.each {|f| wand.read f }
+      s = nil
+      assert_nothing_raised { s = wand.write_string }
+      assert_equal(46278, s.length)
+
+      wand2 = MagickWand::Wand.new
+      assert_nothing_raised { wand2.read_string s }
+      assert_equal(wand.length, wand2.length)
+      wand.length.times do |n|
+         assert_equal(wand[n].format, wand2[n].format)
+         assert_equal(wand[n].dimensions, wand2[n].dimensions)
+         assert_equal(wand[n].page, wand2[n].page)
+      end
+
+      assert_nothing_raised { wand.write_string :format=>"miff", :compress=>"lzw", :quality=>80 }
+
+      # unknown format
+      assert_raise(ArgumentError) { wand.write_string s, :format=>"zzz" }
+   end
+
+end