rmagick 2.16.0 → 3.0.0

data/test/Image3.rb

@@ -2,7 +2,7 @@
 
 require 'rmagick'
 require 'test/unit'
-require 'test/unit/ui/console/testrunner'  unless RUBY_VERSION[/^1\.9|^2/]
+require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
 require 'fileutils'
 
 ColorspaceTypes = [
@@ -48,8 +48,6 @@ Filters = [
 ]
 
 class Image3_UT < Test::Unit::TestCase
-  FreezeError = RUBY_VERSION[/^1\.9|^2/] ? RuntimeError : TypeError
-
   def setup
     @img = Magick::Image.new(20, 20)
     @p = Magick::Image.read(IMAGE_WITH_PROFILE).first.color_profile
@@ -101,7 +99,8 @@ class Image3_UT < Test::Unit::TestCase
       Magick::OrQuantumOperator,
       Magick::RShiftQuantumOperator,
       Magick::SubtractQuantumOperator,
-      Magick::XorQuantumOperator ]
+      Magick::XorQuantumOperator
+    ]
 
     assert_nothing_raised do
       res = @img.quantum_operator(Magick::AddQuantumOperator, 2)
@@ -142,8 +141,8 @@ class Image3_UT < Test::Unit::TestCase
       assert_instance_of(Magick::Image, res)
     end
     assert_nothing_raised { @img.raise(4) }
-    assert_nothing_raised { @img.raise(4,4) }
-    assert_nothing_raised { @img.raise(4,4, false) }
+    assert_nothing_raised { @img.raise(4, 4) }
+    assert_nothing_raised { @img.raise(4, 4, false) }
     assert_raise(TypeError) { @img.raise('x') }
     assert_raise(TypeError) { @img.raise(2, 'x') }
     assert_raise(ArgumentError) { @img.raise(4, 4, false, 2) }
@@ -171,15 +170,15 @@ class Image3_UT < Test::Unit::TestCase
   end
 
   def test_remap
-     remap_image = Magick::Image.new(20,20) {self.background_color = 'green'}
-     assert_nothing_raised { @img.remap(remap_image) }
-     assert_nothing_raised { @img.remap(remap_image, Magick::NoDitherMethod) }
-     assert_nothing_raised { @img.remap(remap_image, Magick::RiemersmaDitherMethod) }
-     assert_nothing_raised { @img.remap(remap_image, Magick::FloydSteinbergDitherMethod) }
+    remap_image = Magick::Image.new(20, 20) { self.background_color = 'green' }
+    assert_nothing_raised { @img.remap(remap_image) }
+    assert_nothing_raised { @img.remap(remap_image, Magick::NoDitherMethod) }
+    assert_nothing_raised { @img.remap(remap_image, Magick::RiemersmaDitherMethod) }
+    assert_nothing_raised { @img.remap(remap_image, Magick::FloydSteinbergDitherMethod) }
 
-     assert_raise(ArgumentError) {@img.remap }
-     assert_raise(ArgumentError) {@img.remap(remap_image, Magick::NoDitherMethod, 1) }
-     assert_raise(TypeError) {@img.remap(remap_image, 1) }
+    assert_raise(ArgumentError) { @img.remap }
+    assert_raise(ArgumentError) { @img.remap(remap_image, Magick::NoDitherMethod, 1) }
+    assert_raise(TypeError) { @img.remap(remap_image, 1) }
   end
 
   def test_resample
@@ -195,7 +194,7 @@ class Image3_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.resample(100) }
     assert_nothing_raised { @img.resample(100, 100) }
 
-    girl = Magick::Image.read(IMAGES_DIR+'/Flower_Hat.jpg').first
+    girl = Magick::Image.read(IMAGES_DIR + '/Flower_Hat.jpg').first
     assert_equal(240.0, girl.x_resolution)
     assert_equal(240.0, girl.y_resolution)
     res = girl.resample(120, 120)
@@ -236,7 +235,7 @@ class Image3_UT < Test::Unit::TestCase
       res = @img.resize(2)
       assert_instance_of(Magick::Image, res)
     end
-    assert_nothing_raised { @img.resize(50,50) }
+    assert_nothing_raised { @img.resize(50, 50) }
 
     Filters.each do |filter|
       assert_nothing_raised { @img.resize(50, 50, filter) }
@@ -260,7 +259,7 @@ class Image3_UT < Test::Unit::TestCase
   end
 
   def test_resize_to_fill_0
-    changed = @img.resize_to_fill(@img.columns,@img.rows)
+    changed = @img.resize_to_fill(@img.columns, @img.rows)
     assert_equal(@img.columns, changed.columns)
     assert_equal(@img.rows, changed.rows)
     assert_not_same(changed, @img)
@@ -268,48 +267,48 @@ class Image3_UT < Test::Unit::TestCase
 
   def test_resize_to_fill_1
     @img = Magick::Image.new(200, 250)
-    @img.resize_to_fill!(100,100)
+    @img.resize_to_fill!(100, 100)
     assert_equal(100, @img.columns)
     assert_equal(100, @img.rows)
   end
 
   def test_resize_to_fill_2
     @img = Magick::Image.new(200, 250)
-    changed = @img.resize_to_fill(300,100)
+    changed = @img.resize_to_fill(300, 100)
     assert_equal(300, changed.columns)
     assert_equal(100, changed.rows)
   end
 
   def test_resize_to_fill_3
     @img = Magick::Image.new(200, 250)
-    changed = @img.resize_to_fill(100,300)
+    changed = @img.resize_to_fill(100, 300)
     assert_equal(100, changed.columns)
     assert_equal(300, changed.rows)
   end
 
   def test_resize_to_fill_4
     @img = Magick::Image.new(200, 250)
-    changed = @img.resize_to_fill(300,350)
+    changed = @img.resize_to_fill(300, 350)
     assert_equal(300, changed.columns)
     assert_equal(350, changed.rows)
   end
 
   def test_resize_to_fill_5
-    changed = @img.resize_to_fill(20,400)
+    changed = @img.resize_to_fill(20, 400)
     assert_equal(20, changed.columns)
     assert_equal(400, changed.rows)
   end
 
   def test_resize_to_fill_6
-    changed = @img.resize_to_fill(3000,400)
+    changed = @img.resize_to_fill(3000, 400)
     assert_equal(3000, changed.columns)
     assert_equal(400, changed.rows)
   end
 
   # Make sure the old name is still around
   def test_resize_to_fill_7
-    assert_block {@img.respond_to? :crop_resized}
-    assert_block {@img.respond_to? :crop_resized!}
+    assert_block { @img.respond_to? :crop_resized }
+    assert_block { @img.respond_to? :crop_resized! }
   end
 
   # 2nd argument defaults to the same value as the 1st argument
@@ -437,22 +436,22 @@ class Image3_UT < Test::Unit::TestCase
 
     # Don't test colorspaces that require PsuedoColor images
     (ColorspaceTypes - [Magick::OHTAColorspace,
-              Magick::LabColorspace,
-              Magick::XYZColorspace,
-              Magick::YCbCrColorspace,
-              Magick::YCCColorspace,
-              Magick::YIQColorspace,
-              Magick::YPbPrColorspace,
-              Magick::YUVColorspace,
-              Magick::Rec601YCbCrColorspace,
-              Magick::Rec709YCbCrColorspace,
-              Magick::LogColorspace]).each do |cs|
+                        Magick::LabColorspace,
+                        Magick::XYZColorspace,
+                        Magick::YCbCrColorspace,
+                        Magick::YCCColorspace,
+                        Magick::YIQColorspace,
+                        Magick::YPbPrColorspace,
+                        Magick::YUVColorspace,
+                        Magick::Rec601YCbCrColorspace,
+                        Magick::Rec709YCbCrColorspace,
+                        Magick::LogColorspace]).each do |cs|
       assert_nothing_raised { @img.segment(cs) }
     end
 
     assert_nothing_raised { @img.segment(Magick::RGBColorspace, 2.0) }
     assert_nothing_raised { @img.segment(Magick::RGBColorspace, 2.0, 2.0) }
-    assert_nothing_raised { @img.segment(Magick::RGBColorspace,  2.0, 2.0, false) }
+    assert_nothing_raised { @img.segment(Magick::RGBColorspace, 2.0, 2.0, false) }
 
     assert_raise(ArgumentError) { @img.segment(Magick::RGBColorspace, 2.0, 2.0, false, 2) }
     assert_raise(TypeError) { @img.segment(2) }
@@ -480,7 +479,7 @@ class Image3_UT < Test::Unit::TestCase
       res = @img.sepiatone
       assert_instance_of(Magick::Image, res)
     end
