rmagick 3.1.0 → 3.2.0

data/test/Magick.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'
 
 module Magick
   def self._tmpnam_
@@ -10,7 +10,7 @@ module Magick
   end
 end
 
-class Magick::AlphaChannelType
+class Magick::AlphaChannelOption
   def self.enumerators
     @@enumerators
   end
@@ -36,7 +36,7 @@ class MagickUT < Test::Unit::TestCase
     res.each do |c|
       assert_instance_of(Magick::Color, c)
       assert_instance_of(String, c.name)
-      assert_instance_of(Magick::ComplianceType, c.compliance)
+      assert_instance_of(Magick::ComplianceType, c.compliance) unless c.compliance.nil?
       assert_instance_of(Magick::Pixel, c.color)
     end
     Magick.colors { |c| assert_instance_of(Magick::Color, c) }
@@ -47,7 +47,7 @@ class MagickUT < Test::Unit::TestCase
   def test_enumerators
     ary = nil
     assert_nothing_raised do
-      ary = Magick::AlphaChannelType.enumerators
+      ary = Magick::AlphaChannelOption.enumerators
     end
     assert_instance_of(Array, ary)
 
@@ -79,8 +79,8 @@ class MagickUT < Test::Unit::TestCase
       assert_instance_of(String, f.name)
       assert_instance_of(String, f.description) unless f.description.nil?
       assert_instance_of(String, f.family)
-      assert_instance_of(Magick::StyleType, f.style)
-      assert_instance_of(Magick::StretchType, f.stretch)
+      assert_instance_of(Magick::StyleType, f.style) unless f.style.nil?
+      assert_instance_of(Magick::StretchType, f.stretch) unless f.stretch.nil?
       assert_kind_of(Integer, f.weight)
       assert_instance_of(String, f.encoding) unless f.encoding.nil?
       assert_instance_of(String, f.foundry) unless f.foundry.nil?
@@ -89,20 +89,6 @@ class MagickUT < Test::Unit::TestCase
     Magick.fonts { |f| assert_instance_of(Magick::Font, f) }
   end
 
-  def test_formats
-    res = nil
-    assert_nothing_raised { res = Magick.formats }
-    assert_instance_of(Hash, res)
-    res.each do |f, v|
-      assert_instance_of(String, f)
-      assert_instance_of(String, v)
-    end
-    Magick.formats.each do |f, v|
-      assert_not_nil(f)
-      assert_not_nil(v)
-    end
-  end
-
   def test_geometry
     g = nil
     gs = nil
@@ -257,6 +243,14 @@ class MagickUT < Test::Unit::TestCase
     assert_raise(ArgumentError) { Magick::Geometry.new(40, 20, 10, Magick::AreaGeometry) }
   end
 
+  def test_init_formats
+    assert_instance_of(Hash, Magick.init_formats)
+  end
+
+  def test_opaque_alpha
+    assert_equal(Magick::QuantumRange, Magick::OpaqueAlpha)
+  end
+
   def test_set_log_event_mask
     assert_nothing_raised { Magick.set_log_event_mask('Module,Coder') }
   end
@@ -309,21 +303,9 @@ class MagickUT < Test::Unit::TestCase
     assert_raise(ArgumentError) { Magick.limit_resource }
   end
 
-  def test_trace_proc
-    Magick.trace_proc = proc do |which, description, id, method|
-      assert(which == :c)
-      assert_instance_of(String, description)
-      assert_instance_of(String, id)
-      assert_equal(:initialize, method)
-    end
-    begin
-      Magick::Image.new(20, 20)
-    ensure
-      Magick.trace_proc = nil
-    end
+  def test_transparent_alpha
+    assert_equal(0, Magick::TransparentAlpha)
   end
 end
 
-if $PROGRAM_NAME == __FILE__
-  Test::Unit::UI::Console::TestRunner.run(MagickUT) unless RUBY_VERSION[/^1\.9|^2/]
-end
+Test::Unit::UI::Console::TestRunner.run(MagickUT) if $PROGRAM_NAME == __FILE__

data/test/Pixel.rb

@@ -2,13 +2,118 @@
 
 require 'rmagick'
 require 'test/unit'
-require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
+require 'test/unit/ui/console/testrunner'
 
 class PixelUT < Test::Unit::TestCase
   def setup
     @pixel = Magick::Pixel.from_color('brown')
   end
 
