rmagick 2.16.0 → 3.0.0

data/test/Info.rb

@@ -1,11 +1,10 @@
-
-#!/usr/bin/env ruby -w
+# !/usr/bin/env ruby -w
 
 require 'rmagick'
 require 'test/unit'
 require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
 
-class Info_UT < Test::Unit::TestCase
+class InfoUT < Test::Unit::TestCase
   def setup
     @info = Magick::Image::Info.new
   end
@@ -58,7 +57,7 @@ class Info_UT < Test::Unit::TestCase
     red = Magick::Pixel.new(Magick::QuantumRange)
     assert_nothing_raised { @info.background_color = red }
     assert_equal('red', @info.background_color)
-    img = Magick::Image.new(20,20) { self.background_color = 'red' }
+    img = Magick::Image.new(20, 20) { self.background_color = 'red' }
     assert_equal('red', img.background_color)
   end
 
@@ -67,14 +66,14 @@ class Info_UT < Test::Unit::TestCase
     red = Magick::Pixel.new(Magick::QuantumRange)
     assert_nothing_raised { @info.border_color = red }
     assert_equal('red', @info.border_color)
-    img = Magick::Image.new(20,20) { self.border_color = 'red' }
+    img = Magick::Image.new(20, 20) { self.border_color = 'red' }
     assert_equal('red', img.border_color)
   end
 
   def caption
     assert_nothing_raised { @info.caption = 'string' }
     assert_equal('string', @info.caption)
-    img = Magick::Image.new(20,20) { self.caption = 'string' }
+    img = Magick::Image.new(20, 20) { self.caption = 'string' }
     assert_equal('string', img.caption)
   end
 
@@ -87,8 +86,8 @@ class Info_UT < Test::Unit::TestCase
 
   def test_colorspace
     Magick::ColorspaceType.values.each do |cs|
-    assert_nothing_raised {@info.colorspace = cs}
-    assert_equal(cs, @info.colorspace)
+      assert_nothing_raised { @info.colorspace = cs }
+      assert_equal(cs, @info.colorspace)
     end
   end
 
@@ -99,8 +98,8 @@ class Info_UT < Test::Unit::TestCase
 
   def test_compression
     Magick::CompressionType.values.each do |v|
-    assert_nothing_raised { @info.compression = v }
-    assert_equal(v, @info.compression)
+      assert_nothing_raised { @info.compression = v }
+      assert_equal(v, @info.compression)
     end
   end
 
@@ -131,8 +130,8 @@ class Info_UT < Test::Unit::TestCase
 
   def test_dispose
     Magick::DisposeType.values.each do |v|
-    assert_nothing_raised { @info.dispose = v }
-    assert_equal(v, @info.dispose)
+      assert_nothing_raised { @info.dispose = v }
+      assert_equal(v, @info.dispose)
     end
   end
 
@@ -187,22 +186,22 @@ class Info_UT < Test::Unit::TestCase
 
   def test_gravity
     Magick::GravityType.values.each do |v|
-    assert_nothing_raised { @info.gravity = v }
-    assert_equal(v, @info.gravity)
+      assert_nothing_raised { @info.gravity = v }
+      assert_equal(v, @info.gravity)
     end
   end
 
   def test_image_type
     Magick::ImageType.values.each do |v|
-    assert_nothing_raised { @info.image_type = v }
-    assert_equal(v, @info.image_type)
+      assert_nothing_raised { @info.image_type = v }
+      assert_equal(v, @info.image_type)
     end
   end
 
   def test_interlace
     Magick::InterlaceType.values.each do |v|
-    assert_nothing_raised { @info.interlace = v }
-    assert_equal(v, @info.interlace)
+      assert_nothing_raised { @info.interlace = v }
+      assert_equal(v, @info.interlace)
     end
   end
 
@@ -216,17 +215,17 @@ class Info_UT < Test::Unit::TestCase
     red = Magick::Pixel.new(Magick::QuantumRange)
     assert_nothing_raised { @info.matte_color = red }
     assert_equal('red', @info.matte_color)
-    img = Magick::Image.new(20,20) { self.matte_color = 'red' }
+    img = Magick::Image.new(20, 20) { self.matte_color = 'red' }
     assert_equal('red', img.matte_color)
   end
 
   def test_monitor
