rmagick 3.2.0 → 4.0.0

data/ext/RMagick/rmstruct.c

@@ -361,13 +361,13 @@ Color_to_s(VALUE self)
 
     sprintf(buff, "name=%s, compliance=%s, "
 #if (MAGICKCORE_QUANTUM_DEPTH  == 32 || MAGICKCORE_QUANTUM_DEPTH  == 64) && defined(HAVE_TYPE_LONG_DOUBLE)
-                  "color.red=%Lg, color.green=%Lg, color.blue=%Lg, color.opacity=%Lg ",
+                  "color.red=%Lg, color.green=%Lg, color.blue=%Lg, color.alpha=%Lg ",
 #else
-                  "color.red=%g, color.green=%g, color.blue=%g, color.opacity=%g ",
+                  "color.red=%g, color.green=%g, color.blue=%g, color.alpha=%g ",
 #endif
                   ci.name,
                   ComplianceType_name(&ci.compliance),
-                  ci.color.red, ci.color.green, ci.color.blue, ci.color.opacity);
+                  ci.color.red, ci.color.green, ci.color.blue, QuantumRange - ci.color.opacity);
 
     destroy_ColorInfo(&ci);
     return rb_str_new2(buff);

data/lib/rmagick/version.rb

@@ -1,5 +1,5 @@
 module Magick
-  VERSION = '3.2.0'
+  VERSION = '4.0.0'
   MIN_RUBY_VERSION = '2.3.0'
   MIN_IM_VERSION = '6.7.7'
 end

data/lib/rmagick_internal.rb

@@ -20,7 +20,6 @@ end
 
 require 'English'
 require 'RMagick2.so'
-require 'obsolete.rb'
 
 module Magick
   @formats = nil
@@ -427,14 +426,6 @@ module Magick
       primitive 'line ' + format('%g,%g %g,%g', start_x, start_y, end_x, end_y)
     end
 
-    # Set matte (make transparent) in image according to the specified
-    # colorization rule
-    def matte(x, y, method)
-      Kernel.warn 'Draw#matte is deprecated. Use Draw#alpha instead.'
-      Kernel.raise ArgumentError, 'Unknown paint method' unless PAINT_METHOD_NAMES.key?(method.to_i)
-      primitive 'matte ' + format('%g,%g, %s', x, y, PAINT_METHOD_NAMES[method.to_i])
-    end
-
     # Specify drawing fill and stroke opacities. If the value is a string
     # ending with a %, the number will be multiplied by 0.01.
     def opacity(opacity)

data/lib/rvg/rvg.rb

@@ -60,10 +60,10 @@ module Magick
     # else, combine it with the background_fill_opacity.
     def bgfill
       if @background_fill.nil?
-        color = Magick::Pixel.new(0, 0, 0, Magick::TransparentOpacity)
+        color = Magick::Pixel.new(0, 0, 0, Magick::OpaqueAlpha)
       else
         color = @background_fill
-        color.opacity = (1.0 - @background_fill_opacity) * Magick::TransparentOpacity
+        color.alpha = @background_fill_opacity * Magick::OpaqueAlpha
       end
       color
     end

data/test/Image1.rb

@@ -321,7 +321,7 @@ class Image1_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.black_threshold(50) }
     assert_nothing_raised { @img.black_threshold(50, 50) }
     assert_nothing_raised { @img.black_threshold(50, 50, 50) }
-    assert_nothing_raised { @img.black_threshold(50, 50, 50, 50) }
+    assert_raise(ArgumentError) { @img.black_threshold(50, 50, 50, 50) }
     assert_nothing_raised { @img.black_threshold(50, 50, 50, alpha: 50) }
     assert_raise(ArgumentError) { @img.black_threshold(50, 50, 50, wrong: 50) }
     assert_raise(ArgumentError) { @img.black_threshold(50, 50, 50, alpha: 50, extra: 50) }
@@ -570,27 +570,6 @@ class Image1_UT < Test::Unit::TestCase
     assert_raise(FreezeError) { @img.color_reset!('red') }
   end
 