+  def test_red
+    assert_nothing_raised { @pixel.red = 123 }
+    assert_equal(123, @pixel.red)
+    assert_nothing_raised { @pixel.red = 255.25 }
+    assert_equal(255, @pixel.red)
+    assert_raise(TypeError) { @pixel.red = 'x' }
+  end
+
+  def test_green
+    assert_nothing_raised { @pixel.green = 123 }
+    assert_equal(123, @pixel.green)
+    assert_nothing_raised { @pixel.green = 255.25 }
+    assert_equal(255, @pixel.green)
+    assert_raise(TypeError) { @pixel.green = 'x' }
+  end
+
+  def test_blue
+    assert_nothing_raised { @pixel.blue = 123 }
+    assert_equal(123, @pixel.blue)
+    assert_nothing_raised { @pixel.blue = 255.25 }
+    assert_equal(255, @pixel.blue)
+    assert_raise(TypeError) { @pixel.blue = 'x' }
+  end
+
+  def test_alpha
+    assert_nothing_raised { @pixel.alpha = 123 }
+    assert_equal(123, @pixel.alpha)
+    assert_nothing_raised { @pixel.alpha = 255.25 }
+    assert_equal(255, @pixel.alpha)
+    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)
+    assert_nothing_raised { @pixel.cyan = 255.25 }
+    assert_equal(255, @pixel.cyan)
+    assert_raise(TypeError) { @pixel.cyan = 'x' }
+  end
+
+  def test_magenta
+    assert_nothing_raised { @pixel.magenta = 123 }
+    assert_equal(123, @pixel.magenta)
+    assert_nothing_raised { @pixel.magenta = 255.25 }
+    assert_equal(255, @pixel.magenta)
+    assert_raise(TypeError) { @pixel.magenta = 'x' }
+  end
+
+  def test_yellow
+    assert_nothing_raised { @pixel.yellow = 123 }
+    assert_equal(123, @pixel.yellow)
+    assert_nothing_raised { @pixel.yellow = 255.25 }
+    assert_equal(255, @pixel.yellow)
+    assert_raise(TypeError) { @pixel.yellow = 'x' }
+  end
+
+  def test_black
+    assert_nothing_raised { @pixel.black = 123 }
+    assert_equal(123, @pixel.black)
+    assert_nothing_raised { @pixel.black = 255.25 }
+    assert_equal(255, @pixel.black)
+    assert_raise(TypeError) { @pixel.black = 'x' }
+  end
+
+  def test_case_eq
+    pixel = Magick::Pixel.from_color('brown')
+    assert_true(@pixel === pixel)
+    assert_false(@pixel === 'red')
+
+    pixel = Magick::Pixel.from_color('red')
+    assert_false(@pixel === pixel)
+  end
+
+  def test_clone
+    pixel = @pixel.clone
+    assert_true(@pixel === pixel)
+    assert_not_equal(@pixel.object_id, pixel.object_id)
+
+    pixel = @pixel.taint.clone
+    assert_true(pixel.tainted?)
+
+    pixel = @pixel.freeze.clone
+    assert_true(pixel.frozen?)
+  end
+
+  def test_dup
+    pixel = @pixel.dup
+    assert_true(@pixel === pixel)
+    assert_not_equal(@pixel.object_id, pixel.object_id)
+
+    pixel = @pixel.taint.dup
+    assert_true(pixel.tainted?)
+
+    pixel = @pixel.freeze.dup
+    assert_false(pixel.frozen?)
+  end
+
   def test_hash
     hash = nil
     assert_nothing_raised { hash = @pixel.hash }
@@ -46,39 +151,38 @@ class PixelUT < Test::Unit::TestCase
     assert_nothing_raised { red.fcmp(blue, 10, Magick::RGBColorspace) }
     assert_raises(TypeError) { red.fcmp(blue, 'x') }
     assert_raises(TypeError) { red.fcmp(blue, 10, 'x') }
+    assert_raises(ArgumentError) { red.fcmp }
+    assert_raises(ArgumentError) { red.fcmp(blue, 10, 'x', 'y') }
   end
 
   def test_from_hsla
     assert_nothing_raised { Magick::Pixel.from_hsla(127, 50, 50) }
     assert_nothing_raised { Magick::Pixel.from_hsla(127, 50, 50, 0) }
-    assert_nothing_raised { Magick::Pixel.from_hsla(127, '50%', 50, 0) }
-    assert_nothing_raised { Magick::Pixel.from_hsla('10%', '50%', 50, 0) }
+    assert_nothing_raised { Magick::Pixel.from_hsla('99%', '100%', '100%', '100%') }
+    assert_nothing_raised { Magick::Pixel.from_hsla(0, 0, 0, 0) }
+    assert_nothing_raised { Magick::Pixel.from_hsla(359, 255, 255, 1.0) }
     assert_raise(TypeError) { Magick::Pixel.from_hsla([], 50, 50, 0) }
     assert_raise(TypeError) { Magick::Pixel.from_hsla(127, [], 50, 0) }
     assert_raise(TypeError) { Magick::Pixel.from_hsla(127, 50, [], 0) }