-    assert_nothing_raised { @info.monitor = lambda {} }
+    assert_nothing_raised { @info.monitor = -> {} }
     monitor = proc do |mth, q, s|
-    assert_equal('resize!', mth)
-    assert_instance_of(Fixnum, q)
-    assert_instance_of(Fixnum, s)
-    true
+      assert_equal('resize!', mth)
+      assert_instance_of(Fixnum, q)
+      assert_instance_of(Fixnum, s)
+      true
     end
     img = Magick::Image.new(2000, 2000) { self.monitor = monitor }
     img.resize!(20, 20)
@@ -240,8 +239,8 @@ class Info_UT < Test::Unit::TestCase
 
   def test_orientation
     Magick::OrientationType.values.each do |v|
-    assert_nothing_raised { @info.orientation = v }
-    assert_equal(v, @info.orientation)
+      assert_nothing_raised { @info.orientation = v }
+      assert_equal(v, @info.orientation)
     end
   end
 
@@ -280,7 +279,7 @@ class Info_UT < Test::Unit::TestCase
   def test_size
     assert_nothing_raised { @info.size = '200x100' }
     assert_equal('200x100', @info.size)
-    assert_nothing_raised { @info.size = Magick::Geometry.new(100,200) }
+    assert_nothing_raised { @info.size = Magick::Geometry.new(100, 200) }
     assert_equal('100x200', @info.size)
   end
 
@@ -307,14 +306,14 @@ class Info_UT < Test::Unit::TestCase
   end
 
   def test_texture
-    img = Magick::Image.read('granite:') {self.size = '20x20' }
+    img = Magick::Image.read('granite:') { self.size = '20x20' }
     assert_nothing_raised { @info.texture = img.first }
   end
 
   def test_tile_offset
     assert_nothing_raised { @info.tile_offset = '200x100' }
     assert_equal('200x100', @info.tile_offset)
-    assert_nothing_raised { @info.tile_offset = Magick::Geometry.new(100,200) }
+    assert_nothing_raised { @info.tile_offset = Magick::Geometry.new(100, 200) }
     assert_equal('100x200', @info.tile_offset)
   end
 
@@ -333,8 +332,8 @@ class Info_UT < Test::Unit::TestCase
 
   def test_units
     Magick::ResolutionType.values.each do |v|
-    assert_nothing_raised { @info.units = v }
-    assert_equal(v, @info.units)
+      assert_nothing_raised { @info.units = v }
+      assert_equal(v, @info.units)
     end
   end
 

data/test/Magick.rb

@@ -1,5 +1,4 @@
-
-#!/usr/bin/env ruby -w
+# !/usr/bin/env ruby -w
 
 require 'rmagick'
 require 'test/unit'
@@ -29,18 +28,18 @@ class Magick::AnchorType
   end
 end
 
-class Magick_UT < Test::Unit::TestCase
+class MagickUT < Test::Unit::TestCase
   def test_colors
     res = nil
     assert_nothing_raised { res = Magick.colors }
     assert_instance_of(Array, res)
     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::Pixel, c.color)
+      assert_instance_of(Magick::Color, c)
+      assert_instance_of(String, c.name)
+      assert_instance_of(Magick::ComplianceType, c.compliance)
+      assert_instance_of(Magick::Pixel, c.color)
     end
-    Magick.colors {|c| assert_instance_of(Magick::Color, c) }
+    Magick.colors { |c| assert_instance_of(Magick::Color, c) }
   end
 
   # Test a few of the @@enumerator arrays in the Enum subclasses.
@@ -48,18 +47,18 @@ class Magick_UT < Test::Unit::TestCase
   def test_enumerators
     ary = nil
     assert_nothing_raised do
-    ary = Magick::AlphaChannelType.enumerators
+      ary = Magick::AlphaChannelType.enumerators
     end
     assert_instance_of(Array, ary)
 
     assert_nothing_raised do
-    ary = Magick::AlignType.enumerators
+      ary = Magick::AlignType.enumerators
     end
     assert_instance_of(Array, ary)
     assert_equal(4, ary.length)
 
     assert_nothing_raised do
-    ary = Magick::AnchorType.enumerators
+      ary = Magick::AnchorType.enumerators
     end
     assert_instance_of(Array, ary)
     assert_equal(3, ary.length)