-  def test_combine
-    r = Magick::Image.new(20, 20) { self.background_color = 'red' }
-    g = Magick::Image.new(20, 20) { self.background_color = 'green' }
-    b = Magick::Image.new(20, 20) { self.background_color = 'blue' }
-    a = Magick::Image.new(20, 20) { self.background_color = 'transparent' }
-    assert_nothing_raised { Magick::Image.combine(r) }
-    assert_nothing_raised { Magick::Image.combine(r, g) }
-    assert_nothing_raised { Magick::Image.combine(r, g, b) }
-    assert_nothing_raised { Magick::Image.combine(r, g, b, a) }
-    assert_nothing_raised { Magick::Image.combine(nil, g) }
-    assert_nothing_raised { Magick::Image.combine(r, nil, b) }
-    assert_nothing_raised { Magick::Image.combine(r, g, nil, a) }
-    assert_nothing_raised { Magick::Image.combine(r, g, b, nil) }
-    res = Magick::Image.combine(r, g, b)
-    assert_instance_of(Magick::Image, res)
-    assert_raise(ArgumentError) { Magick::Image.combine }
-    assert_raise(ArgumentError) { Magick::Image.combine(nil) }
-    assert_raise(ArgumentError) { Magick::Image.combine(r, g, b, a, r) }
-    assert_raise(TypeError) { Magick::Image.combine(1, g, b, a) }
-  end
-
   def test_compare_channel
     img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
     img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first

data/test/Image2.rb

@@ -387,7 +387,7 @@ class Image2_UT < Test::Unit::TestCase
 
     unmapped = Magick::ImageList.new(IMAGES_DIR + '/Hot_Air_Balloons.jpg', IMAGES_DIR + '/Violin.jpg', IMAGES_DIR + '/Polynesia.jpg')
     map = Magick::ImageList.new 'netscape:'
-    mapped = unmapped.map map, false
+    mapped = unmapped.remap map
     unmapped.each(&:destroy!)
     map.destroy!
     mapped.each(&:destroy!)
@@ -521,6 +521,8 @@ class Image2_UT < Test::Unit::TestCase
   end
 
   def test_each_profile
+    assert_nil(@img.each_profile {})
+
     @img.iptc_profile = 'test profile'
     assert_nothing_raised do
       @img.each_profile do |name, value|
@@ -655,10 +657,6 @@ class Image2_UT < Test::Unit::TestCase
       res = @img.export_pixels_to_str(0, 0, 10, 10, 'I', Magick::ShortPixel)
       assert_equal(10 * 10 * 2, res.length)
     end
-    assert_nothing_raised do
-      res = @img.export_pixels_to_str(0, 0, 10, 10, 'I', Magick::IntegerPixel)
-      assert_equal(10 * 10 * 4, res.length)
-    end
     assert_nothing_raised do
       res = @img.export_pixels_to_str(0, 0, 10, 10, 'I', Magick::LongPixel)
       assert_equal(10 * 10 * [1].pack('L!').length, res.length)
@@ -1088,21 +1086,6 @@ class Image2_UT < Test::Unit::TestCase
     assert_same(@img, res)
   end
 
-  def test_map
-    map = Magick::Image.read('netscape:').first
-    assert_nothing_raised do
-      res = @img.map(map)
-      assert_instance_of(Magick::Image, res)
-      assert_not_same(@img, res)
-    end
-    assert_nothing_raised { @img.map(map, true) }
-    assert_raise(NoMethodError) { @img.map(2) }
-    assert_raise(ArgumentError) { @img.map(map, true, 2) }
-    assert_raise(ArgumentError) { @img.map }
-    map.destroy!
-    assert_raise(Magick::DestroyedImageError) { @img.map(map, true) }
-  end
-
   def test_marshal
     img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
     d = nil
@@ -1345,23 +1328,22 @@ class Image2_UT < Test::Unit::TestCase
     assert_not_nil(res)
     assert_instance_of(Magick::Image, res)
     assert_not_same(res, @img)
-    assert_nothing_raised { @img.paint_transparent('red', Magick::TransparentOpacity) }
+    assert_raise(ArgumentError) { @img.paint_transparent('red', Magick::TransparentAlpha) }
     assert_nothing_raised { @img.paint_transparent('red', alpha: Magick::TransparentAlpha) }
     assert_raise(ArgumentError) { @img.paint_transparent('red', wrong: Magick::TransparentAlpha) }
-    assert_nothing_raised { @img.paint_transparent('red', Magick::TransparentOpacity, true) }
+    assert_raise(ArgumentError) { @img.paint_transparent('red', Magick::TransparentAlpha, true) }
     assert_nothing_raised { @img.paint_transparent('red', true, alpha: Magick::TransparentAlpha) }
     assert_raise(ArgumentError) { @img.paint_transparent('red', true, wrong: Magick::TransparentAlpha) }
     assert_raise(ArgumentError) { @img.paint_transparent('red', true, alpha: Magick::TransparentAlpha, extra: Magick::TransparentAlpha) }