-    assert_nothing_raised { @img.sepiatone(Magick::QuantumRange*0.80) }
+    assert_nothing_raised { @img.sepiatone(Magick::QuantumRange * 0.80) }
     assert_raise(ArgumentError) { @img.sepiatone(Magick::QuantumRange, 2) }
     assert_raise(TypeError) { @img.sepiatone('x') }
   end
@@ -494,15 +493,16 @@ class Image3_UT < Test::Unit::TestCase
       Magick::MagentaChannel,
       Magick::BlueChannel,
       Magick::YellowChannel,
-    #     Magick::AlphaChannel,
+      #     Magick::AlphaChannel,
       Magick::OpacityChannel,
       Magick::MatteChannel,
       Magick::BlackChannel,
       Magick::IndexChannel,
-      Magick::AllChannels]
+      Magick::AllChannels
+    ]
 
     channels.each do |ch|
-      assert_nothing_raised {@img.set_channel_depth(ch, 8) }
+      assert_nothing_raised { @img.set_channel_depth(ch, 8) }
     end
   end
 
@@ -564,15 +564,15 @@ class Image3_UT < Test::Unit::TestCase
 
   def test_shave
     assert_nothing_raised do
-      res = @img.shave(5,5)
+      res = @img.shave(5, 5)
       assert_instance_of(Magick::Image, res)
     end
     assert_nothing_raised do
-      res = @img.shave!(5,5)
+      res = @img.shave!(5, 5)
       assert_same(@img, res)
     end
     @img.freeze
-    assert_raise(FreezeError) { @img.shave!(2,2) }
+    assert_raise(FreezeError) { @img.shave!(2, 2) }
   end
 
   def test_shear
@@ -631,6 +631,7 @@ class Image3_UT < Test::Unit::TestCase
     # assert good calls work
     Magick::SparseColorMethod.values do |v|
       next if v == Magick::UndefinedColorInterpolate
+
       assert_nothing_raised { img.sparse_color(v, *args) }
     end
     args << Magick::RedChannel
@@ -646,10 +647,10 @@ class Image3_UT < Test::Unit::TestCase
     assert_raise(TypeError) { img.sparse_color(1, *args) }
     # missing arguments
     assert_raise(ArgumentError) { img.sparse_color(Magick::VoronoiColorInterpolate) }
-    args << 10   # too many arguments
+    args << 10 # too many arguments
     assert_raise(ArgumentError) { img.sparse_color(Magick::VoronoiColorInterpolate, *args) }
     args.shift
-    args.shift  # too few
+    args.shift # too few
     assert_raise(ArgumentError) { img.sparse_color(Magick::VoronoiColorInterpolate, *args) }
   end
 
@@ -661,7 +662,7 @@ class Image3_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.splice(0, 0, 2, 2, 'red') }
     red = Magick::Pixel.new(Magick::QuantumRange)
     assert_nothing_raised { @img.splice(0, 0, 2, 2, red) }
-    assert_raise(ArgumentError) { @img.splice(0,0, 2, 2, red, 'x') }
+    assert_raise(ArgumentError) { @img.splice(0, 0, 2, 2, red, 'x') }
     assert_raise(TypeError) { @img.splice([], 0, 2, 2, red) }
     assert_raise(TypeError) { @img.splice(0, 'x', 2, 2, red) }
     assert_raise(TypeError) { @img.splice(0, 0, 'x', 2, red) }
@@ -680,7 +681,7 @@ class Image3_UT < Test::Unit::TestCase
   end
 
   def test_stegano
-    img = Magick::Image.new(100, 100) { self.background_color = 'black' }
+    @img = Magick::Image.new(100, 100) { self.background_color = 'black' }
     watermark = Magick::Image.new(10, 10) { self.background_color = 'white' }
     assert_nothing_raised do
       res = @img.stegano(watermark, 0)
@@ -697,7 +698,7 @@ class Image3_UT < Test::Unit::TestCase
       assert_instance_of(Magick::Image, res)
     end
 
-    img = Magick::Image.new(20,20)
+    img = Magick::Image.new(20, 20)
     img.destroy!
     assert_raise(Magick::DestroyedImageError) { @img.stereo(img) }
   end
@@ -713,8 +714,8 @@ class Image3_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.store_pixels(0, 0, @img.columns, 1, pixels) }
     assert_raise(RangeError) { @img.store_pixels(-1, 0, @img.columns, 1, pixels) }
     assert_raise(RangeError) { @img.store_pixels(0, -1, @img.columns, 1, pixels) }
-    assert_raise(RangeError) { @img.store_pixels(0, 0, 1+@img.columns, 1, pixels) }
-    assert_raise(RangeError) { @img.store_pixels(-1, 0, 1, 1+@img.rows, pixels) }
+    assert_raise(RangeError) { @img.store_pixels(0, 0, 1 + @img.columns, 1, pixels) }
+    assert_raise(RangeError) { @img.store_pixels(-1, 0, 1, 1 + @img.rows, pixels) }
     assert_raise(IndexError) { @img.store_pixels(0, 0, @img.columns, 1, ['x']) }
   end
 
@@ -739,21 +740,21 @@ class Image3_UT < Test::Unit::TestCase
   def test_texture_fill_to_border
     texture = Magick::Image.read('granite:').first
     assert_nothing_raised do
-      res = @img.texture_fill_to_border(@img.columns/2, @img.rows/2, texture)
+      res = @img.texture_fill_to_border(@img.columns / 2, @img.rows / 2, texture)
       assert_instance_of(Magick::Image, res)
     end
-    assert_raise(NoMethodError) { @img.texture_fill_to_border(@img.columns/2, @img.rows/2, 'x') }
+    assert_raise(NoMethodError) { @img.texture_fill_to_border(@img.columns / 2, @img.rows / 2, 'x') }
   end
 
   def test_texture_floodfill
     texture = Magick::Image.read('granite:').first
     assert_nothing_raised do
-      res = @img.texture_floodfill(@img.columns/2, @img.rows/2, texture)
+      res = @img.texture_floodfill(@img.columns / 2, @img.rows / 2, texture)
       assert_instance_of(Magick::Image, res)
     end
-    assert_raise(NoMethodError) { @img.texture_floodfill(@img.columns/2, @img.rows/2, 'x') }
+    assert_raise(NoMethodError) { @img.texture_floodfill(@img.columns / 2, @img.rows / 2, 'x') }
     texture.destroy!
-    assert_raise(Magick::DestroyedImageError) { @img.texture_floodfill(@img.columns/2, @img.rows/2, texture) }
+    assert_raise(Magick::DestroyedImageError) { @img.texture_floodfill(@img.columns / 2, @img.rows / 2, texture) }
   end
 
   def test_threshold
@@ -809,7 +810,7 @@ class Image3_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.transparent(pixel) }
     assert_nothing_raised { @img.transparent('white', Magick::TransparentOpacity) }
     assert_raise(ArgumentError) { @img.transparent('white', Magick::TransparentOpacity, 2) }
-    assert_nothing_raised { @img.transparent('white', Magick::QuantumRange/2) }
+    assert_nothing_raised { @img.transparent('white', Magick::QuantumRange / 2) }
     assert_raise(TypeError) { @img.transparent(2) }
   end
 
@@ -841,7 +842,7 @@ class Image3_UT < Test::Unit::TestCase
 
   def test_trim
     # Can't use the default image because it's a solid color
-    hat = Magick::Image.read(IMAGES_DIR+'/Flower_Hat.jpg').first
+    hat = Magick::Image.read(IMAGES_DIR + '/Flower_Hat.jpg').first
     assert_nothing_raised do
       res = hat.trim
       assert_instance_of(Magick::Image, res)
@@ -929,7 +930,7 @@ class Image3_UT < Test::Unit::TestCase
   end
 
   def test_watermark
-    mark = Magick::Image.new(5,5)
+    mark = Magick::Image.new(5, 5)
     mark_list = Magick::ImageList.new
     mark_list << mark.copy
     assert_nothing_raised { @img.watermark(mark) }
@@ -974,7 +975,7 @@ class Image3_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.white_threshold(50, 50, 50, 50) }
     assert_raise(ArgumentError) { @img.white_threshold(50, 50, 50, 50, 50) }
     res = @img.white_threshold(50)
-    assert_instance_of(Magick::Image,  res)
+    assert_instance_of(Magick::Image, res)
   end
 
   # test write with #format= attribute
@@ -1023,8 +1024,8 @@ class Image3_UT < Test::Unit::TestCase
   end
 end
 
-if __FILE__ == $PROGRAM_NAME
-IMAGES_DIR = '../doc/ex/images'
-FILES = Dir[IMAGES_DIR+'/Button_*.gif']
-Test::Unit::UI::Console::TestRunner.run(Image3_UT) unless RUBY_VERSION[/^1\.9|^2/]
+if $PROGRAM_NAME == __FILE__
+  IMAGES_DIR = '../doc/ex/images'
+  FILES = Dir[IMAGES_DIR + '/Button_*.gif']
+  Test::Unit::UI::Console::TestRunner.run(Image3UT) unless RUBY_VERSION[/^1\.9|^2/]
 end