@@ -76,18 +75,18 @@ class Magick_UT < Test::Unit::TestCase
     assert_nothing_raised { res = Magick.fonts }
     assert_instance_of(Array, res)
     res.each do |f|
-    assert_instance_of(Magick::Font, f)
-    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(Fixnum, f.weight)
-    assert_instance_of(String, f.encoding) unless f.encoding.nil?
-    assert_instance_of(String, f.foundry) unless f.foundry.nil?
-    assert_instance_of(String, f.format) unless f.format.nil?
+      assert_instance_of(Magick::Font, f)
+      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(Fixnum, f.weight)
+      assert_instance_of(String, f.encoding) unless f.encoding.nil?
+      assert_instance_of(String, f.foundry) unless f.foundry.nil?
+      assert_instance_of(String, f.format) unless f.format.nil?
     end
-    Magick.fonts {|f| assert_instance_of(Magick::Font, f) }
+    Magick.fonts { |f| assert_instance_of(Magick::Font, f) }
   end
 
   def test_formats
@@ -95,17 +94,19 @@ class Magick_UT < Test::Unit::TestCase
     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)
+      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
-    Magick.formats.each { |f, v| assert_not_nil(f); assert_not_nil(v) }
   end
 
   def test_geometry
     g = nil
     gs = nil
     g2 = nil
-    gs2 = nil
     assert_nothing_raised { g = Magick::Geometry.new }
     assert_nothing_raised { gs = g.to_s }
     assert_equal('', gs)
@@ -267,31 +268,31 @@ class Magick_UT < Test::Unit::TestCase
   def test_limit_resources
     cur = new = nil
 
-    assert_nothing_raised {cur = Magick.limit_resource(:memory, 500)}
+    assert_nothing_raised { cur = Magick.limit_resource(:memory, 500) }
     assert_kind_of(Integer, cur)
-    assert(cur > 1024 ** 2)
-    assert_nothing_raised {new = Magick.limit_resource('memory')}
+    assert(cur > 1024**2)
+    assert_nothing_raised { new = Magick.limit_resource('memory') }
     assert_equal(500, new)
     Magick.limit_resource(:memory, cur)
 
-    assert_nothing_raised {cur = Magick.limit_resource(:map, 3500)}
+    assert_nothing_raised { cur = Magick.limit_resource(:map, 3500) }
     assert_kind_of(Integer, cur)
-    assert(cur > 1024 ** 2)
-    assert_nothing_raised {new = Magick.limit_resource('map')}
+    assert(cur > 1024**2)
+    assert_nothing_raised { new = Magick.limit_resource('map') }
     assert_equal(3500, new)
     Magick.limit_resource(:map, cur)
 
-    assert_nothing_raised {cur = Magick.limit_resource(:disk, 3*1024*1024*1024)}
+    assert_nothing_raised { cur = Magick.limit_resource(:disk, 3 * 1024 * 1024 * 1024) }
     assert_kind_of(Integer, cur)
-    assert(cur > 1024 ** 2)
-    assert_nothing_raised {new = Magick.limit_resource('disk')}
-    assert_equal(3221225472, new)
+    assert(cur > 1024**2)
+    assert_nothing_raised { new = Magick.limit_resource('disk') }
+    assert_equal(3_221_225_472, new)
     Magick.limit_resource(:disk, cur)
 
-    assert_nothing_raised {cur = Magick.limit_resource(:file, 500)}
+    assert_nothing_raised { cur = Magick.limit_resource(:file, 500) }
     assert_kind_of(Integer, cur)
     assert(cur > 512)
-    assert_nothing_raised {new = Magick.limit_resource('file')}
+    assert_nothing_raised { new = Magick.limit_resource('file') }
     assert_equal(500, new)
     Magick.limit_resource(:file, cur)
 
@@ -303,19 +304,19 @@ class Magick_UT < Test::Unit::TestCase
 
   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)
+      assert(which == :c)
+      assert_instance_of(String, description)
+      assert_instance_of(String, id)
+      assert_equal(:initialize, method)
     end
     begin
-    img = Magick::Image.new(20,20)
+      Magick::Image.new(20, 20)
     ensure
-    Magick.trace_proc = nil
+      Magick.trace_proc = nil
     end
   end
 end
 