-    assert_nothing_raised { @img.paint_transparent('red', Magick::TransparentOpacity, true, 50) }
+    assert_raise(ArgumentError) { @img.paint_transparent('red', Magick::TransparentAlpha, true, 50) }
     assert_nothing_raised { @img.paint_transparent('red', true, 50, alpha: Magick::TransparentAlpha) }
     assert_raise(ArgumentError) { @img.paint_transparent('red', true, 50, wrong: Magick::TransparentAlpha) }
 
     # Too many arguments
-    assert_raise(ArgumentError) { @img.paint_transparent('red', Magick::TransparentOpacity, true, 50, 50) }
+    assert_raise(ArgumentError) { @img.paint_transparent('red', true, 50, 50, 50) }
     # Not enough
     assert_raise(ArgumentError) { @img.paint_transparent }
-    assert_raise(TypeError) { @img.paint_transparent('red', Magick::TransparentOpacity, true, []) }
-    assert_raise(TypeError) { @img.paint_transparent('red', 'blue') }
+    assert_raise(TypeError) { @img.paint_transparent('red', true, [], alpha: Magick::TransparentAlpha) }
     assert_raise(TypeError) { @img.paint_transparent(50) }
   end
 

data/test/Image3.rb

@@ -690,10 +690,6 @@ class Image3_UT < Test::Unit::TestCase
     end
   end
 
-  def test_sync_profiles
-    assert_nothing_raised { assert(@img.sync_profiles) }
-  end
-
   def test_texture_fill_to_border
     texture = Magick::Image.read('granite:').first
     assert_nothing_raised do
@@ -809,24 +805,23 @@ class Image3_UT < Test::Unit::TestCase
     end
     pixel = Magick::Pixel.new
     assert_nothing_raised { @img.transparent(pixel) }
-    assert_nothing_raised { @img.transparent('white', Magick::TransparentOpacity) }
+    assert_raise(ArgumentError) { @img.transparent('white', Magick::TransparentAlpha) }
     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(ArgumentError) { @img.transparent('white', Magick::TransparentAlpha, 2) }
+    assert_raise(ArgumentError) { @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_raise(ArgumentError) { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange), Magick::TransparentAlpha) }
     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), Magick::TransparentAlpha, true) }
+    assert_nothing_raised { @img.transparent_chroma('white', Magick::Pixel.new(Magick::QuantumRange), true, 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
@@ -1014,7 +1009,7 @@ class Image3_UT < Test::Unit::TestCase
     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_raise(ArgumentError) { @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) }

data/test/ImageList2.rb

@@ -107,37 +107,6 @@ class ImageList2UT < Test::Unit::TestCase
     assert_equal(@ilist, ilist2)
   end
 
-  def test_fx
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_1.gif')
-    assert_nothing_raised { @ilist.fx('1/2') }
-    assert_nothing_raised { @ilist.fx('1/2', Magick::BlueChannel) }
-    assert_nothing_raised { @ilist.fx('1/2', Magick::BlueChannel, Magick::RedChannel) }
-    assert_raise(ArgumentError) { @ilist.fx }
-    assert_raise(ArgumentError) { @ilist.fx(Magick::BlueChannel) }
-    assert_raise(TypeError) { @ilist.fx(1) }
-    assert_raise(TypeError) { @ilist.fx('1/2', 1) }
-  end
-
-  def test_map
-    map = Magick::Image.read('netscape:')[0]
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_1.gif')
-    assert_nothing_raised do
-      img = @ilist.map(map)
-      assert_instance_of(Magick::ImageList, img)
-    end
-    assert_nothing_raised do
-      img = @ilist.map(map, true)
-      assert_instance_of(Magick::ImageList, img)
-    end
-
-    map = Magick::ImageList.new('netscape:')
-    img = @ilist.map(map, true)
-    assert_instance_of(Magick::ImageList, img)
-
-    assert_raise(ArgumentError) { @ilist.map }
-    assert_raise(ArgumentError) { @ilist.map(map, true, 42) }
-  end
-
   def test_marshal
     ilist1 = Magick::ImageList.new(*Dir[IMAGES_DIR + '/Button_*.gif'])
     d = nil

data/test/Image_attributes.rb

@@ -23,13 +23,6 @@ class Image_Attributes_UT < Test::Unit::TestCase
     @p = Magick::Image.read(IMAGE_WITH_PROFILE).first.color_profile
   end
 
-  # Test old alpha attribute. New alpha() behavior is tested in Image1.rb
-  def test_alpha
-    assert(@img.alpha)
-    assert_nothing_raised { @img.alpha = Magick::DeactivateAlphaChannel }
-    assert(!@img.alpha)
-  end
-
   def test_background_color
     assert_nothing_raised { @img.background_color }
     assert_equal('white', @img.background_color)
@@ -92,13 +85,6 @@ class Image_Attributes_UT < Test::Unit::TestCase
     assert_equal(false, @img.black_point_compensation)
   end
 
-  def test_blur
-    assert_nothing_raised { @img.blur }
-    assert_equal(1.0, @img.blur)
-    assert_nothing_raised { @img.blur = 2.0 }
-    assert_raise(TypeError) { @img.blur = 'x' }
-  end
-
   def test_border_color
     assert_nothing_raised { @img.border_color }
     # assert_equal("rgb(223,223,223)", @img.border_color)
@@ -406,13 +392,6 @@ class Image_Attributes_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.iptc_profile = 2 }
   end
 