data/test/ImageList1.rb

@@ -4,803 +4,807 @@ require 'rmagick'
 require 'test/unit'
 require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
 
-class ImageList1_UT < Test::Unit::TestCase
-    def setup
-        @list = Magick::ImageList.new(*FILES[0..9])
-        @list2 = Magick::ImageList.new   # intersection is 5..9
-        @list2 << @list[5]
-        @list2 << @list[6]
-        @list2 << @list[7]
-        @list2 << @list[8]
-        @list2 << @list[9]
-    end
-
-    def test_delay
-        assert_nothing_raised { @list.delay }
-        assert_equal(0, @list.delay)
-        assert_nothing_raised { @list.delay = 20 }
-        assert_equal(20, @list.delay)
-        assert_raise(ArgumentError) { @list.delay = 'x' }
-    end
-
-    def test_ticks_per_second
-        assert_nothing_raised { @list.ticks_per_second }
-        assert_equal(100, @list.ticks_per_second)
-        assert_nothing_raised { @list.ticks_per_second = 1000 }
-        assert_equal(1000, @list.ticks_per_second)
-        assert_raise(ArgumentError) { @list.ticks_per_second = 'x' }
-    end
-
-    def test_iterations
-        assert_nothing_raised { @list.iterations }
-        assert_equal(1, @list.iterations)
-        assert_nothing_raised { @list.iterations = 20 }
-        assert_equal(20, @list.iterations)
-        assert_raise(ArgumentError) { @list.iterations = 'x' }
-    end
-
-    # also tests #size
-    def test_length
-        assert_nothing_raised { @list.length }
-        assert_equal(10, @list.length)
-        assert_raise(NoMethodError) { @list.length = 2 }
-    end
-
-    def test_scene
-        assert_nothing_raised { @list.scene }
-        assert_equal(9, @list.scene)
-        assert_nothing_raised { @list.scene = 0 }
-        assert_equal(0, @list.scene)
-        assert_nothing_raised { @list.scene = 1 }
-        assert_equal(1, @list.scene)
-        assert_raise(IndexError) { @list.scene = -1 }
-        assert_raise(IndexError) { @list.scene = 1000 }
-        assert_raise(IndexError) { @list.scene = nil }
-
-        # allow nil on empty list
-        empty_list = Magick::ImageList.new
-        assert_nothing_raised { empty_list.scene = nil }
-    end
-
-    def test_undef_array_methods
-        assert_raise(NoMethodError) { @list.assoc }
-        assert_raise(NoMethodError) { @list.flatten }
-        assert_raise(NoMethodError) { @list.flatten! }
-        assert_raise(NoMethodError) { @list.join }
-        assert_raise(NoMethodError) { @list.pack }
-        assert_raise(NoMethodError) { @list.rassoc }
-    end
-
-    def test_all
-        q = nil
-        assert_nothing_raised { q = @list.all? { |i| i.class == Magick::Image } }
-        assert(q)
-    end
-
-    def test_any
-        q = nil
-        assert_nothing_raised { q = @list.all? { |i| false } }
-        assert(!q)
-        assert_nothing_raised { q = @list.all? { |i| i.class == Magick::Image } }
-        assert(q)
-    end
-
-    def test_aref
-        assert_nothing_raised { @list[0] }
-        assert_instance_of(Magick::Image, @list[0])
-        assert_instance_of(Magick::Image, @list[-1])
-        assert_instance_of(Magick::ImageList, @list[0,1])
-        assert_instance_of(Magick::ImageList, @list[0..2])
-        assert_nil(@list[20])
-    end
-
-    def test_aset
-        img = Magick::Image.new(5,5)
-        assert_nothing_raised do
-            rv = @list[0] = img
-            assert_same(img, rv)
-            assert_same(img, @list[0])
-            assert_equal(0, @list.scene)
-        end
-
-        # replace 2 images with 1
-        assert_nothing_raised do
-            img = Magick::Image.new(5,5)
-            rv = @list[1,2] = img
-            assert_same(img, rv)
-            assert_equal(9, @list.length)
-            assert_same(img, @list[1])
-            assert_equal(1, @list.scene)
-        end
-
-        # replace 1 image with 2
-        assert_nothing_raised do
-            img = Magick::Image.new(5,5)
-            img2 = Magick::Image.new(5,5)
-            ary = [img, img2]
-            rv = @list[3,1] = ary
-            assert_same(ary, rv)
-            assert_equal(10, @list.length)
-            assert_same(img, @list[3])
-            assert_same(img2, @list[4])
-            assert_equal(4, @list.scene)
-        end
-
-        assert_nothing_raised do
-            img = Magick::Image.new(5,5)
-            rv = @list[5..6] = img
-            assert_same(img, rv)
-            assert_equal(9, @list.length)
-            assert_same(img, @list[5])
-            assert_equal(5, @list.scene)
-        end
-
-        assert_nothing_raised do
-            ary = [img, img]
-            rv = @list[7..8] = ary
-            assert_same(ary, rv)
-            assert_equal(9, @list.length)
-            assert_same(img, @list[7])
-            assert_same(img, @list[8])
-            assert_equal(8, @list.scene)
-        end
-
-        assert_nothing_raised do
-            rv = @list[-1] = img
-            assert_same(img, rv)
-            assert_equal(9, @list.length)
-            assert_same(img, @list[8])
-            assert_equal(8, @list.scene)
-        end
-
-        assert_raise(ArgumentError) { @list[0] = 1 }
-        assert_raise(ArgumentError) { @list[0,1] = [1,2] }
-        assert_raise(ArgumentError) { @list[2..3] = 'x' }
-    end
-
-    def test_and
-        @list.scene = 7
-        cur = @list.cur_image
-        assert_nothing_raised do
-            res = @list & @list2
-            assert_instance_of(Magick::ImageList, res)
-            assert_not_same(res, @list)
-            assert_not_same(res, @list2)
-            assert_equal(5, res.length)
-            assert_equal(2, res.scene)
-            assert_same(cur, res.cur_image)
-        end
-
-        # current scene not in the result, set result scene to last image in result
-        @list.scene = 2
-        assert_nothing_raised do
-            res = @list & @list2
-            assert_instance_of(Magick::ImageList, res)
-            assert_equal(4, res.scene)
-        end
-
-        assert_raise(ArgumentError) { @list & 2 }
-    end
-
-    def test_at
-         assert_nothing_raised do
-            cur = @list.cur_image
-            img = @list.at(7)
-            assert_same(img, @list[7])
-            assert_same(cur, @list.cur_image)
-            img = @list.at(10)
-            assert_nil(img)
-            assert_same(cur, @list.cur_image)
-            img = @list.at(-1)
-            assert_same(img, @list[9])
-            assert_same(cur, @list.cur_image)
-         end
-    end
-
-    def test_star
-        @list.scene = 7
-        cur = @list.cur_image
-        assert_nothing_raised do
-            res = @list * 2
-            assert_instance_of(Magick::ImageList, res)
-            assert_equal(20, res.length)
-            assert_not_same(res, @list)
-            assert_same(cur, res.cur_image)
-        end
-
-        assert_raise(ArgumentError) { @list * 'x' }
-    end
-
-    def test_plus
-        @list.scene = 7
-        cur = @list.cur_image
-        assert_nothing_raised do
-            res = @list + @list2
-            assert_instance_of(Magick::ImageList, res)
-            assert_equal(15, res.length)
-            assert_not_same(res, @list)
-            assert_not_same(res, @list2)
-            assert_same(cur, res.cur_image)
-        end
-
-        assert_raise(ArgumentError) { @list + [2] }
-    end
-
-    def test_minus
-        @list.scene = 0
-        cur = @list.cur_image
-        assert_nothing_raised do
-            res = @list - @list2
-            assert_instance_of(Magick::ImageList, res)
-            assert_equal(5, res.length)
-            assert_not_same(res, @list)
-            assert_not_same(res, @list2)
-            assert_same(cur, res.cur_image)
-        end
-
-        # current scene not in result - set result scene to last image in result
-        @list.scene = 7
-        cur = @list.cur_image
-        assert_nothing_raised do
-            res = @list - @list2
-            assert_instance_of(Magick::ImageList, res)
-            assert_equal(5, res.length)
-            assert_equal(4, res.scene)
-        end
-    end
-
-    def test_catenate
-        assert_nothing_raised do
-            @list2.each { |img| @list << img }
-            assert_equal(15, @list.length)
-            assert_equal(14, @list.scene)
-        end
-
-        assert_raise(ArgumentError) { @list << 2 }
-        assert_raise(ArgumentError) { @list << [2] }
-    end
-
-    def test_or
-        assert_nothing_raised do
-            @list.scene = 7
-            # The or of these two lists should be the same as @list
-            # but not be the *same* list
-            res = @list | @list2
-            assert_instance_of(Magick::ImageList, res)
-            assert_not_same(res, @list)
-            assert_not_same(res, @list2)
-            assert_equal(res, @list)
-        end
-
-        # Try or'ing disjoint lists
-        temp_list = Magick::ImageList.new(*FILES[10..14])
-        res = @list | temp_list
-        assert_instance_of(Magick::ImageList, res)
-        assert_equal(15, res.length)
-        assert_equal(7, res.scene)
-
-        assert_raise(ArgumentError) { @list | 2 }
-        assert_raise(ArgumentError) { @list | [2] }
-    end
-
-    def test_clear
-        assert_nothing_raised { @list.clear }
-        assert_instance_of(Magick::ImageList, @list)
-        assert_equal(0, @list.length)
-        assert_nil(@list.scene)
-    end
-
-    def test_collect
-        assert_nothing_raised do
-            cur = @list.cur_image
-            scene = @list.scene
-            res = @list.collect { |img| img.negate }
-            assert_instance_of(Magick::ImageList, res)
-            assert_not_same(res, @list)
-            assert_equal(scene, res.scene)
-        end
-        assert_nothing_raised do
-            scene = @list.scene
-            @list.collect! { |img| img.negate }
-            assert_instance_of(Magick::ImageList, @list)
-            assert_equal(scene, @list.scene)
-        end
-    end
-
-    def test_compact
-        assert_nothing_raised do
-            res = @list.compact
-            assert_not_same(res, @list)
-            assert_equal(res, @list)
-        end
-        assert_nothing_raised do
-            res = @list
-            @list.compact!
-            assert_instance_of(Magick::ImageList, @list)
-            assert_equal(res, @list)
-            assert_same(res, @list)
-        end
-    end
-
-    def test_concat
-        assert_nothing_raised do
-            res = @list.concat(@list2)
-            assert_instance_of(Magick::ImageList, res)
-            assert_equal(15, res.length)
-            assert_same(res[14], res.cur_image)
-        end
-        assert_raise(ArgumentError) { res = @list.concat(2) }
-        assert_raise(ArgumentError) { res = @list.concat([2]) }
-    end
-
-    def test_delete
-        assert_nothing_raised do
-            cur = @list.cur_image
-            img = @list[7]
-            assert_same(img, @list.delete(img))
-            assert_equal(9, @list.length)
-            assert_same(cur, @list.cur_image)
-
-            # Try deleting the current image.
-            assert_same(cur, @list.delete(cur))
-            assert_same(@list[-1], @list.cur_image)
-
-            assert_raise(ArgumentError) { @list.delete(2) }
-            assert_raise(ArgumentError) { @list.delete([2]) }
-
-            # Try deleting something that isn't in the list.
-            # Should return the value of the block.
-            assert_nothing_raised do
-                img = Magick::Image.read(FILES[10]).first
-                res = @list.delete(img) { 1 }
-                assert_equal(1, res)
-            end
-        end
-    end
-
-    def test_delete_at
-        @list.scene = 7
-        cur = @list.cur_image
-        assert_nothing_raised { @list.delete_at(9) }
-        assert_same(cur, @list.cur_image)
-        assert_nothing_raised { @list.delete_at(7) }
-        assert_same(@list[-1], @list.cur_image)
-    end
-
-    def test_delete_if
-        @list.scene = 7
-        cur = @list.cur_image
-        assert_nothing_raised do
-            @list.delete_if { |img| img.filename =~ /5/ }
-            assert_instance_of(Magick::ImageList, @list)
-            assert_equal(9, @list.length)
-            assert_same(cur, @list.cur_image)
-        end
-
-        # Delete the current image
-        assert_nothing_raised do
-            @list.delete_if { |img| img.filename =~ /7/ }
-            assert_instance_of(Magick::ImageList, @list)
-            assert_equal(8, @list.length)
-            assert_same(@list[-1], @list.cur_image)
-        end
-    end
-
-    # defined by Enumerable
-    def test_enumerables
-      assert_nothing_raised { @list.detect { true } }
+class ImageList1UT < Test::Unit::TestCase
+  def setup
+    @list = Magick::ImageList.new(*FILES[0..9])
+    @list2 = Magick::ImageList.new # intersection is 5..9
+    @list2 << @list[5]
+    @list2 << @list[6]
+    @list2 << @list[7]
+    @list2 << @list[8]
+    @list2 << @list[9]
+  end
+
+  def test_delay
+    assert_nothing_raised { @list.delay }
+    assert_equal(0, @list.delay)
+    assert_nothing_raised { @list.delay = 20 }
+    assert_equal(20, @list.delay)
+    assert_raise(ArgumentError) { @list.delay = 'x' }
+  end
+
+  def test_ticks_per_second
+    assert_nothing_raised { @list.ticks_per_second }
+    assert_equal(100, @list.ticks_per_second)
+    assert_nothing_raised { @list.ticks_per_second = 1000 }
+    assert_equal(1000, @list.ticks_per_second)
+    assert_raise(ArgumentError) { @list.ticks_per_second = 'x' }
+  end
+
+  def test_iterations
+    assert_nothing_raised { @list.iterations }
+    assert_equal(1, @list.iterations)
+    assert_nothing_raised { @list.iterations = 20 }
+    assert_equal(20, @list.iterations)
+    assert_raise(ArgumentError) { @list.iterations = 'x' }
+  end
+
+  # also tests #size
+  def test_length
+    assert_nothing_raised { @list.length }
+    assert_equal(10, @list.length)
+    assert_raise(NoMethodError) { @list.length = 2 }
+  end
+
+  def test_scene
+    assert_nothing_raised { @list.scene }
+    assert_equal(9, @list.scene)
+    assert_nothing_raised { @list.scene = 0 }
+    assert_equal(0, @list.scene)
+    assert_nothing_raised { @list.scene = 1 }
+    assert_equal(1, @list.scene)
+    assert_raise(IndexError) { @list.scene = -1 }
+    assert_raise(IndexError) { @list.scene = 1000 }
+    assert_raise(IndexError) { @list.scene = nil }
+
+    # allow nil on empty list
+    empty_list = Magick::ImageList.new
+    assert_nothing_raised { empty_list.scene = nil }
+  end
+
+  def test_undef_array_methods
+    assert_raise(NoMethodError) { @list.assoc }
+    assert_raise(NoMethodError) { @list.flatten }
+    assert_raise(NoMethodError) { @list.flatten! }
+    assert_raise(NoMethodError) { @list.join }
+    assert_raise(NoMethodError) { @list.pack }
+    assert_raise(NoMethodError) { @list.rassoc }
+  end
+
+  def test_all
+    q = nil
+    assert_nothing_raised { q = @list.all? { |i| i.class == Magick::Image } }
+    assert(q)
+  end
+
+  def test_any
+    q = nil
+    assert_nothing_raised { q = @list.all? { |_i| false } }
+    assert(!q)
+    assert_nothing_raised { q = @list.all? { |i| i.class == Magick::Image } }
+    assert(q)
+  end
+
+  def test_aref
+    assert_nothing_raised { @list[0] }
+    assert_instance_of(Magick::Image, @list[0])
+    assert_instance_of(Magick::Image, @list[-1])
+    assert_instance_of(Magick::ImageList, @list[0, 1])
+    assert_instance_of(Magick::ImageList, @list[0..2])
+    assert_nil(@list[20])
+  end
+
+  def test_aset
+    img = Magick::Image.new(5, 5)
+    assert_nothing_raised do
+      rv = @list[0] = img
+      assert_same(img, rv)
+      assert_same(img, @list[0])
+      assert_equal(0, @list.scene)
+    end
+
+    # replace 2 images with 1
+    assert_nothing_raised do
+      img = Magick::Image.new(5, 5)
+      rv = @list[1, 2] = img
+      assert_same(img, rv)
+      assert_equal(9, @list.length)
+      assert_same(img, @list[1])
+      assert_equal(1, @list.scene)
+    end
+
+    # replace 1 image with 2
+    assert_nothing_raised do
+      img = Magick::Image.new(5, 5)
+      img2 = Magick::Image.new(5, 5)
+      ary = [img, img2]
+      rv = @list[3, 1] = ary
+      assert_same(ary, rv)
+      assert_equal(10, @list.length)
+      assert_same(img, @list[3])
+      assert_same(img2, @list[4])
+      assert_equal(4, @list.scene)
+    end
+
+    assert_nothing_raised do
+      img = Magick::Image.new(5, 5)
+      rv = @list[5..6] = img
+      assert_same(img, rv)
+      assert_equal(9, @list.length)
+      assert_same(img, @list[5])
+      assert_equal(5, @list.scene)
+    end
+
+    assert_nothing_raised do
+      ary = [img, img]
+      rv = @list[7..8] = ary
+      assert_same(ary, rv)
+      assert_equal(9, @list.length)
+      assert_same(img, @list[7])
+      assert_same(img, @list[8])
+      assert_equal(8, @list.scene)
+    end
+
+    assert_nothing_raised do
+      rv = @list[-1] = img
+      assert_same(img, rv)
+      assert_equal(9, @list.length)
+      assert_same(img, @list[8])
+      assert_equal(8, @list.scene)
+    end
+
+    assert_raise(ArgumentError) { @list[0] = 1 }
+    assert_raise(ArgumentError) { @list[0, 1] = [1, 2] }
+    assert_raise(ArgumentError) { @list[2..3] = 'x' }
+  end
+
+  def test_and
+    @list.scene = 7
+    cur = @list.cur_image
+    assert_nothing_raised do
+      res = @list & @list2
+      assert_instance_of(Magick::ImageList, res)
+      assert_not_same(res, @list)
+      assert_not_same(res, @list2)
+      assert_equal(5, res.length)
+      assert_equal(2, res.scene)
+      assert_same(cur, res.cur_image)
+    end
+
+    # current scene not in the result, set result scene to last image in result
+    @list.scene = 2
+    assert_nothing_raised do
+      res = @list & @list2
+      assert_instance_of(Magick::ImageList, res)
+      assert_equal(4, res.scene)
+    end
+
+    assert_raise(ArgumentError) { @list & 2 }
+  end
+
+  def test_at
+    assert_nothing_raised do
+      cur = @list.cur_image
+      img = @list.at(7)
+      assert_same(img, @list[7])
+      assert_same(cur, @list.cur_image)
+      img = @list.at(10)
+      assert_nil(img)
+      assert_same(cur, @list.cur_image)
+      img = @list.at(-1)
+      assert_same(img, @list[9])
+      assert_same(cur, @list.cur_image)
+    end
+  end
+
+  def test_star
+    @list.scene = 7
+    cur = @list.cur_image
+    assert_nothing_raised do
+      res = @list * 2
+      assert_instance_of(Magick::ImageList, res)
+      assert_equal(20, res.length)
+      assert_not_same(res, @list)
+      assert_same(cur, res.cur_image)
+    end
+
+    assert_raise(ArgumentError) { @list * 'x' }
+  end
+
+  def test_plus
+    @list.scene = 7
+    cur = @list.cur_image
+    assert_nothing_raised do
+      res = @list + @list2
+      assert_instance_of(Magick::ImageList, res)
+      assert_equal(15, res.length)
+      assert_not_same(res, @list)
+      assert_not_same(res, @list2)
+      assert_same(cur, res.cur_image)
+    end
+
+    assert_raise(ArgumentError) { @list + [2] }
+  end
+
+  def test_minus
+    @list.scene = 0
+    cur = @list.cur_image
+    assert_nothing_raised do
+      res = @list - @list2
+      assert_instance_of(Magick::ImageList, res)
+      assert_equal(5, res.length)
+      assert_not_same(res, @list)
+      assert_not_same(res, @list2)
+      assert_same(cur, res.cur_image)
+    end
+
+    # current scene not in result - set result scene to last image in result
+    @list.scene = 7
+    cur = @list.cur_image
+    assert_nothing_raised do
+      res = @list - @list2
+      assert_instance_of(Magick::ImageList, res)
+      assert_equal(5, res.length)
+      assert_equal(4, res.scene)
+    end
+  end
+
+  def test_catenate
+    assert_nothing_raised do
+      @list2.each { |img| @list << img }
+      assert_equal(15, @list.length)
+      assert_equal(14, @list.scene)
+    end
+
+    assert_raise(ArgumentError) { @list << 2 }
+    assert_raise(ArgumentError) { @list << [2] }
+  end
+
+  def test_or
+    assert_nothing_raised do
+      @list.scene = 7
+      # The or of these two lists should be the same as @list
+      # but not be the *same* list
+      res = @list | @list2
+      assert_instance_of(Magick::ImageList, res)
+      assert_not_same(res, @list)
+      assert_not_same(res, @list2)
+      assert_equal(res, @list)
+    end
+
+    # Try or'ing disjoint lists
+    temp_list = Magick::ImageList.new(*FILES[10..14])
+    res = @list | temp_list
+    assert_instance_of(Magick::ImageList, res)
+    assert_equal(15, res.length)
+    assert_equal(7, res.scene)
+
+    assert_raise(ArgumentError) { @list | 2 }
+    assert_raise(ArgumentError) { @list | [2] }
+  end
+
+  def test_clear
+    assert_nothing_raised { @list.clear }
+    assert_instance_of(Magick::ImageList, @list)
+    assert_equal(0, @list.length)
+    assert_nil(@list.scene)
+  end
+
+  def test_collect
+    assert_nothing_raised do
+      scene = @list.scene
+      res = @list.collect(&:negate)
+      assert_instance_of(Magick::ImageList, res)
+      assert_not_same(res, @list)
+      assert_equal(scene, res.scene)
+    end
+    assert_nothing_raised do
+      scene = @list.scene
+      @list.collect!(&:negate)
+      assert_instance_of(Magick::ImageList, @list)
+      assert_equal(scene, @list.scene)
+    end
+  end
+
+  def test_compact
+    assert_nothing_raised do
+      res = @list.compact
+      assert_not_same(res, @list)
+      assert_equal(res, @list)
+    end
+    assert_nothing_raised do
+      res = @list
+      @list.compact!
+      assert_instance_of(Magick::ImageList, @list)
+      assert_equal(res, @list)
+      assert_same(res, @list)
+    end
+  end
+
+  def test_concat
+    assert_nothing_raised do
+      res = @list.concat(@list2)
+      assert_instance_of(Magick::ImageList, res)
+      assert_equal(15, res.length)
+      assert_same(res[14], res.cur_image)
+    end
+    assert_raise(ArgumentError) { @list.concat(2) }
+    assert_raise(ArgumentError) { @list.concat([2]) }
+  end
+
+  def test_delete
+    assert_nothing_raised do
+      cur = @list.cur_image
+      img = @list[7]
+      assert_same(img, @list.delete(img))
+      assert_equal(9, @list.length)
+      assert_same(cur, @list.cur_image)
+
+      # Try deleting the current image.
+      assert_same(cur, @list.delete(cur))
+      assert_same(@list[-1], @list.cur_image)
+
+      assert_raise(ArgumentError) { @list.delete(2) }
+      assert_raise(ArgumentError) { @list.delete([2]) }
+
+      # Try deleting something that isn't in the list.
+      # Should return the value of the block.
       assert_nothing_raised do
