rmagick 3.1.0 → 3.2.0

data/test/Image3.rb

@@ -2,61 +2,9 @@
 
 require 'rmagick'
 require 'test/unit'
-require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
+require 'test/unit/ui/console/testrunner'
 require 'fileutils'
 
-ColorspaceTypes = [
-  Magick::RGBColorspace,
-  Magick::GRAYColorspace,
-  Magick::TransparentColorspace,
-  Magick::OHTAColorspace,
-  Magick::LabColorspace,
-  Magick::XYZColorspace,
-  Magick::YCbCrColorspace,
-  Magick::YCCColorspace,
-  Magick::YIQColorspace,
-  Magick::YPbPrColorspace,
-  Magick::YUVColorspace,
-  Magick::CMYKColorspace,
-  Magick::SRGBColorspace,
-  Magick::HSLColorspace,
-  Magick::HWBColorspace,
-  Magick::HSBColorspace,
-  Magick::Rec601LumaColorspace,
-  Magick::Rec601YCbCrColorspace,
-  Magick::Rec709LumaColorspace,
-  Magick::Rec709YCbCrColorspace,
-  Magick::LogColorspace,
-  Magick::CMYColorspace
-]
-
-Filters = [
-  Magick::PointFilter,
-  Magick::BoxFilter,
-  Magick::TriangleFilter,
-  Magick::HermiteFilter,
-  Magick::HanningFilter,
-  Magick::HammingFilter,
-  Magick::BlackmanFilter,
-  Magick::GaussianFilter,
-  Magick::QuadraticFilter,
-  Magick::CubicFilter,
-  Magick::CatromFilter,
-  Magick::MitchellFilter,
-  Magick::LanczosFilter,
-  Magick::BesselFilter,
-  Magick::SincFilter,
-  Magick::JincFilter,
-  Magick::SincFastFilter,
-  Magick::LanczosSharpFilter,
-  Magick::Lanczos2Filter,
-  Magick::Lanczos2SharpFilter,
-  Magick::RobidouxFilter,
-  Magick::RobidouxSharpFilter,
-  Magick::CosineFilter,
-  Magick::SplineFilter
-]
-
 class Image3_UT < Test::Unit::TestCase
   def setup
     @img = Magick::Image.new(20, 20)
@@ -86,7 +34,7 @@ class Image3_UT < Test::Unit::TestCase
       assert_instance_of(Magick::Image, res)
     end
 
-    ColorspaceTypes.each do |cs|
+    Magick::ColorspaceType.values do |cs|
       assert_nothing_raised { @img.quantize(256, cs) }
     end
     assert_nothing_raised { @img.quantize(256, Magick::RGBColorspace, false) }
@@ -99,45 +47,15 @@ class Image3_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.quantize('x') }
     assert_raise(TypeError) { @img.quantize(16, 2) }
     assert_raise(TypeError) { @img.quantize(16, Magick::RGBColorspace, false, 'x') }
+    assert_raise(ArgumentError) { @img.quantize(256, Magick::RGBColorspace, true, 2, true, true) }
   end
 
   def test_quantum_operator
-    quantum_ops = [
-      Magick::AddQuantumOperator,
-      Magick::AndQuantumOperator,
-      Magick::DivideQuantumOperator,
-      Magick::LShiftQuantumOperator,
-      Magick::MultiplyQuantumOperator,
-      Magick::OrQuantumOperator,
-      Magick::RShiftQuantumOperator,
-      Magick::SubtractQuantumOperator,
-      Magick::XorQuantumOperator,
-      Magick::PowQuantumOperator,
-      Magick::LogQuantumOperator,
-      Magick::ThresholdQuantumOperator,
-      Magick::ThresholdBlackQuantumOperator,
-      Magick::ThresholdWhiteQuantumOperator,
-      Magick::GaussianNoiseQuantumOperator,
-      Magick::ImpulseNoiseQuantumOperator,
-      Magick::LaplacianNoiseQuantumOperator,
-      Magick::MultiplicativeNoiseQuantumOperator,
-      Magick::PoissonNoiseQuantumOperator,
-      Magick::UniformNoiseQuantumOperator,
-      Magick::CosineQuantumOperator,
-      Magick::SineQuantumOperator,
-      Magick::AddModulusQuantumOperator,
-      Magick::MeanQuantumOperator,
-      Magick::AbsQuantumOperator,
-      Magick::ExponentialQuantumOperator,
-      Magick::MedianQuantumOperator,
-      Magick::SumQuantumOperator
-    ]
-
     assert_nothing_raised do
       res = @img.quantum_operator(Magick::AddQuantumOperator, 2)
       assert_instance_of(Magick::Image, res)
     end