-if __FILE__ == $PROGRAM_NAME
-Test::Unit::UI::Console::TestRunner.run(Magick_UT) unless RUBY_VERSION[/^1\.9|^2/]
+if $PROGRAM_NAME == __FILE__
+  Test::Unit::UI::Console::TestRunner.run(MagickUT) unless RUBY_VERSION[/^1\.9|^2/]
 end

data/test/Pixel.rb

@@ -4,22 +4,22 @@ require 'rmagick'
 require 'test/unit'
 require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
 
-class Pixel_UT < Test::Unit::TestCase
+class PixelUT < Test::Unit::TestCase
   def setup
     @pixel = Magick::Pixel.from_color('brown')
   end
 
   def test_hash
     hash = nil
-    assert_nothing_raised { hash = @pixel.hash}
+    assert_nothing_raised { hash = @pixel.hash }
     assert_not_nil(hash)
-    assert_equal(1385501952, hash)
+    assert_equal(1_385_501_952, hash)
 
     p = Magick::Pixel.new
     assert_equal(0, p.hash)
 
     p = Magick::Pixel.from_color('red')
-    assert_equal(2139095040, p.hash)
+    assert_equal(2_139_095_040, p.hash)
 
     # Pixel.hash sacrifices the last bit of the opacity channel
     p = Magick::Pixel.new(0, 0, 0, 72)
@@ -60,29 +60,29 @@ class Pixel_UT < Test::Unit::TestCase
     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}")
+      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
-    end
     end
 
     # test percentages
-    args = ['20%','20%','20%','20%']
-    args2 = [360.0/5,255.0/5,255.0/5,1.0/5]
+    args = ['20%', '20%', '20%', '20%']
+    args2 = [360.0 / 5, 255.0 / 5, 255.0 / 5, 1.0 / 5]
     px = Magick::Pixel.from_hsla(*args)
     hsla = px.to_hsla
     px2 = Magick::Pixel.from_hsla(*args2)
@@ -91,7 +91,7 @@ class Pixel_UT < Test::Unit::TestCase
     assert_in_delta(hsla[0], hsla2[0], 0.25, "#{hsla.inspect} != #{hsla2.inspect} with args: #{args.inspect} and #{args2.inspect}")
     assert_in_delta(hsla[1], hsla2[1], 0.25, "#{hsla.inspect} != #{hsla2.inspect} with args: #{args.inspect} and #{args2.inspect}")
     assert_in_delta(hsla[2], hsla2[2], 0.25, "#{hsla.inspect} != #{hsla2.inspect} with args: #{args.inspect} and #{args2.inspect}")
-    assert_in_delta(hsla[3], hsla2[3], 0.005,  "#{hsla.inspect} != #{hsla2.inspect} with args: #{args.inspect} and #{args2.inspect}")
+    assert_in_delta(hsla[3], hsla2[3], 0.005, "#{hsla.inspect} != #{hsla2.inspect} with args: #{args.inspect} and #{args2.inspect}")
   end
 
   def test_to_color

data/test/Preview.rb

@@ -4,7 +4,7 @@ require 'rmagick'
 require 'test/unit'
 require 'test/unit/ui/console/testrunner' unless RUBY_VERSION[/^1\.9|^2/]
 
-class Preview_UT < Test::Unit::TestCase
+class PreviewUT < Test::Unit::TestCase
   def test_preview
     preview_types = [
       Magick::RotatePreview,
@@ -35,9 +35,10 @@ class Preview_UT < Test::Unit::TestCase
       Magick::WavePreview,
       Magick::OilPaintPreview,
       Magick::CharcoalDrawingPreview,
-      Magick::JPEGPreview ]
+      Magick::JPEGPreview
+    ]
 
-    hat = Magick::Image.read(IMAGES_DIR+'/Flower_Hat.jpg').first
+    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)
@@ -51,7 +52,7 @@ class Preview_UT < Test::Unit::TestCase
   end
 end
 
-if __FILE__ == $PROGRAM_NAME
-IMAGES_DIR = '../doc/ex/images'
-Test::Unit::UI::Console::TestRunner.run(Preview_UT) unless RUBY_VERSION[/^1\.9|^2/]
+if $PROGRAM_NAME == __FILE__
+  IMAGES_DIR = '../doc/ex/images'
+  Test::Unit::UI::Console::TestRunner.run(PreviewUT) unless RUBY_VERSION[/^1\.9|^2/]
 end