-    assert_raise(TypeError) { Magick::Pixel.from_hsla(127, 50, 50, []) }
+    assert_raise(ArgumentError) { Magick::Pixel.from_hsla }
+    assert_raise(ArgumentError) { Magick::Pixel.from_hsla(127, 50, 50, 50, 50) }
+    assert_raise(ArgumentError) { Magick::Pixel.from_hsla(-0.01, 0, 0) }
+    assert_raise(ArgumentError) { Magick::Pixel.from_hsla(0, -0.01, 0) }
+    assert_raise(ArgumentError) { Magick::Pixel.from_hsla(0, 0, -0.01) }
+    assert_raise(ArgumentError) { Magick::Pixel.from_hsla(0, 0, 0, -0.01) }
+    assert_raise(RangeError) { Magick::Pixel.from_hsla(0, 0, 0, 1.01) }
+    assert_raise(RangeError) { Magick::Pixel.from_hsla(360, 0, 0) }
+    assert_raise(RangeError) { Magick::Pixel.from_hsla(0, 256, 0) }
+    assert_raise(RangeError) { Magick::Pixel.from_hsla(0, 0, 256) }
     assert_nothing_raised { @pixel.to_hsla }
 
-    18.times do |h|
-      25.times do |s|
-        25.times do |l|
-          5.times do |a|
-            args = [20 * h, s + 25, l + 25, a / 5.0]
-            px = Magick::Pixel.from_hsla(*args)
-            hsla = px.to_hsla
-            # puts "[#{args.join(', ')}] = [#{hsla.join(', ')}]"
-            # Handle cases where the result is very near 360
-            # hsla[0] = ((hsla[0] + 0.005) % 360.0) - 0.005
-            # hsla[1] = ((hsla[1] + 0.005) % 360.0) - 0.005
-            # hsla[2] = ((hsla[2] + 0.005) % 360.0) - 0.005
-            assert_in_delta(args[0], hsla[0], 0.25, "expected #{args.inspect} got #{hsla.inspect}")
-            assert_in_delta(args[1], hsla[1], 0.25, "expected #{args.inspect} got #{hsla.inspect}")
-            assert_in_delta(args[2], hsla[2], 0.25, "expected #{args.inspect} got #{hsla.inspect}")
-            assert_in_delta(args[3], hsla[3], 0.005, "expected #{args.inspect} got #{hsla.inspect}")
-          end
-        end
-      end
-    end
+    args = [200, 125.125, 250.5, 0.6]
+    px = Magick::Pixel.from_hsla(*args)
+    hsla = px.to_hsla
+    assert_in_delta(args[0], hsla[0], 0.25, "expected #{args.inspect} got #{hsla.inspect}")
+    assert_in_delta(args[1], hsla[1], 0.25, "expected #{args.inspect} got #{hsla.inspect}")
+    assert_in_delta(args[2], hsla[2], 0.25, "expected #{args.inspect} got #{hsla.inspect}")
+    assert_in_delta(args[3], hsla[3], 0.005, "expected #{args.inspect} got #{hsla.inspect}")
 
     # test percentages
     args = ['20%', '20%', '20%', '20%']
@@ -94,6 +198,67 @@ 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
+
+  def test_marshal
+    marshal = @pixel.marshal_dump
+
+    pixel = Magick::Pixel.new
+    assert_equal(@pixel, pixel.marshal_load(marshal))
+  end
+
+  def test_spaceship
+    @pixel.red = 100
+    pixel = @pixel.dup
+    assert_equal(0, @pixel <=> pixel)
+
+    pixel.red -= 10
+    assert_equal(1, @pixel <=> pixel)
+    pixel.red += 20
+    assert_equal(-1, @pixel <=> pixel)
+
+    @pixel.green = 100
+    pixel = @pixel.dup
+    pixel.green -= 10
+    assert_equal(1, @pixel <=> pixel)
+    pixel.green += 20
+    assert_equal(-1, @pixel <=> pixel)
+
+    @pixel.blue = 100
+    pixel = @pixel.dup
+    pixel.blue -= 10
+    assert_equal(1, @pixel <=> pixel)
+    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)
+  end
+
   def test_to_color
     assert_nothing_raised { @pixel.to_color(Magick::AllCompliance) }
     assert_nothing_raised { @pixel.to_color(Magick::SVGCompliance) }
@@ -113,4 +278,8 @@ class PixelUT < Test::Unit::TestCase
     assert_raise(ArgumentError) { @pixel.to_color(Magick::AllCompliance, false, 32) }
     assert_raise(TypeError) { @pixel.to_color(1) }
   end