-    quantum_ops.each do |op|
+    Magick::QuantumExpressionOperator.values do |op|
       assert_nothing_raised { @img.quantum_operator(op, 2) }
     end
     assert_nothing_raised { @img.quantum_operator(Magick::AddQuantumOperator, 2, Magick::RedChannel) }
@@ -193,7 +111,9 @@ class Image3_UT < Test::Unit::TestCase
   end
 
   def test_recolor
+    assert_nothing_raised { @img.recolor([1, 1, 2, 1]) }
     assert_raise(TypeError) { @img.recolor('x') }
+    assert_raise(TypeError) { @img.recolor([1, 1, 'x', 1]) }
   end
 
   def test_reduce_noise
@@ -242,7 +162,7 @@ class Image3_UT < Test::Unit::TestCase
     assert_equal(240.0, girl.x_resolution)
     assert_equal(240.0, girl.y_resolution)
 
-    Filters.each do |filter|
+    Magick::FilterType.values do |filter|
       assert_nothing_raised { @img.resample(50, 50, filter) }
     end
     assert_nothing_raised { @img.resample(50, 50, Magick::PointFilter, 2.0) }
@@ -272,7 +192,7 @@ class Image3_UT < Test::Unit::TestCase
     end
     assert_nothing_raised { @img.resize(50, 50) }
 
-    Filters.each do |filter|
+    Magick::FilterType.values do |filter|
       assert_nothing_raised { @img.resize(50, 50, filter) }
     end
     assert_nothing_raised { @img.resize(50, 50, Magick::PointFilter, 2.0) }
@@ -280,6 +200,9 @@ class Image3_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.resize(50, 'x') }
     assert_raise(TypeError) { @img.resize(50, 50, 2) }
     assert_raise(TypeError) { @img.resize(50, 50, Magick::CubicFilter, 'x') }
+    assert_raise(ArgumentError) { @img.resize(-1.0) }
+    assert_raise(ArgumentError) { @img.resize(0, 50) }
+    assert_raise(ArgumentError) { @img.resize(50, 0) }
     assert_raise(ArgumentError) { @img.resize(50, 50, Magick::SincFilter, 2.0, 'x') }
     assert_raise(ArgumentError) { @img.resize }
   end
@@ -428,6 +351,9 @@ class Image3_UT < Test::Unit::TestCase
     end
     assert_nothing_raised { @img.sample(2) }
     assert_raise(ArgumentError) { @img.sample }
+    assert_raise(ArgumentError) { @img.sample(0) }
+    assert_raise(ArgumentError) { @img.sample(0, 25) }
+    assert_raise(ArgumentError) { @img.sample(25, 0) }
     assert_raise(ArgumentError) { @img.sample(25, 25, 25) }
     assert_raise(TypeError) { @img.sample('x') }
     assert_raise(TypeError) { @img.sample(10, 'x') }
@@ -470,17 +396,17 @@ class Image3_UT < Test::Unit::TestCase
     end
 
     # 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::ColorspaceType.values - [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|
       assert_nothing_raised { @img.segment(cs) }
     end
 
@@ -505,8 +431,15 @@ class Image3_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.selective_blur_channel(0, 1, '10%', Magick::RedChannel) }
     assert_nothing_raised { @img.selective_blur_channel(0, 1, '10%', Magick::RedChannel, Magick::BlueChannel) }
     assert_nothing_raised { @img.selective_blur_channel(0, 1, '10%', Magick::RedChannel, Magick::BlueChannel, Magick::GreenChannel) }
-    # not enough arguments
+
     assert_raise(ArgumentError) { @img.selective_blur_channel(0, 1) }
+    assert_raise(TypeError) { @img.selective_blur_channel(0, 1, 0.1, '10%') }
+  end
+
+  def test_separate
+    assert_instance_of(Magick::ImageList, @img.separate)
+    assert_instance_of(Magick::ImageList, @img.separate(Magick::BlueChannel))
+    assert_raise(TypeError) { @img.separate('x') }
   end
 
   def test_sepiatone
@@ -520,23 +453,7 @@ class Image3_UT < Test::Unit::TestCase
   end
 
   def test_set_channel_depth