-        @list.each_with_index { |img, n| assert_instance_of(Magick::Image, img) }
-      end
-      assert_nothing_raised { @list.entries }
-      assert_nothing_raised { @list.include?(@list[0]) }
-      assert_nothing_raised { @list.inject(0) { 0 } }
-      assert_nothing_raised { @list.max }
-      assert_nothing_raised { @list.min }
-      assert_nothing_raised { @list.sort }
-      assert_nothing_raised { @list.sort_by {|img| img.signature} }
-      assert_nothing_raised { @list.zip }
-    end
-
-    def test_eql?
-      list2 = @list
-      assert(@list.eql?(list2))
-      list2 = @list.copy
-      assert(! @list.eql?(list2))
-    end
-
-    def test_fill
-        list = @list.copy
-        img = list[0].copy
-        assert_nothing_raised do
-            assert_instance_of(Magick::ImageList, list.fill(img))
-        end
-        list.each {|el| assert_same(el, img) }
-
-        list = @list.copy
-        list.fill(img, 0, 3)
-        0.upto(2) {|i| assert_same(img, list[i]) }
-
-        list = @list.copy
-        list.fill(img, 4..7)
-        4.upto(7) {|i| assert_same(img, list[i]) }
-
-        list = @list.copy
-        list.fill { |i| list[i] = img }
-        list.each {|el| assert_same(el, img) }
-
-        list = @list.copy
-        list.fill(0, 3) { |i| list[i] = img }
-        0.upto(2) {|i| assert_same(img, list[i]) }
-
-        assert_raise(ArgumentError) { list.fill('x', 0) }
-    end
-
-    def test_find
-      assert_nothing_raised { @list.find { true } }
-    end
-
-    def find_all
-        assert_nothing_raised do
-            res = @list.select { |img| img.filename =~ /Button_2/ }
-            assert_instance_of(Magick::ImageList, res)
-            assert_equal(1, res.length)
-            assert_same(res[0], @list[2])
-        end
-    end
-
-    def test_insert
-        assert_nothing_raised do
-            @list.scene = 7
-            cur = @list.cur_image
-            assert_instance_of(Magick::ImageList, @list.insert(1, @list[2]))
-            assert_same(cur, @list.cur_image)
-            @list.insert(1, @list[2], @list[3], @list[4])
-            assert_same(cur, @list.cur_image)
-        end
-
-        assert_raise(ArgumentError) { @list.insert(0, 'x') }
-        assert_raise(ArgumentError) { @list.insert(0, 'x', 'y') }
-    end
-
-    def test_last
-        img = Magick::Image.new(5,5)
-        @list << img
-        img2 = nil
-        assert_nothing_raised { img2 = @list.last }
-        assert_instance_of(Magick::Image, img2)
-        assert_equal(img2, img)
-        img2 = Magick::Image.new(5,5)
-        @list << img2
-        ilist = nil
-        assert_nothing_raised { ilist = @list.last(2) }
-        assert_instance_of(Magick::ImageList, ilist)
-        assert_equal(2, ilist.length)
-        assert_equal(1, ilist.scene)
-        assert_equal(img, ilist[0])
-        assert_equal(img2, ilist[1])
-    end
-
-    def test___map__
-        img = @list[0]
-        assert_nothing_raised do
-            @list.__map__ { |x| img }
-        end
-        assert_instance_of(Magick::ImageList, @list)
-        assert_raise(ArgumentError) { @list.__map__ { 2 } }
-    end
-
-    def test_map!
-        img = @list[0]
-        assert_nothing_raised do
-            @list.map! { img }
-        end
-        assert_instance_of(Magick::ImageList, @list)
-        assert_raise(ArgumentError) { @list.map! { 2 } }
-    end
-
-    unless RUBY_VERSION[/^1\.9|^2/]
-       def test_nitems
-         n = nil
-         assert_nothing_raised { n = @list.nitems }
-         assert_equal(10, n)
-       end
-    end
-
-    def test_partition
-      a = nil
-      n = -1
-      assert_nothing_raised { a = @list.partition { n += 1; (n&1).zero? } }
-      assert_instance_of(Array, a)
-      assert_equal(2, a.size)
-      assert_instance_of(Magick::ImageList, a[0])
-      assert_instance_of(Magick::ImageList, a[1])
-      assert_equal(4, a[0].scene)
-      assert_equal(5, a[0].length)
-      assert_equal(4, a[1].scene)
-      assert_equal(5, a[1].length)
-    end
-
-    def test_pop
-        @list.scene = 8
-        cur = @list.cur_image
-        last = @list[-1]
-        assert_nothing_raised do
-            assert_same(last, @list.pop)
-            assert_same(cur, @list.cur_image)
-        end
-
-        assert_same(cur, @list.pop)
-        assert_same(@list[-1], @list.cur_image)
-    end
-
-    def test_push
-        list = @list
-        img1 = @list[0]
-        img2 = @list[1]
-        assert_nothing_raised { @list.push(img1, img2) }
-        assert_same(list, @list)    # push returns self
-        assert_same(img2, @list.cur_image)
-    end
-
-    def test_reject
-        @list.scene = 7
-        cur = @list.cur_image
-        list = @list
-        assert_nothing_raised do
-            res = @list.reject {|img| img.filename =~ /Button_9/ }
-            assert_equal(9, res.length)
-            assert_instance_of(Magick::ImageList, res)
-            assert_same(cur, res.cur_image)
-        end
-        assert_same(list, @list)
-        assert_same(cur, @list.cur_image)
-
-        # Omit current image from result list - result cur_image s/b last image
-        res = @list.reject {|img| img.filename =~ /Button_7/}
-        assert_equal(9, res.length)
-        assert_same(res[-1], res.cur_image)
-        assert_same(cur, @list.cur_image)
-    end
-
-    def test_reject!
-        @list.scene = 7
-        cur = @list.cur_image
-        assert_nothing_raised do
-            @list.reject! { |img| img.filename =~ /5/ }
-            assert_instance_of(Magick::ImageList, @list)
-            assert_equal(9, @list.length)
-            assert_same(cur, @list.cur_image)
-        end
-
-        # Delete the current image
-        assert_nothing_raised do
-            @list.reject! { |img| img.filename =~ /7/ }
-            assert_instance_of(Magick::ImageList, @list)
-            assert_equal(8, @list.length)
-            assert_same(@list[-1], @list.cur_image)
-        end
-
-        # returns nil if no changes are made
-        assert_nil(@list.reject! { false })
-    end
-
-    def test_replace1
-        # Replace with empty list
-        assert_nothing_raised do
-            res = @list.replace([])
-            assert_same(res, @list)
-            assert_equal(0, @list.length)
-            assert_nil(@list.scene)
-        end
-
-        # Replace empty list with non-empty list
-        temp = Magick::ImageList.new
-        assert_nothing_raised do
-            temp.replace(@list2)
-            assert_equal(5, temp.length)
-            assert_equal(4, temp.scene)
-        end
-
-        # Try to replace with illegal values
-        assert_raise(ArgumentError) { @list.replace([1, 2, 3]) }
-    end
-
-    def test_replace2
-        # Replace with shorter list
-        assert_nothing_raised do
-            @list.scene = 7
-            cur = @list.cur_image
-            res = @list.replace(@list2)
-            assert_same(res, @list)
-            assert_equal(5, @list.length)
-            assert_equal(2, @list.scene)
-            assert_same(cur, @list.cur_image)
-        end
-    end
-
-    def test_replace3
-        # Replace with longer list
-        assert_nothing_raised do
-            @list2.scene = 2
-            cur = @list2.cur_image
-            res = @list2.replace(@list)
-            assert_same(res, @list2)
-            assert_equal(10, @list2.length)
-            assert_equal(7, @list2.scene)
-            assert_same(cur, @list2.cur_image)
-        end
-    end
-
-    def test_reverse
-        list = nil
-        cur = @list.cur_image
-        assert_nothing_raised { list = @list.reverse }
-        assert_equal(list.length, @list.length)
-        assert_same(cur, @list.cur_image)
-    end
-
-    def test_reverse!
-        list = @list
-        cur = @list.cur_image
-        assert_nothing_raised { @list.reverse! }
-        assert_same(list, @list)
-        assert_same(cur, @list.cur_image)
-    end
-
-    # Just validate its existence
-    def test_reverse_each
-      assert_nothing_raised do
-          @list.reverse_each { |img| assert_instance_of(Magick::Image, img) }
+        img = Magick::Image.read(FILES[10]).first
+        res = @list.delete(img) { 1 }
+        assert_equal(1, res)
       end
     end