-  def test_matte
-    assert_nothing_raised { @img.matte }
-    assert(@img.matte)
-    assert_nothing_raised { @img.matte = false }
-    assert(!@img.matte)
-  end
-
   def test_mean_error
     assert_nothing_raised { @hat.mean_error_per_pixel }
     assert_nothing_raised { @hat.normalized_mean_error }
@@ -467,12 +446,6 @@ class Image_Attributes_UT < Test::Unit::TestCase
     assert_raise(TypeError) { @img.offset = 'x' }
   end
 
-  def test_opacity
-    assert_raise(NoMethodError) { @img.opacity }
-    assert_nothing_raised { @img.opacity = 50 }
-    assert_raise(TypeError) { @img.opacity = 'x' }
-  end
-
   def test_orientation
     assert_nothing_raised { @img.orientation }
     assert_instance_of(Magick::OrientationType, @img.orientation)
@@ -621,7 +594,6 @@ class Image_Attributes_UT < Test::Unit::TestCase
   def test_frozen
     @img.freeze
     assert_raise(FreezeError) { @img.background_color = 'xxx' }
-    assert_raise(FreezeError) { @img.blur = 50 }
     assert_raise(FreezeError) { @img.border_color = 'xxx' }
     rp = Magick::Point.new(1, 1)
     gp = Magick::Point.new(1, 1)
@@ -645,11 +617,8 @@ class Image_Attributes_UT < Test::Unit::TestCase
     assert_raise(FreezeError) { @img.geometry = '100x100' }
     assert_raise(FreezeError) { @img.interlace = Magick::NoInterlace }
     assert_raise(FreezeError) { @img.iptc_profile = 'xxx' }
-    assert_raise(FreezeError) { @img.mask = @img }
-    assert_raise(FreezeError) { @img.matte = true }
     assert_raise(FreezeError) { @img.monitor = proc { |name, _q, _s| puts name } }
     assert_raise(FreezeError) { @img.offset = 100 }
-    assert_raise(FreezeError) { @img.opacity = 100 }
     assert_raise(FreezeError) { @img.page = Magick::Rectangle.new(1, 2, 3, 4) }
     assert_raise(FreezeError) { @img.rendering_intent = Magick::SaturationIntent }
     assert_raise(FreezeError) { @img.start_loop = true }

data/test/Import_Export.rb

@@ -54,7 +54,6 @@ class ImportExportUT < Test::Unit::TestCase
 
       ipixels = pixels.collect { |px| px * 16_843_009 }
       p = ipixels.pack('I*')
-      import(p, Magick::IntegerPixel)
       import(p, Magick::LongPixel)
 
     when 16
@@ -70,7 +69,6 @@ class ImportExportUT < Test::Unit::TestCase
       ipixels = pixels.collect { |px| px * 65_537 }
       ipixels.pack('I*')
     # Diff s/b 0.0 but never is.
-    # import(p, Magick::IntegerPixel, 430.7834)
     # import(p, Magick::LongPixel, 430.7834)
 
     when 32
@@ -83,7 +81,6 @@ class ImportExportUT < Test::Unit::TestCase
       import(p, Magick::ShortPixel)
 
       p = pixels.pack('I*')
-      import(p, Magick::IntegerPixel)
       import(p, Magick::LongPixel)
       p = pixels.pack('D*') if is_hdri_support
       import(p, Magick::QuantumPixel)
@@ -99,7 +96,6 @@ class ImportExportUT < Test::Unit::TestCase
 
       ipixels = pixels.collect { |px| px / 4_294_967_297 }
       p = ipixels.pack('I*')
-      import(p, Magick::IntegerPixel)
       import(p, Magick::LongPixel)
 
       p = pixels.pack('Q*')

data/test/Info.rb