-    channels = [
-      Magick::RedChannel,
-      Magick::GrayChannel,
-      Magick::CyanChannel,
-      Magick::GreenChannel,
-      Magick::MagentaChannel,
-      Magick::BlueChannel,
-      Magick::YellowChannel,
-      #     Magick::AlphaChannel,
-      Magick::OpacityChannel,
-      Magick::MatteChannel,
-      Magick::BlackChannel,
-      Magick::IndexChannel,
-      Magick::AllChannels
-    ]
-
-    channels.each do |ch|
+    Magick::ChannelType.values do |ch|
       assert_nothing_raised { @img.set_channel_depth(ch, 8) }
     end
   end
@@ -656,6 +573,8 @@ class Image3_UT < Test::Unit::TestCase
       assert_instance_of(Magick::Image, res)
     end
     assert_nothing_raised { @img.solarize(100) }
+    assert_raise(ArgumentError) { @img.solarize(-100) }
+    assert_raise(ArgumentError) { @img.solarize(Magick::QuantumRange + 1) }
     assert_raise(ArgumentError) { @img.solarize(100, 2) }
     assert_raise(TypeError) { @img.solarize('x') }
   end
@@ -687,6 +606,9 @@ class Image3_UT < Test::Unit::TestCase
     args.shift
     args.shift # too few
     assert_raise(ArgumentError) { img.sparse_color(Magick::VoronoiColorInterpolate, *args) }
+
+    args = [30, 10, 'red', 10, 80, 'blue', 70, 60, 'lime', 80, '20', 'yellow']
+    assert_raise(TypeError) { img.sparse_color(Magick::VoronoiColorInterpolate, *args) }
   end
 
   def test_splice
@@ -779,6 +701,14 @@ class Image3_UT < Test::Unit::TestCase
       assert_instance_of(Magick::Image, res)
     end
     assert_raise(NoMethodError) { @img.texture_fill_to_border(@img.columns / 2, @img.rows / 2, 'x') }
+    assert_raise(ArgumentError) { @img.texture_fill_to_border(@img.columns * 2, @img.rows, texture) }
+    assert_raise(ArgumentError) { @img.texture_fill_to_border(@img.columns, @img.rows * 2, texture) }
+
+    Magick::PaintMethod.values do |method|
+      next if [Magick::FillToBorderMethod, Magick::FloodfillMethod].include?(method)
+
+      assert_raise(ArgumentError) { @img.texture_flood_fill('blue', texture, @img.columns, @img.rows, method) }
+    end
   end
 
   def test_texture_floodfill
@@ -806,9 +736,21 @@ class Image3_UT < Test::Unit::TestCase
     end
     assert_nothing_raised { @img.thumbnail(2) }
     assert_raise(ArgumentError) { @img.thumbnail }
+    assert_raise(ArgumentError) { @img.thumbnail(-1.0) }
+    assert_raise(ArgumentError) { @img.thumbnail(0, 25) }
+    assert_raise(ArgumentError) { @img.thumbnail(25, 0) }
     assert_raise(ArgumentError) { @img.thumbnail(25, 25, 25) }
     assert_raise(TypeError) { @img.thumbnail('x') }
     assert_raise(TypeError) { @img.thumbnail(10, 'x') }
+
+    girl = Magick::Image.read(IMAGES_DIR + '/Flower_Hat.jpg').first
+    new_img = girl.thumbnail(200, 200)
+    assert_equal(160, new_img.columns)
+    assert_equal(200, new_img.rows)
+
+    new_img = girl.thumbnail(2)
+    assert_equal(400, new_img.columns)
+    assert_equal(500, new_img.rows)
   end
 
   def test_thumbnail!
@@ -833,6 +775,10 @@ class Image3_UT < Test::Unit::TestCase
     assert_raise(ArgumentError) { @img.tint('red') }
     assert_raise(ArgumentError) { @img.tint('red', 1.0, 1.0, 1.0, 1.0, 1.0) }
     assert_raise(ArgumentError) { @img.tint('x', 1.0) }
+    assert_raise(ArgumentError) { @img.tint('red', -1.0, 1.0, 1.0, 1.0) }
+    assert_raise(ArgumentError) { @img.tint('red', 1.0, -1.0, 1.0, 1.0) }
+    assert_raise(ArgumentError) { @img.tint('red', 1.0, 1.0, -1.0, 1.0) }
+    assert_raise(ArgumentError) { @img.tint('red', 1.0, 1.0, 1.0, -1.0) }
     assert_raise(TypeError) { @img.tint(1.0, 1.0) }
     assert_raise(TypeError) { @img.tint('red', 'green') }
     assert_raise(TypeError) { @img.tint('red', 1.0, 'green') }