-
-    def test_rindex
-      img = @list.last
+  end
+
+  def test_delete_at
+    @list.scene = 7
+    cur = @list.cur_image
+    assert_nothing_raised { @list.delete_at(9) }
+    assert_same(cur, @list.cur_image)
+    assert_nothing_raised { @list.delete_at(7) }
+    assert_same(@list[-1], @list.cur_image)
+  end
+
+  def test_delete_if
+    @list.scene = 7
+    cur = @list.cur_image
+    assert_nothing_raised do
+      @list.delete_if { |img| img.filename =~ /5/ }
+      assert_instance_of(Magick::ImageList, @list)
+      assert_equal(9, @list.length)
+      assert_same(cur, @list.cur_image)
+    end
+
+    # Delete the current image
+    assert_nothing_raised do
+      @list.delete_if { |img| img.filename =~ /7/ }
+      assert_instance_of(Magick::ImageList, @list)
+      assert_equal(8, @list.length)
+      assert_same(@list[-1], @list.cur_image)
+    end
+  end
+
+  # defined by Enumerable
+  def test_enumerables
+    assert_nothing_raised { @list.detect { true } }
+    assert_nothing_raised do
+      @list.each_with_index { |img, _n| assert_instance_of(Magick::Image, img) }
+    end
+    assert_nothing_raised { @list.entries }
+    assert_nothing_raised { @list.include?(@list[0]) }
+    assert_nothing_raised { @list.inject(0) { 0 } }
+    assert_nothing_raised { @list.max }
+    assert_nothing_raised { @list.min }
+    assert_nothing_raised { @list.sort }
+    assert_nothing_raised { @list.sort_by(&:signature) }
+    assert_nothing_raised { @list.zip }
+  end
+
+  def test_eql?
+    list2 = @list
+    assert(@list.eql?(list2))
+    list2 = @list.copy
+    assert(!@list.eql?(list2))
+  end
+
+  def test_fill
+    list = @list.copy
+    img = list[0].copy
+    assert_nothing_raised do
+      assert_instance_of(Magick::ImageList, list.fill(img))
+    end
+    list.each { |el| assert_same(el, img) }
+
+    list = @list.copy
+    list.fill(img, 0, 3)
+    0.upto(2) { |i| assert_same(img, list[i]) }
+
+    list = @list.copy
+    list.fill(img, 4..7)
+    4.upto(7) { |i| assert_same(img, list[i]) }
+
+    list = @list.copy
+    list.fill { |i| list[i] = img }
+    list.each { |el| assert_same(el, img) }
+
+    list = @list.copy
+    list.fill(0, 3) { |i| list[i] = img }
+    0.upto(2) { |i| assert_same(img, list[i]) }
+
+    assert_raise(ArgumentError) { list.fill('x', 0) }
+  end
+
+  def test_find
+    assert_nothing_raised { @list.find { true } }
+  end
+
+  def find_all
+    assert_nothing_raised do
+      res = @list.select { |img| img.filename =~ /Button_2/ }
+      assert_instance_of(Magick::ImageList, res)
+      assert_equal(1, res.length)
+      assert_same(res[0], @list[2])
+    end
+  end
+
+  def test_insert
+    assert_nothing_raised do
+      @list.scene = 7
+      cur = @list.cur_image
+      assert_instance_of(Magick::ImageList, @list.insert(1, @list[2]))
+      assert_same(cur, @list.cur_image)
+      @list.insert(1, @list[2], @list[3], @list[4])
+      assert_same(cur, @list.cur_image)
+    end
+
+    assert_raise(ArgumentError) { @list.insert(0, 'x') }
+    assert_raise(ArgumentError) { @list.insert(0, 'x', 'y') }
+  end
+
+  def test_last
+    img = Magick::Image.new(5, 5)
+    @list << img
+    img2 = nil
+    assert_nothing_raised { img2 = @list.last }
+    assert_instance_of(Magick::Image, img2)
+    assert_equal(img2, img)
+    img2 = Magick::Image.new(5, 5)
+    @list << img2
+    ilist = nil
+    assert_nothing_raised { ilist = @list.last(2) }
+    assert_instance_of(Magick::ImageList, ilist)
+    assert_equal(2, ilist.length)
+    assert_equal(1, ilist.scene)
+    assert_equal(img, ilist[0])
+    assert_equal(img2, ilist[1])
+  end
+
+  def test___map__
+    img = @list[0]
+    assert_nothing_raised do
+      @list.__map__ { |_x| img }
+    end
+    assert_instance_of(Magick::ImageList, @list)
+    assert_raise(ArgumentError) { @list.__map__ { 2 } }
+  end
+
+  def test_map!
+    img = @list[0]
+    assert_nothing_raised do
+      @list.map! { img }
+    end
+    assert_instance_of(Magick::ImageList, @list)
+    assert_raise(ArgumentError) { @list.map! { 2 } }
+  end
+
+  unless RUBY_VERSION[/^1\.9|^2/]
+    def test_nitems
       n = nil