+
+  def test_to_s
+    assert_match(/red=\d+, green=\d+, blue=\d+, opacity=\d+/, @pixel.to_s)
+  end
 end

data/test/PolaroidOptions.rb

@@ -1,6 +1,6 @@
 require 'rmagick'
 require 'test/unit'
-require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
+require 'test/unit/ui/console/testrunner'
 
 class PolaroidOptionsUT < Test::Unit::TestCase
   def setup

data/test/Preview.rb

@@ -2,49 +2,17 @@
 
 require 'rmagick'
 require 'test/unit'
-require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
+require 'test/unit/ui/console/testrunner'
 
 class PreviewUT < Test::Unit::TestCase
   def test_preview
-    preview_types = [
-      Magick::RotatePreview,
-      Magick::ShearPreview,
-      Magick::RollPreview,
-      Magick::HuePreview,
-      Magick::SaturationPreview,
-      Magick::BrightnessPreview,
-      Magick::GammaPreview,
-      Magick::SpiffPreview,
-      Magick::DullPreview,
-      Magick::GrayscalePreview,
-      Magick::QuantizePreview,
-      Magick::DespecklePreview,
-      Magick::ReduceNoisePreview,
-      Magick::AddNoisePreview,
-      Magick::SharpenPreview,
-      Magick::BlurPreview,
-      Magick::ThresholdPreview,
-      Magick::EdgeDetectPreview,
-      Magick::SpreadPreview,
-      Magick::SolarizePreview,
-      Magick::ShadePreview,
-      Magick::RaisePreview,
-      Magick::SegmentPreview,
-      Magick::SwirlPreview,
-      Magick::ImplodePreview,
-      Magick::WavePreview,
-      Magick::OilPaintPreview,
-      Magick::CharcoalDrawingPreview,
-      Magick::JPEGPreview
-    ]
-
     hat = Magick::Image.read(IMAGES_DIR + '/Flower_Hat.jpg').first
     assert_nothing_raised do
       prev = hat.preview(Magick::RotatePreview)
       assert_instance_of(Magick::Image, prev)
     end
     puts "\n"
-    preview_types.each do |type|
+    Magick::PreviewType.values do |type|
       puts "testing #{type}..."
       assert_nothing_raised { hat.preview(type) }
     end
@@ -54,5 +22,5 @@ end
 
 if $PROGRAM_NAME == __FILE__
   IMAGES_DIR = '../doc/ex/images'
-  Test::Unit::UI::Console::TestRunner.run(PreviewUT) unless RUBY_VERSION[/^1\.9|^2/]
+  Test::Unit::UI::Console::TestRunner.run(PreviewUT)
 end

data/test/Struct.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby -w
+
+require 'rmagick'
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+
+class StructUT < Test::Unit::TestCase
+  def test_chromaticity_to_s
+    image = Magick::Image.new(10, 10)
+    assert_match(/red_primary=\(x=.+,y=.+\) green_primary=\(x=.+,y=.+\) blue_primary=\(x=.+,y=.+\) white_point=\(x=.+,y=.+\)/, image.chromaticity.to_s)
+  end
+
+  def test_export_color_info
+    color = Magick.colors[0]
+    assert_instance_of(Magick::Color, color)
+    assert_match(/name=.+, compliance=.+, color.red=.+, color.green=.+, color.blue=.+, color.opacity=.+/, color.to_s)
+  end
+
+  def test_export_type_info
+    font = Magick.fonts[0]
+    assert_match(/^name=.+, description=.+, family=.+, style=.+, stretch=.+, weight=.+, encoding=.*, foundry=.*, format=.*$/, font.to_s)
+  end
+
+  def test_export_point_info
+    draw = Magick::Draw.new
+    metric = draw.get_type_metrics('ABCDEF')
+    assert_match(/^pixels_per_em=\(x=.+,y=.+\) ascent=.+ descent=.+ width=.+ height=.+ max_advance=.+ bounds.x1=.+ bounds.y1=.+ bounds.x2=.+ bounds.y2=.+ underline_position=.+ underline_thickness=.+$/, metric.to_s)
+  end
+
+  def test_primary_info_to_s
+    chrom = Magick::Image.new(10, 10).chromaticity
+    red_primary = chrom.red_primary
+    assert_match(/^x=.+, y=.+, z=.+$/, red_primary.to_s)
+  end
+
+  def test_rectangle_info_to_s
+    rect = Magick::Rectangle.new(10, 20, 30, 40)
+    assert_equal('width=10, height=20, x=30, y=40', rect.to_s)
+  end
+
+  def test_segment_info_to_s
+    segment = Magick::Segment.new(10, 20, 30, 40)
+    assert_equal('x1=10, y1=20, x2=30, y2=40', segment.to_s)
+  end
+end