@@ -864,11 +810,27 @@ class Image3_UT < Test::Unit::TestCase
     pixel = Magick::Pixel.new
     assert_nothing_raised { @img.transparent(pixel) }
     assert_nothing_raised { @img.transparent('white', Magick::TransparentOpacity) }
+    assert_nothing_raised { @img.transparent('white', alpha: Magick::TransparentAlpha) }
+    assert_raise(ArgumentError) { @img.transparent('white', wrong: Magick::TransparentAlpha) }
+    assert_raise(ArgumentError) { @img.transparent('white', alpha: Magick::TransparentAlpha, extra: Magick::TransparentAlpha) }
     assert_raise(ArgumentError) { @img.transparent('white', Magick::TransparentOpacity, 2) }
     assert_nothing_raised { @img.transparent('white', Magick::QuantumRange / 2) }
     assert_raise(TypeError) { @img.transparent(2) }
   end
 
+  def test_transparent_chroma
+    assert_instance_of(Magick::Image, @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange)))
+    assert_nothing_raised { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange)) }
+    assert_nothing_raised { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange), Magick::TransparentOpacity) }
+    assert_nothing_raised { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange), alpha: Magick::TransparentAlpha) }
+    assert_raise(ArgumentError) { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange), wrong: Magick::TransparentAlpha) }
+    assert_nothing_raised { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange), Magick::TransparentOpacity, true) }
+    assert_nothing_raised { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange), Magick::TransparentOpacity, false) }
+    assert_nothing_raised { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange), false, alpha: Magick::TransparentAlpha) }
+    assert_raise(ArgumentError) { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange), false, wrong: Magick::TransparentAlpha) }
+    assert_raise(ArgumentError) { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange), false, alpha: Magick::TransparentAlpha, extra: Magick::TransparentAlpha) }
+  end
+
   def test_transpose
     assert_nothing_raised do
       res = @img.transpose
@@ -899,13 +861,19 @@ class Image3_UT < Test::Unit::TestCase
     # Can't use the default image because it's a solid color
     hat = Magick::Image.read(IMAGES_DIR + '/Flower_Hat.jpg').first
     assert_nothing_raised do
-      res = hat.trim
-      assert_instance_of(Magick::Image, res)
+      assert_instance_of(Magick::Image, hat.trim)
+      assert_instance_of(Magick::Image, hat.trim(10))
     end
+    assert_raise(ArgumentError) { hat.trim(10, 10) }
+
     assert_nothing_raised do
       res = hat.trim!
       assert_same(hat, res)
+
+      res = hat.trim!(10)
+      assert_same(hat, res)
     end
+    assert_raise(ArgumentError) { hat.trim!(10, 10) }
   end
 
   def test_unique_colors
@@ -928,6 +896,10 @@ class Image3_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.unsharp_mask(2.0, 1.0, 0.50) }
     assert_nothing_raised { @img.unsharp_mask(2.0, 1.0, 0.50, 0.10) }
     assert_raise(ArgumentError) { @img.unsharp_mask(2.0, 1.0, 0.50, 0.10, 2) }
+    assert_raise(ArgumentError) { @img.unsharp_mask(-2.0, 1.0, 0.50, 0.10) }
+    assert_raise(ArgumentError) { @img.unsharp_mask(2.0, 0.0, 0.50, 0.10) }
+    assert_raise(ArgumentError) { @img.unsharp_mask(2.0, 1.0, 0.0, 0.10) }
+    assert_raise(ArgumentError) { @img.unsharp_mask(2.0, 1.0, 0.01, -0.10) }
     assert_raise(TypeError) { @img.unsharp_mask('x') }
     assert_raise(TypeError) { @img.unsharp_mask(2.0, 'x') }
     assert_raise(TypeError) { @img.unsharp_mask(2.0, 1.0, 'x') }
@@ -1000,8 +972,10 @@ class Image3_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.watermark(mark, 0.50, 0.50, Magick::NorthEastGravity, 10) }
     assert_nothing_raised { @img.watermark(mark, 0.50, 0.50, Magick::NorthEastGravity, 10, 10) }
 
+    assert_raise(ArgumentError) { @img.watermark }
     assert_raise(ArgumentError) { @img.watermark(mark, 'x') }
     assert_raise(ArgumentError) { @img.watermark(mark, 0.50, 'x') }
+    assert_raise(ArgumentError) { @img.watermark(mark, 0.50, '1500%') }
     assert_raise(TypeError) { @img.watermark(mark, 0.50, 0.50, 'x') }
     assert_raise(TypeError) { @img.watermark(mark, 0.50, 0.50, Magick::NorthEastGravity, 'x') }
     assert_raise(TypeError) { @img.watermark(mark, 0.50, 0.50, Magick::NorthEastGravity, 10, 'x') }