-      assert_nothing_raised { n = @list.rindex(img) }
-      assert_equal(9, n)
-    end
-
-    def test_select
-        assert_nothing_raised do
-            res = @list.select { |img| img.filename =~ /Button_2/ }
-            assert_instance_of(Magick::ImageList, res)
-            assert_equal(1, res.length)
-            assert_same(res[0], @list[2])
-        end
-    end
-
-    def test_shift
-        assert_nothing_raised do
-            @list.scene = 0
-            res = @list[0]
-            img = @list.shift
-            assert_same(res, img)
-            assert_equal(8, @list.scene)
-        end
-        res = @list[0]
-        img = @list.shift
-        assert_same(res, img)
-        assert_equal(7, @list.scene)
-    end
-
-    def test_slice
-        assert_nothing_raised { @list.slice(0) }
-        assert_nothing_raised { @list.slice(-1) }
-        assert_nothing_raised { @list.slice(0,1) }
-        assert_nothing_raised { @list.slice(0..2) }
-        assert_nothing_raised { @list.slice(20) }
-    end
-
-    def test_slice!
-        @list.scene = 7
-        assert_nothing_raised do
-            img0 = @list[0]
-            img = @list.slice!(0)
-            assert_same(img0, img)
-            assert_equal(9, @list.length)
-            assert_equal(6, @list.scene)
-        end
-        cur = @list.cur_image
-        img = @list.slice!(6)
-        assert_same(cur, img)
-        assert_equal(8, @list.length)
-        assert_equal(7, @list.scene)
-        assert_nothing_raised { @list.slice!(-1) }
-        assert_nothing_raised { @list.slice!(0,1) }
-        assert_nothing_raised { @list.slice!(0..2) }
-        assert_nothing_raised { @list.slice!(20) }
-    end
-
-    # simply ensure existence
-    def test_sort
-      assert_nothing_raised { @list.sort }
-      assert_nothing_raised { @list.sort! }
-    end
-
-    def test_to_a
-      a = nil
-      assert_nothing_raised { a = @list.to_a }
-      assert_instance_of(Array, a)
-      assert_equal(10, a.length)
-    end
-
-    def test_uniq
-        assert_nothing_raised { @list.uniq }
-        assert_instance_of(Magick::ImageList, @list.uniq)
-        @list[1] = @list[0]
-        @list.scene = 7
-        list = @list.uniq
-        assert_equal(9, list.length)
-        assert_equal(6, list.scene)
-        assert_equal(7, @list.scene)
-        @list[6] = @list[7]
-        list = @list.uniq
-        assert_equal(8, list.length)
-        assert_equal(5, list.scene)
-        assert_equal(7, @list.scene)
-    end
-
-    def test_uniq!
-        assert_nothing_raised do
-            assert_nil(@list.uniq!)
-        end
-        @list[1] = @list[0]
-        @list.scene = 7
-        cur = @list.cur_image
-        list = @list
-        @list.uniq!
-        assert_same(list, @list)
-        assert_same(cur, @list.cur_image)
-        assert_equal(6, @list.scene)
-        @list[5] = @list[6]
-        @list.uniq!
-        assert_same(cur, @list.cur_image)
-        assert_equal(5, @list.scene)
-    end
-
-    def test_unshift
-        img = @list[9]
-        @list.scene = 7
-        @list.unshift(img)
-        assert_equal(0, @list.scene)
-        assert_raise(ArgumentError) { @list.unshift(2) }
-        assert_raise(ArgumentError) { @list.unshift([1,2]) }
-    end
-
-    def test_values_at
-        ilist = nil
-        assert_nothing_raised { ilist = @list.values_at(1,3,5) }
-        assert_instance_of(Magick::ImageList, ilist)
-        assert_equal(3, ilist.length)
-        assert_equal(2, ilist.scene)
-    end
-
-    def test_spaceship
-        list2 = @list.copy
-        assert_equal(@list.scene, list2.scene)
-        assert_equal(@list, list2)
-        list2.scene = 0
-        assert_not_equal(@list, list2)
-        list2 = @list.copy
-        list2[9] = list2[0]
-        assert_not_equal(@list, list2)
-        list2 = @list.copy
-        list2 << @list[9]
-        assert_not_equal(@list, list2)
-
-        assert_raise(TypeError) { @list <=> 2 }
-        list = Magick::ImageList.new
-        list2 = Magick::ImageList.new
-        assert_raise(TypeError) { list2 <=> @list }
-        assert_raise(TypeError) { @list <=> list2 }
-        assert_nothing_raised(TypeError) { list <=> list2 }
+      assert_nothing_raised { n = @list.nitems }
+      assert_equal(10, n)
+    end
+  end
+
+  def test_partition
+    a = nil
+    n = -1
+    assert_nothing_raised do
+      a = @list.partition do
+        n += 1
+        (n & 1).zero?
+      end
     end