@@ -234,14 +234,6 @@ class InfoUT < Test::Unit::TestCase
     assert_nothing_raised { @info.gravity = nil }
   end
 
-  def test_group
-    assert_kind_of(Integer, @info.group)
-    assert_nothing_raised { @info.group = 50 }
-    assert_equal(50, @info.group)
-    assert_raise(TypeError) { @info.group = nil }
-    assert_raise(TypeError) { @info.group = 'xxx' }
-  end
-
   def test_image_type
     Magick::ImageType.values.each do |v|
       assert_nothing_raised { @info.image_type = v }

data/test/KernelInfo.rb

@@ -23,20 +23,12 @@ class KernelInfoUT < Test::Unit::TestCase
     assert_raise(TypeError) { Magick::KernelInfo.new(42) }
   end
 
-  def test_zero_nans
-    assert_nil(@kernel.zero_nans)
-  end
-
   def test_unity_add
     assert_nil(@kernel.unity_add(1.0))
     assert_nil(@kernel.unity_add(12))
     assert_raise(TypeError) { @kernel.unity_add('x') }
   end
 
-  def test_show
-    assert_nil(@kernel.show)
-  end
-
   def test_scale
     Magick::GeometryFlags.values do |flag|
       assert_nil(@kernel.scale(1.0, flag))

data/test/Pixel.rb

@@ -41,14 +41,6 @@ class PixelUT < Test::Unit::TestCase
     assert_raise(TypeError) { @pixel.alpha = 'x' }
   end
 
-  def test_opacity
-    assert_nothing_raised { @pixel.opacity = 123 }
-    assert_equal(123, @pixel.opacity)
-    assert_nothing_raised { @pixel.opacity = 255.25 }
-    assert_equal(255, @pixel.opacity)
-    assert_raise(TypeError) { @pixel.opacity = 'x' }
-  end
-
   def test_cyan
     assert_nothing_raised { @pixel.cyan = 123 }
     assert_equal(123, @pixel.cyan)
@@ -118,13 +110,13 @@ class PixelUT < Test::Unit::TestCase
     hash = nil
     assert_nothing_raised { hash = @pixel.hash }
     assert_not_nil(hash)
-    assert_equal(1_385_501_952, hash)
+    assert_equal(1_385_502_079, hash)
 
     p = Magick::Pixel.new
-    assert_equal(0, p.hash)
+    assert_equal(127, p.hash)
 
     p = Magick::Pixel.from_color('red')
-    assert_equal(2_139_095_040, p.hash)
+    assert_equal(2_139_095_167, p.hash)
 
     # Pixel.hash sacrifices the last bit of the opacity channel
     p = Magick::Pixel.new(0, 0, 0, 72)
@@ -198,11 +190,6 @@ class PixelUT < Test::Unit::TestCase
     assert_in_delta(hsla[3], hsla2[3], 0.005, "#{hsla.inspect} != #{hsla2.inspect} with args: #{args.inspect} and #{args2.inspect}")
   end
 
-  def test_from_hsl
-    assert_instance_of(Magick::Pixel, Magick::Pixel.from_HSL([127, 50, 50]))
-    assert_raise(ArgumentError) { Magick::Pixel.from_HSL([127, 50]) }
-  end
-
   def test_intensity
     assert_kind_of(Integer, @pixel.intensity)
   end
@@ -238,25 +225,12 @@ class PixelUT < Test::Unit::TestCase
     pixel.blue += 20
     assert_equal(-1, @pixel <=> pixel)
 
-    @pixel.opacity = 100
-    pixel = @pixel.dup
-    pixel.opacity -= 10
-    assert_equal(1, @pixel <=> pixel)
-    pixel.opacity += 20
-    assert_equal(-1, @pixel <=> pixel)
-
     @pixel.alpha = 100
     pixel = @pixel.dup
     pixel.alpha -= 10
-    assert_equal(-1, @pixel <=> pixel)
-    pixel.alpha += 20
     assert_equal(1, @pixel <=> pixel)
-  end
-
-  def test_to_hsl
-    hsl = @pixel.to_HSL
-    assert_instance_of(Array, hsl)
-    assert_equal(3, hsl.size)
+    pixel.alpha += 20
+    assert_equal(-1, @pixel <=> pixel)
   end
 
   def test_to_color
@@ -280,6 +254,6 @@ class PixelUT < Test::Unit::TestCase
   end
 
   def test_to_s
-    assert_match(/red=\d+, green=\d+, blue=\d+, opacity=\d+/, @pixel.to_s)
+    assert_match(/red=\d+, green=\d+, blue=\d+, alpha=\d+/, @pixel.to_s)
   end
 end