@@ -1022,12 +996,28 @@ class Image3_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.wave(25, 'x') }
   end
 
+  def test_wet_floor
+    assert_instance_of(Magick::Image, @img.wet_floor)
+    assert_nothing_raised { @img.wet_floor(0.0) }
+    assert_nothing_raised { @img.wet_floor(0.5) }
+    assert_nothing_raised { @img.wet_floor(0.5, 10) }
+    assert_nothing_raised { @img.wet_floor(0.5, 0.0) }
+
+    assert_raise(ArgumentError) { @img.wet_floor(2.0) }
+    assert_raise(ArgumentError) { @img.wet_floor(-2.0) }
+    assert_raise(ArgumentError) { @img.wet_floor(0.5, -1.0) }
+    assert_raise(ArgumentError) { @img.wet_floor(0.5, 10, 0.5) }
+  end
+
   def test_white_threshold
     assert_raise(ArgumentError) { @img.white_threshold }
     assert_nothing_raised { @img.white_threshold(50) }
     assert_nothing_raised { @img.white_threshold(50, 50) }
     assert_nothing_raised { @img.white_threshold(50, 50, 50) }
     assert_nothing_raised { @img.white_threshold(50, 50, 50, 50) }
+    assert_nothing_raised { @img.white_threshold(50, 50, 50, alpha: 50) }
+    assert_raise(ArgumentError) { @img.white_threshold(50, 50, 50, wrong: 50) }
+    assert_raise(ArgumentError) { @img.white_threshold(50, 50, 50, alpha: 50, extra: 50) }
     assert_raise(ArgumentError) { @img.white_threshold(50, 50, 50, 50, 50) }
     res = @img.white_threshold(50)
     assert_instance_of(Magick::Image, res)
@@ -1097,5 +1087,5 @@ end
 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/]
+  Test::Unit::UI::Console::TestRunner.run(Image3UT)
 end

data/test/ImageList1.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'
 
 class ImageList1UT < Test::Unit::TestCase
   def setup
@@ -15,13 +15,56 @@ class ImageList1UT < Test::Unit::TestCase
     @list2 << @list[9]
   end
 
+  def test_combine
+    red   = Magick::Image.new(20, 20) { self.background_color = 'red' }
+    green = Magick::Image.new(20, 20) { self.background_color = 'green' }
+    blue  = Magick::Image.new(20, 20) { self.background_color = 'blue' }
+    black = Magick::Image.new(20, 20) { self.background_color = 'black' }
+    alpha = Magick::Image.new(20, 20) { self.background_color = 'transparent' }
+
+    list = Magick::ImageList.new
+    assert_raise(ArgumentError) { list.combine }
+
+    list << red
+    assert_nothing_raised { list.combine }
+
+    res = list.combine
+    assert_instance_of(Magick::Image, res)
+
+    list << alpha
+    assert_nothing_raised { list.combine }
+
+    list.pop
+    list << green
+    list << blue
+    assert_nothing_raised { list.combine }
+
+    list << alpha
+    assert_nothing_raised { list.combine }
+
+    list.pop
+    list << black
+    assert_nothing_raised { list.combine(Magick::CMYKColorspace) }
+    assert_nothing_raised { list.combine(Magick::SRGBColorspace) }
+
+    list << alpha
+    assert_nothing_raised { list.combine(Magick::CMYKColorspace) }
+    assert_raise(ArgumentError) { list.combine(Magick::SRGBColorspace) }
+
+    list << alpha
+    assert_raise(ArgumentError) { list.combine }
+
+    assert_raise(TypeError) { list.combine(nil) }
+    assert_raise(ArgumentError) { list.combine(Magick::SRGBColorspace, 1) }
+  end
+
   def test_composite_layers
     assert_nothing_raised { @list.composite_layers(@list2) }
     Magick::CompositeOperator.values do |op|
       assert_nothing_raised { @list.composite_layers(@list2, op) }
     end
 
-    assert_raise(ArgumentError) { @list.composite_layers(@list2, Magick::AddCompositeOp, 42) }
+    assert_raise(ArgumentError) { @list.composite_layers(@list2, Magick::ModulusAddCompositeOp, 42) }
   end
 
   def test_delay
@@ -511,14 +554,6 @@ class ImageList1UT < Test::Unit::TestCase
     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
@@ -819,5 +854,5 @@ end
 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/]
+  Test::Unit::UI::Console::TestRunner.run(ImageList1UT)
 end