+    assert_instance_of(Array, a)
+    assert_equal(2, a.size)
+    assert_instance_of(Magick::ImageList, a[0])
+    assert_instance_of(Magick::ImageList, a[1])
+    assert_equal(4, a[0].scene)
+    assert_equal(5, a[0].length)
+    assert_equal(4, a[1].scene)
+    assert_equal(5, a[1].length)
+  end
+
+  def test_pop
+    @list.scene = 8
+    cur = @list.cur_image
+    last = @list[-1]
+    assert_nothing_raised do
+      assert_same(last, @list.pop)
+      assert_same(cur, @list.cur_image)
+    end
+
+    assert_same(cur, @list.pop)
+    assert_same(@list[-1], @list.cur_image)
+  end
+
+  def test_push
+    list = @list
+    img1 = @list[0]
+    img2 = @list[1]
+    assert_nothing_raised { @list.push(img1, img2) }
+    assert_same(list, @list) # push returns self
+    assert_same(img2, @list.cur_image)
+  end
+
+  def test_reject
+    @list.scene = 7
+    cur = @list.cur_image
+    list = @list
+    assert_nothing_raised do
+      res = @list.reject { |img| img.filename =~ /Button_9/ }
+      assert_equal(9, res.length)
+      assert_instance_of(Magick::ImageList, res)
+      assert_same(cur, res.cur_image)
+    end
+    assert_same(list, @list)
+    assert_same(cur, @list.cur_image)
+
+    # Omit current image from result list - result cur_image s/b last image
+    res = @list.reject { |img| img.filename =~ /Button_7/ }
+    assert_equal(9, res.length)
+    assert_same(res[-1], res.cur_image)
+    assert_same(cur, @list.cur_image)
+  end
+
+  def test_reject!
+    @list.scene = 7
+    cur = @list.cur_image
+    assert_nothing_raised do
+      @list.reject! { |img| img.filename =~ /5/ }
+      assert_instance_of(Magick::ImageList, @list)
+      assert_equal(9, @list.length)
+      assert_same(cur, @list.cur_image)
+    end
+
+    # Delete the current image
+    assert_nothing_raised do
+      @list.reject! { |img| img.filename =~ /7/ }
+      assert_instance_of(Magick::ImageList, @list)
+      assert_equal(8, @list.length)
+      assert_same(@list[-1], @list.cur_image)
+    end
+
+    # returns nil if no changes are made
+    assert_nil(@list.reject! { false })
+  end
+
+  def test_replace1
+    # Replace with empty list
+    assert_nothing_raised do
+      res = @list.replace([])
+      assert_same(res, @list)
+      assert_equal(0, @list.length)
+      assert_nil(@list.scene)
+    end
+
+    # Replace empty list with non-empty list
+    temp = Magick::ImageList.new
+    assert_nothing_raised do
+      temp.replace(@list2)
+      assert_equal(5, temp.length)
+      assert_equal(4, temp.scene)
+    end
+
+    # Try to replace with illegal values
+    assert_raise(ArgumentError) { @list.replace([1, 2, 3]) }
+  end
+
+  def test_replace2
+    # Replace with shorter list
+    assert_nothing_raised do
+      @list.scene = 7
+      cur = @list.cur_image
+      res = @list.replace(@list2)
+      assert_same(res, @list)
+      assert_equal(5, @list.length)
+      assert_equal(2, @list.scene)
+      assert_same(cur, @list.cur_image)
+    end
+  end
+
+  def test_replace3
+    # Replace with longer list
+    assert_nothing_raised do
+      @list2.scene = 2
+      cur = @list2.cur_image
+      res = @list2.replace(@list)
+      assert_same(res, @list2)
+      assert_equal(10, @list2.length)
+      assert_equal(7, @list2.scene)
+      assert_same(cur, @list2.cur_image)
+    end
+  end
+
+  def test_reverse
+    list = nil
+    cur = @list.cur_image
+    assert_nothing_raised { list = @list.reverse }
+    assert_equal(list.length, @list.length)
+    assert_same(cur, @list.cur_image)
+  end
+
+  def test_reverse!
+    list = @list
+    cur = @list.cur_image
+    assert_nothing_raised { @list.reverse! }
+    assert_same(list, @list)
+    assert_same(cur, @list.cur_image)
+  end
+
+  # Just validate its existence
+  def test_reverse_each
+    assert_nothing_raised do
+      @list.reverse_each { |img| assert_instance_of(Magick::Image, img) }
+    end
+  end
+
+  def test_rindex
+    img = @list.last
+    n = nil
+    assert_nothing_raised { n = @list.rindex(img) }
+    assert_equal(9, n)
+  end
+
+  def test_select
+    assert_nothing_raised do
+      res = @list.select { |img| img.filename =~ /Button_2/ }
+      assert_instance_of(Magick::ImageList, res)
+      assert_equal(1, res.length)
+      assert_same(res[0], @list[2])
+    end
+  end
+
+  def test_shift
+    assert_nothing_raised do
+      @list.scene = 0
+      res = @list[0]
+      img = @list.shift
+      assert_same(res, img)
+      assert_equal(8, @list.scene)
+    end
+    res = @list[0]
+    img = @list.shift
+    assert_same(res, img)
+    assert_equal(7, @list.scene)
+  end
+
+  def test_slice
+    assert_nothing_raised { @list.slice(0) }
+    assert_nothing_raised { @list.slice(-1) }
+    assert_nothing_raised { @list.slice(0, 1) }
+    assert_nothing_raised { @list.slice(0..2) }
+    assert_nothing_raised { @list.slice(20) }
+  end
+
+  def test_slice!
+    @list.scene = 7
+    assert_nothing_raised do
+      img0 = @list[0]
+      img = @list.slice!(0)
+      assert_same(img0, img)
+      assert_equal(9, @list.length)
+      assert_equal(6, @list.scene)
+    end
+    cur = @list.cur_image
+    img = @list.slice!(6)
+    assert_same(cur, img)
+    assert_equal(8, @list.length)
+    assert_equal(7, @list.scene)
+    assert_nothing_raised { @list.slice!(-1) }
+    assert_nothing_raised { @list.slice!(0, 1) }
+    assert_nothing_raised { @list.slice!(0..2) }
+    assert_nothing_raised { @list.slice!(20) }
+  end
+
+  # simply ensure existence
+  def test_sort
+    assert_nothing_raised { @list.sort }
+    assert_nothing_raised { @list.sort! }
+  end
+
+  def test_to_a
+    a = nil
+    assert_nothing_raised { a = @list.to_a }
+    assert_instance_of(Array, a)
+    assert_equal(10, a.length)
+  end
+
+  def test_uniq
+    assert_nothing_raised { @list.uniq }
+    assert_instance_of(Magick::ImageList, @list.uniq)
+    @list[1] = @list[0]
+    @list.scene = 7
+    list = @list.uniq
+    assert_equal(9, list.length)
+    assert_equal(6, list.scene)
+    assert_equal(7, @list.scene)
+    @list[6] = @list[7]
+    list = @list.uniq
+    assert_equal(8, list.length)
+    assert_equal(5, list.scene)
+    assert_equal(7, @list.scene)
+  end
+
+  def test_uniq!
+    assert_nothing_raised do
+      assert_nil(@list.uniq!)
+    end
+    @list[1] = @list[0]
+    @list.scene = 7
+    cur = @list.cur_image
+    list = @list
+    @list.uniq!
+    assert_same(list, @list)
+    assert_same(cur, @list.cur_image)
+    assert_equal(6, @list.scene)
+    @list[5] = @list[6]
+    @list.uniq!
+    assert_same(cur, @list.cur_image)
+    assert_equal(5, @list.scene)
+  end
+
+  def test_unshift
+    img = @list[9]
+    @list.scene = 7
+    @list.unshift(img)
+    assert_equal(0, @list.scene)
+    assert_raise(ArgumentError) { @list.unshift(2) }
+    assert_raise(ArgumentError) { @list.unshift([1, 2]) }
+  end
+
+  def test_values_at
+    ilist = nil
+    assert_nothing_raised { ilist = @list.values_at(1, 3, 5) }
+    assert_instance_of(Magick::ImageList, ilist)
+    assert_equal(3, ilist.length)
+    assert_equal(2, ilist.scene)
+  end
+
+  def test_spaceship
+    list2 = @list.copy
+    assert_equal(@list.scene, list2.scene)
+    assert_equal(@list, list2)
+    list2.scene = 0
+    assert_not_equal(@list, list2)
+    list2 = @list.copy
+    list2[9] = list2[0]
+    assert_not_equal(@list, list2)
+    list2 = @list.copy
+    list2 << @list[9]
+    assert_not_equal(@list, list2)
+
+    assert_raise(TypeError) { @list <=> 2 }
+    list = Magick::ImageList.new
+    list2 = Magick::ImageList.new
+    assert_raise(TypeError) { list2 <=> @list }
+    assert_raise(TypeError) { @list <=> list2 }
+    assert_nothing_raised(TypeError) { list <=> list2 }
+  end
 end
 
-if __FILE__ == $PROGRAM_NAME
-IMAGES_DIR = '../doc/ex/images'
-FILES = Dir[IMAGES_DIR+'/Button_*.gif'].sort
-Test::Unit::UI::Console::TestRunner.run(ImageList1_UT) unless RUBY_VERSION[/^1\.9|^2/]
+if $PROGRAM_NAME == __FILE__
+  IMAGES_DIR = '../doc/ex/images'
+  FILES = Dir[IMAGES_DIR + '/Button_*.gif'].sort
+  Test::Unit::UI::Console::TestRunner.run(ImageList1UT) unless RUBY_VERSION[/^1\.9|^2/]
 end