rmagick 3.2.0 → 4.3.0

data/test/Magick.rb

@@ -1,311 +0,0 @@
-# !/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-module Magick
-  def self._tmpnam_
-    @@_tmpnam_
-  end
-end
-
-class Magick::AlphaChannelOption
-  def self.enumerators
-    @@enumerators
-  end
-end
-
-class Magick::AlignType
-  def self.enumerators
-    @@enumerators
-  end
-end
-
-class Magick::AnchorType
-  def self.enumerators
-    @@enumerators
-  end
-end
-
-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) unless c.compliance.nil?
-      assert_instance_of(Magick::Pixel, c.color)
-    end
-    Magick.colors { |c| assert_instance_of(Magick::Color, c) }
-  end
-
-  # Test a few of the @@enumerator arrays in the Enum subclasses.
-  # No need to test all of them.
-  def test_enumerators
-    ary = nil
-    assert_nothing_raised do
-      ary = Magick::AlphaChannelOption.enumerators
-    end
-    assert_instance_of(Array, ary)
-
-    assert_nothing_raised do
-      ary = Magick::AlignType.enumerators
-    end
-    assert_instance_of(Array, ary)
-    assert_equal(4, ary.length)
-
-    assert_nothing_raised do
-      ary = Magick::AnchorType.enumerators
-    end
-    assert_instance_of(Array, ary)
-    assert_equal(3, ary.length)
-  end
-
-  def test_features
-    res = nil
-    assert_nothing_raised { res = Magick::Magick_features }
-    assert_instance_of(String, res)
-  end
-
-  def test_fonts
-    res = nil
-    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) 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?
-      assert_instance_of(String, f.format) unless f.format.nil?
-    end
-    Magick.fonts { |f| assert_instance_of(Magick::Font, f) }
-  end
-
-  def test_geometry
-    g = nil
-    gs = nil
-    g2 = nil
-    assert_nothing_raised { g = Magick::Geometry.new }
-    assert_nothing_raised { gs = g.to_s }
-    assert_equal('', gs)
-
-    g = Magick::Geometry.new(40)
-    gs = g.to_s
-    assert_equal('40x', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 50)
-    gs = g.to_s
-    assert_equal('40x50', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 50, 10)
-    gs = g.to_s
-    assert_equal('40x50+10+0', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 50, 10, -15)
-    gs = g.to_s
-    assert_equal('40x50+10-15', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 50, 0, 0, Magick::AreaGeometry)
-    gs = g.to_s
-    assert_equal('40x50@', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 50, 0, 0, Magick::AspectGeometry)
-    gs = g.to_s
-    assert_equal('40x50!', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 50, 0, 0, Magick::LessGeometry)
-    gs = g.to_s
-    assert_equal('40x50<', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 50, 0, 0, Magick::GreaterGeometry)
-    gs = g.to_s
-    assert_equal('40x50>', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 50, 0, 0, Magick::MinimumGeometry)
-    gs = g.to_s
-    assert_equal('40x50^', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 0, 0, 0, Magick::PercentGeometry)
-    gs = g.to_s
-    assert_equal('40%', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 60, 0, 0, Magick::PercentGeometry)
-    gs = g.to_s
-    assert_equal('40%x60%', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 60, 10, 0, Magick::PercentGeometry)
-    gs = g.to_s
-    assert_equal('40%x60%+10+0', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40, 60, 10, 20, Magick::PercentGeometry)
-    gs = g.to_s
-    assert_equal('40%x60%+10+20', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40.5, 60.75)
-    gs = g.to_s
-    assert_equal('40.50x60.75', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(40.5, 60.75, 0, 0, Magick::PercentGeometry)
-    gs = g.to_s
-    assert_equal('40.50%x60.75%', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(0, 0, 10, 20)
-    gs = g.to_s
-    assert_equal('+10+20', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    g = Magick::Geometry.new(0, 0, 10)
-    gs = g.to_s
-    assert_equal('+10+0', gs)
-
-    assert_nothing_raised { g2 = Magick::Geometry.from_s(gs) }
-    gs2 = g2.to_s
-    assert_equal(gs, gs2)
-
-    # assert behavior with empty string argument
-    assert_nothing_raised { g = Magick::Geometry.from_s('') }
-    assert_equal('', g.to_s)
-
-    assert_raise(ArgumentError) { Magick::Geometry.new(Magick::AreaGeometry) }
-    assert_raise(ArgumentError) { Magick::Geometry.new(40, Magick::AreaGeometry) }
-    assert_raise(ArgumentError) { Magick::Geometry.new(40, 20, Magick::AreaGeometry) }
-    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
-
-  def test_set_log_format
-    assert_nothing_raised { Magick.set_log_format('format %d%e%f') }
-  end
-
-  def test_limit_resources
-    cur = new = nil
-
-    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_equal(500, new)
-    Magick.limit_resource(:memory, cur)
-
-    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_equal(3500, new)
-    Magick.limit_resource(:map, cur)
-
-    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(3_221_225_472, new)
-    Magick.limit_resource(:disk, cur)
-
-    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_equal(500, new)
-    Magick.limit_resource(:file, cur)
-
-    assert_nothing_raised { cur = Magick.limit_resource(:time, 300) }
-    assert_kind_of(Integer, cur)
-    assert(cur > 300)
-    assert_nothing_raised { new = Magick.limit_resource('time') }
-    assert_equal(300, new)
-    Magick.limit_resource(:time, cur)
-
-    assert_raise(ArgumentError) { Magick.limit_resource(:xxx) }
-    assert_raise(ArgumentError) { Magick.limit_resource('xxx') }
-    assert_raise(ArgumentError) { Magick.limit_resource('map', 3500, 2) }
-    assert_raise(ArgumentError) { Magick.limit_resource }
-  end
-
-  def test_transparent_alpha
-    assert_equal(0, Magick::TransparentAlpha)
-  end
-end
-
-Test::Unit::UI::Console::TestRunner.run(MagickUT) if $PROGRAM_NAME == __FILE__

data/test/Pixel.rb

@@ -1,285 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-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 }
-    assert_not_nil(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(2_139_095_040, p.hash)
-
-    # Pixel.hash sacrifices the last bit of the opacity channel
-    p = Magick::Pixel.new(0, 0, 0, 72)
-    p2 = Magick::Pixel.new(0, 0, 0, 73)
-    assert_not_equal(p, p2)
-    assert_equal(p.hash, p2.hash)
-  end
-
-  def test_eql?
-    p = @pixel
-    assert(@pixel.eql?(p))
-    p = Magick::Pixel.new
-    assert(!@pixel.eql?(p))
-  end
-
-  def test_fcmp
-    red = Magick::Pixel.from_color('red')
-    blue = Magick::Pixel.from_color('blue')
-    assert_nothing_raised { red.fcmp(red) }
-    assert(red.fcmp(red))
-    assert(!red.fcmp(blue))
-
-    assert_nothing_raised { red.fcmp(blue, 10) }
-    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('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(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 }
-
-    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%']
-    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)
-    hsla2 = px2.to_hsla
-
-    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}")
-  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) }
-    assert_nothing_raised { @pixel.to_color(Magick::X11Compliance) }
-    assert_nothing_raised { @pixel.to_color(Magick::XPMCompliance) }
-    assert_nothing_raised { @pixel.to_color(Magick::AllCompliance, true) }
-    assert_nothing_raised { @pixel.to_color(Magick::AllCompliance, false) }
-    assert_nothing_raised { @pixel.to_color(Magick::AllCompliance, false, 8) }
-    assert_nothing_raised { @pixel.to_color(Magick::AllCompliance, false, 16) }
-    # test "hex" format
-    assert_nothing_raised { @pixel.to_color(Magick::AllCompliance, false, 8, true) }
-    assert_nothing_raised { @pixel.to_color(Magick::AllCompliance, false, 16, true) }
-
-    assert_equal('#A52A2A', @pixel.to_color(Magick::AllCompliance, false, 8, true))
-    assert_equal('#A5A52A2A2A2A', @pixel.to_color(Magick::AllCompliance, false, 16, true))
-
-    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,23 +0,0 @@
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class PolaroidOptionsUT < Test::Unit::TestCase
-  def setup
-    @options = Magick::Image::PolaroidOptions.new
-  end
-
-  def test_shadow_color
-    assert_nothing_raised { @options.shadow_color = "gray50" }
-
-    @options.freeze
-    assert_raise(FreezeError) { @options.shadow_color = "gray50" }
-  end
-
-  def test_border_color
-    assert_nothing_raised { @options.border_color = "gray50" }
-
-    @options.freeze
-    assert_raise(FreezeError) { @options.border_color = "gray50" }
-  end
-end

data/test/Preview.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class PreviewUT < Test::Unit::TestCase
-  def test_preview
-    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"
-    Magick::PreviewType.values do |type|
-      puts "testing #{type}..."
-      assert_nothing_raised { hat.preview(type) }
-    end
-    assert_raise(TypeError) { hat.preview(2) }
-  end
-end
-
-if $PROGRAM_NAME == __FILE__
-  IMAGES_DIR = '../doc/ex/images'
-  Test::Unit::UI::Console::TestRunner.run(PreviewUT)
-end

data/test/Struct.rb

@@ -1,45 +0,0 @@
-#!/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