rmagick 4.1.0.rc2 → 4.1.0

data/test/ImageList2.rb

@@ -1,375 +0,0 @@
-# !/usr/bin/env ruby -w
-
-require 'fileutils'
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class ImageList2UT < Test::Unit::TestCase
-  def setup
-    @ilist = Magick::ImageList.new
-  end
-
-  def test_append
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_0.gif')
-    assert_nothing_raised do
-      img = @ilist.append(true)
-      assert_instance_of(Magick::Image, img)
-    end
-    assert_nothing_raised do
-      img = @ilist.append(false)
-      assert_instance_of(Magick::Image, img)
-    end
-    assert_raise(ArgumentError) { @ilist.append }
-    assert_raise(ArgumentError) { @ilist.append(true, 1) }
-  end
-
-  def test_average
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_0.gif')
-    assert_nothing_raised do
-      img = @ilist.average
-      assert_instance_of(Magick::Image, img)
-    end
-    assert_raise(ArgumentError) { @ilist.average(1) }
-  end
-
-  def test_clone
-    @ilist.read(*Dir[IMAGES_DIR + '/Button_*.gif'])
-    ilist2 = @ilist.clone
-    assert_equal(ilist2, @ilist)
-    assert_equal(@ilist.frozen?, ilist2.frozen?)
-    assert_equal(@ilist.tainted?, ilist2.tainted?)
-    @ilist.taint
-    @ilist.freeze
-    ilist2 = @ilist.clone
-    assert_equal(@ilist.frozen?, ilist2.frozen?)
-    assert_equal(@ilist.tainted?, ilist2.tainted?)
-  end
-
-  def test_coalesce
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_0.gif')
-    ilist = nil
-    assert_nothing_raised { ilist = @ilist.coalesce }
-    assert_instance_of(Magick::ImageList, ilist)
-    assert_equal(2, ilist.length)
-    assert_equal(0, ilist.scene)
-  end
-
-  def test_copy
-    @ilist.read(*Dir[IMAGES_DIR + '/Button_*.gif'])
-    @ilist.scene = 7
-    ilist2 = @ilist.copy
-    assert_not_same(@ilist, ilist2)
-    assert_equal(@ilist.scene, ilist2.scene)
-    @ilist.each_with_index do |img, x|
-      assert_equal(img, ilist2[x])
-    end
-  end
-
-  def test_deconstruct
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_1.gif')
-    ilist = nil
-    assert_nothing_raised { ilist = @ilist.deconstruct }
-    assert_instance_of(Magick::ImageList, ilist)
-    assert_equal(2, ilist.length)
-    assert_equal(0, ilist.scene)
-  end
-
-  def test_dup
-    @ilist.read(*Dir[IMAGES_DIR + '/Button_*.gif'])
-    ilist2 = @ilist.dup
-    assert_equal(ilist2, @ilist)
-    assert_equal(@ilist.frozen?, ilist2.frozen?)
-    assert_equal(@ilist.tainted?, ilist2.tainted?)
-    @ilist.taint
-    @ilist.freeze
-    ilist2 = @ilist.dup
-    assert_not_equal(@ilist.frozen?, ilist2.frozen?)
-    assert_equal(@ilist.tainted?, ilist2.tainted?)
-  end
-
-  def flatten_images
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_1.gif')
-    assert_nothing_thrown do
-      img = @ilist.flatten_images
-      assert_instance_of(Magick::Image, img)
-    end
-  end
-
-  def test_from_blob
-    hat = File.open(FLOWER_HAT, 'rb')
-    blob = hat.read
-    assert_nothing_raised { @ilist.from_blob(blob) }
-    assert_instance_of(Magick::Image, @ilist[0])
-    assert_equal(0, @ilist.scene)
-
-    ilist2 = Magick::ImageList.new(FLOWER_HAT)
-    assert_equal(@ilist, ilist2)
-  end
-
-  def test_marshal
-    ilist1 = Magick::ImageList.new(*Dir[IMAGES_DIR + '/Button_*.gif'])
-    d = nil
-    ilist2 = nil
-    assert_nothing_raised { d = Marshal.dump(ilist1) }
-    assert_nothing_raised { ilist2 = Marshal.load(d) }
-    assert_equal(ilist1, ilist2)
-  end
-
-  def test_montage
-    @ilist.read(*Dir[IMAGES_DIR + '/Button_*.gif'])
-    ilist = @ilist.copy
-    montage = nil
-    assert_nothing_thrown do
-      montage = ilist.montage do
-        self.background_color = Magick::Pixel.new(Magick::QuantumRange, 0, 0)
-        self.background_color = 'blue'
-        self.border_color = Magick::Pixel.new(0, 0, 0)
-        self.border_color = 'red'
-        self.border_width = 2
-        self.compose = Magick::OverCompositeOp
-        self.filename = 'test.png'
-        self.fill = 'green'
-        self.font = 'Arial'
-        self.frame = '20x20+4+4'
-        self.frame = Magick::Geometry.new(20, 20, 4, 4)
-        self.geometry = '63x60+5+5'
-        self.geometry = Magick::Geometry.new(63, 60, 5, 5)
-        self.gravity = Magick::SouthGravity
-        self.matte_color = '#bdbdbd'
-        self.matte_color = Magick::Pixel.new(Magick::QuantumRange, 0, 0)
-        self.pointsize = 12
-        self.shadow = true
-        self.stroke = 'transparent'
-        self.texture = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first
-        self.texture = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first
-        self.tile = '4x9'
-        self.tile = Magick::Geometry.new(4, 9)
-        self.title = 'sample'
-      end
-      assert_instance_of(Magick::ImageList, montage)
-      assert_equal(@ilist, ilist)
-
-      montage_image = montage.first
-      assert_equal('blue', montage_image.background_color)
-      assert_equal('red', montage_image.border_color)
-    end
-
-    # test illegal option arguments
-    # looks like IM doesn't diagnose invalid geometry args
-    # to tile= and geometry=
-    assert_raise(TypeError) do
-      montage = ilist.montage { self.background_color = 2 }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(TypeError) do
-      montage = ilist.montage { self.border_color = 2 }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(TypeError) do
-      montage = ilist.montage { self.border_width = [2] }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(TypeError) do
-      montage = ilist.montage { self.compose = 2 }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(TypeError) do
-      montage = ilist.montage { self.filename = 2 }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(TypeError) do
-      montage = ilist.montage { self.fill = 2 }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(TypeError) do
-      montage = ilist.montage { self.font = 2 }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(TypeError) do
-      montage = ilist.montage { self.gravity = 2 }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(TypeError) do
-      montage = ilist.montage { self.matte_color = 2 }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(TypeError) do
-      montage = ilist.montage { self.pointsize = 'x' }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(ArgumentError) do
-      montage = ilist.montage { self.stroke = 'x' }
-      assert_equal(@ilist, ilist)
-    end
-    assert_raise(NoMethodError) do
-      montage = ilist.montage { self.texture = 'x' }
-      assert_equal(@ilist, ilist)
-    end
-  end
-
-  def test_morph
-    # can't morph an empty list
-    assert_raise(ArgumentError) { @ilist.morph(1) }
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_1.gif')
-    # can't specify a negative argument
-    assert_raise(ArgumentError) { @ilist.morph(-1) }
-    assert_nothing_raised do
-      res = @ilist.morph(2)
-      assert_instance_of(Magick::ImageList, res)
-      assert_equal(4, res.length)
-      assert_equal(0, res.scene)
-    end
-  end
-
-  def test_mosaic
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_1.gif')
-    assert_nothing_thrown do
-      res = @ilist.mosaic
-      assert_instance_of(Magick::Image, res)
-    end
-  end
-
-  def test_mosaic_with_invalid_imagelist
-    list = @ilist.copy
-    list.instance_variable_set("@images", nil)
-    assert_raise(Magick::ImageMagickError) { list.mosaic }
-  end
-
-  def test_new_image
-    assert_nothing_raised do
-      @ilist.new_image(20, 20)
-    end
-    assert_equal(1, @ilist.length)
-    assert_equal(0, @ilist.scene)
-    @ilist.new_image(20, 20, Magick::HatchFill.new('black'))
-    assert_equal(2, @ilist.length)
-    assert_equal(1, @ilist.scene)
-    @ilist.new_image(20, 20) { self.background_color = 'red' }
-    assert_equal(3, @ilist.length)
-    assert_equal(2, @ilist.scene)
-  end
-
-  def test_optimize_layers
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_1.gif')
-    Magick::LayerMethod.values do |method|
-      next if [Magick::UndefinedLayer, Magick::CompositeLayer, Magick::TrimBoundsLayer].include?(method)
-
-      assert_nothing_raised do
-        res = @ilist.optimize_layers(method)
-        assert_instance_of(Magick::ImageList, res)
-        assert_kind_of(Integer, res.length)
-      end
-    end
-
-    assert_nothing_raised { @ilist.optimize_layers(Magick::CompareClearLayer) }
-    assert_raise(ArgumentError) { @ilist.optimize_layers(Magick::UndefinedLayer) }
-    assert_raise(TypeError) { @ilist.optimize_layers(2) }
-    assert_raise(NotImplementedError) { @ilist.optimize_layers(Magick::CompositeLayer) }
-  end
-
-  def test_ping
-    assert_nothing_raised { @ilist.ping(FLOWER_HAT) }
-    assert_equal(1, @ilist.length)
-    assert_equal(0, @ilist.scene)
-    assert_nothing_raised { @ilist.ping(FLOWER_HAT, FLOWER_HAT) }
-    assert_equal(3, @ilist.length)
-    assert_equal(2, @ilist.scene)
-    assert_nothing_raised { @ilist.ping(FLOWER_HAT) { self.background_color = 'red ' } }
-    assert_equal(4, @ilist.length)
-    assert_equal(3, @ilist.scene)
-  end
-
-  def test_quantize
-    @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_1.gif')
-    assert_nothing_raised do
-      res = @ilist.quantize
-      assert_instance_of(Magick::ImageList, res)
-      assert_equal(1, res.scene)
-    end
-    assert_nothing_raised { @ilist.quantize(128) }
-    assert_raise(TypeError) { @ilist.quantize('x') }
-    assert_nothing_raised { @ilist.quantize(128, Magick::RGBColorspace) }
-    assert_raise(TypeError) { @ilist.quantize(128, 'x') }
-    assert_nothing_raised { @ilist.quantize(128, Magick::RGBColorspace, true, 0) }
-    assert_nothing_raised { @ilist.quantize(128, Magick::RGBColorspace, true) }
-    assert_nothing_raised { @ilist.quantize(128, Magick::RGBColorspace, false) }
-    assert_nothing_raised { @ilist.quantize(128, Magick::RGBColorspace, Magick::NoDitherMethod) }
-    assert_nothing_raised { @ilist.quantize(128, Magick::RGBColorspace, Magick::RiemersmaDitherMethod) }
-    assert_nothing_raised { @ilist.quantize(128, Magick::RGBColorspace, Magick::FloydSteinbergDitherMethod) }
-    assert_nothing_raised { @ilist.quantize(128, Magick::RGBColorspace, Magick::FloydSteinbergDitherMethod, 32) }
-    assert_nothing_raised { @ilist.quantize(128, Magick::RGBColorspace, Magick::FloydSteinbergDitherMethod, 32, true) }
-    assert_nothing_raised { @ilist.quantize(128, Magick::RGBColorspace, Magick::FloydSteinbergDitherMethod, 32, false) }
-    assert_raise(TypeError) { @ilist.quantize(128, Magick::RGBColorspace, true, 'x') }
-    assert_raise(ArgumentError) { @ilist.quantize(128, Magick::RGBColorspace, true, 0, false, 'extra') }
-  end
-
-  def test_read
-    assert_nothing_raised { @ilist.read(FLOWER_HAT) }
-    assert_equal(1, @ilist.length)
-    assert_equal(0, @ilist.scene)
-    assert_nothing_raised { @ilist.read(FLOWER_HAT, FLOWER_HAT) }
-    assert_equal(3, @ilist.length)
-    assert_equal(2, @ilist.scene)
-    assert_nothing_raised { @ilist.read(FLOWER_HAT) { self.background_color = 'red ' } }
-    assert_equal(4, @ilist.length)
-    assert_equal(3, @ilist.scene)
-  end
-
-  def test_remap
-    @ilist.read(*Dir[IMAGES_DIR + '/Button_*.gif'])
-    assert_nothing_raised { @ilist.remap }
-    remap_image = Magick::Image.new(20, 20) { self.background_color = 'green' }
-    assert_nothing_raised { @ilist.remap(remap_image) }
-    assert_nothing_raised { @ilist.remap(remap_image, Magick::NoDitherMethod) }
-    assert_nothing_raised { @ilist.remap(remap_image, Magick::RiemersmaDitherMethod) }
-    assert_nothing_raised { @ilist.remap(remap_image, Magick::FloydSteinbergDitherMethod) }
-    assert_raise(ArgumentError) { @ilist.remap(remap_image, Magick::NoDitherMethod, 1) }
-
-    remap_image.destroy!
-    assert_raise(Magick::DestroyedImageError) { @ilist.remap(remap_image) }
-    # assert_raise(TypeError) { @ilist.affinity(affinity_image, 1) }
-  end
-
-  def test_to_blob
-    @ilist.read(IMAGES_DIR + '/Button_0.gif')
-    blob = nil
-    assert_nothing_raised { blob = @ilist.to_blob }
-    img = @ilist.from_blob(blob)
-    assert_equal(@ilist[0], img[0])
-    assert_equal(1, img.scene)
-  end
-
-  def test_write
-    @ilist.read(IMAGES_DIR + '/Button_0.gif')
-    assert_nothing_raised do
-      @ilist.write('temp.gif')
-    end
-    list = Magick::ImageList.new('temp.gif')
-    assert_equal('GIF', list.format)
-    FileUtils.rm('temp.gif')
-
-    @ilist.write('jpg:temp.foo')
-    list = Magick::ImageList.new('temp.foo')
-    assert_equal('JPEG', list.format)
-    FileUtils.rm('temp.foo')
-
-    @ilist.write('temp.0') { self.format = 'JPEG' }
-    list = Magick::ImageList.new('temp.0')
-    assert_equal('JPEG', list.format)
-    FileUtils.rm('temp.0')
-
-    f = File.new('test.0', 'w')
-    @ilist.write(f) { self.format = 'JPEG' }
-    f.close
-    list = Magick::ImageList.new('test.0')
-    assert_equal('JPEG', list.format)
-    FileUtils.rm('test.0')
-  end
-end
-
-if $PROGRAM_NAME == __FILE__
-  IMAGES_DIR = '../doc/ex/images'
-  FLOWER_HAT = IMAGES_DIR + '/Flower_Hat.jpg'
-  Test::Unit::UI::Console::TestRunner.run(ImageList2UT)
-end

data/test/Image_attributes.rb

@@ -1,635 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'fileutils'
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-# TODO
-#   test frozen attributes!
-#   improve test_directory
-#   improve test_montage
-
-class Image_Attributes_UT < Test::Unit::TestCase
-  def setup
-    @img = Magick::Image.new(100, 100)
-    gc = Magick::Draw.new
-
-    gc.stroke_width(5)
-    gc.circle(50, 50, 80, 80)
-    gc.draw(@img)
-
-    @hat = Magick::Image.read(FLOWER_HAT).first
-    @p = Magick::Image.read(IMAGE_WITH_PROFILE).first.color_profile
-  end
-
-  def test_background_color
-    assert_nothing_raised { @img.background_color }
-    assert_equal('white', @img.background_color)
-    assert_nothing_raised { @img.background_color = '#dfdfdf' }
-    # assert_equal("rgb(223,223,223)", @img.background_color)
-    background_color = @img.background_color
-    if background_color.length == 13
-      assert_equal('#DFDFDFDFDFDF', background_color)
-    else
-      assert_equal('#DFDFDFDFDFDFFFFF', background_color)
-    end
-    assert_nothing_raised { @img.background_color = Magick::Pixel.new(Magick::QuantumRange, Magick::QuantumRange / 2.0, Magick::QuantumRange / 2.0) }
-    # assert_equal("rgb(100%,49.9992%,49.9992%)", @img.background_color)
-    background_color = @img.background_color
-    if background_color.length == 13
-      assert_equal('#FFFF7FFF7FFF', background_color)
-    else
-      assert_equal('#FFFF7FFF7FFFFFFF', background_color)
-    end
-    assert_raise(TypeError) { @img.background_color = 2 }
-  end
-
-  def test_base_columns
-    assert_nothing_raised { @img.base_columns }
-    assert_equal(0, @img.base_columns)
-    assert_raise(NoMethodError) { @img.base_columns = 1 }
-  end
-
-  def test_base_filename
-    assert_nothing_raised { @img.base_filename }
-    assert_equal('', @img.base_filename)
-    assert_raise(NoMethodError) { @img.base_filename = 'xxx' }
-  end
-
-  def test_base_rows
-    assert_nothing_raised { @img.base_rows }
-    assert_equal(0, @img.base_rows)
-    assert_raise(NoMethodError) { @img.base_rows = 1 }
-  end
-
-  def test_bias
-    assert_nothing_raised { @img.bias }
-    assert_equal(0.0, @img.bias)
-    assert_instance_of(Float, @img.bias)
-
-    assert_nothing_raised { @img.bias = 0.1 }
-    assert_in_delta(Magick::QuantumRange * 0.1, @img.bias, 0.1)
-
-    assert_nothing_raised { @img.bias = '10%' }
-    assert_in_delta(Magick::QuantumRange * 0.10, @img.bias, 0.1)
-
-    assert_raise(TypeError) { @img.bias = [] }
-    assert_raise(ArgumentError) { @img.bias = 'x' }
-  end
-
-  def test_black_point_compensation
-    assert_nothing_raised { @img.black_point_compensation = true }
-    assert(@img.black_point_compensation)
-    assert_nothing_raised { @img.black_point_compensation = false }
-    assert_equal(false, @img.black_point_compensation)
-  end
-
-  def test_border_color
-    assert_nothing_raised { @img.border_color }
-    # assert_equal("rgb(223,223,223)", @img.border_color)
-    border_color = @img.border_color
-    if border_color.length == 13
-      assert_equal('#DFDFDFDFDFDF', border_color)
-    else
-      assert_equal('#DFDFDFDFDFDFFFFF', border_color)
-    end
-    assert_nothing_raised { @img.border_color = 'red' }
-    assert_equal('red', @img.border_color)
-    assert_nothing_raised { @img.border_color = Magick::Pixel.new(Magick::QuantumRange, Magick::QuantumRange / 2, Magick::QuantumRange / 2) }
-    # assert_equal("rgb(100%,49.9992%,49.9992%)", @img.border_color)
-    border_color = @img.border_color
-    if border_color.length == 13
-      assert_equal('#FFFF7FFF7FFF', border_color)
-    else
-      assert_equal('#FFFF7FFF7FFFFFFF', border_color)
-    end
-    assert_raise(TypeError) { @img.border_color = 2 }
-  end
-
-  def test_bounding_box
-    assert_nothing_raised { @img.bounding_box }
-    box = @img.bounding_box
-    assert_equal(87, box.width)
-    assert_equal(87, box.height)
-    assert_equal(7, box.x)
-    assert_equal(7, box.y)
-    assert_raise(NoMethodError) { @img.bounding_box = 2 }
-  end
-
-  def test_chromaticity
-    chrom = @img.chromaticity
-    assert_nothing_raised { @img.chromaticity }
-    assert_instance_of(Magick::Chromaticity, chrom)
-    assert_equal(0, chrom.red_primary.x)
-    assert_equal(0, chrom.red_primary.y)
-    assert_equal(0, chrom.red_primary.z)
-    assert_equal(0, chrom.green_primary.x)
-    assert_equal(0, chrom.green_primary.y)
-    assert_equal(0, chrom.green_primary.z)
-    assert_equal(0, chrom.blue_primary.x)
-    assert_equal(0, chrom.blue_primary.y)
-    assert_equal(0, chrom.blue_primary.z)
-    assert_equal(0, chrom.white_point.x)
-    assert_equal(0, chrom.white_point.y)
-    assert_equal(0, chrom.white_point.z)
-    assert_nothing_raised { @img.chromaticity = chrom }
-    assert_raise(TypeError) { @img.chromaticity = 2 }
-  end
-
-  def test_class_type
-    assert_nothing_raised { @img.class_type }
-    assert_instance_of(Magick::ClassType, @img.class_type)
-    assert_equal(Magick::DirectClass, @img.class_type)
-    assert_nothing_raised { @img.class_type = Magick::PseudoClass }
-    assert_equal(Magick::PseudoClass, @img.class_type)
-    assert_raise(TypeError) { @img.class_type = 2 }
-
-    assert_nothing_raised do
-      @img.class_type = Magick::PseudoClass
-      @img.class_type = Magick::DirectClass
-      assert_equal(Magick::DirectClass, @img.class_type)
-    end
-  end
-
-  def test_color_profile
-    assert_nothing_raised { @img.color_profile }
-    assert_nil(@img.color_profile)
-    assert_nothing_raised { @img.color_profile = @p }
-    assert_equal(@p, @img.color_profile)
-    assert_raise(TypeError) { @img.color_profile = 2 }
-  end
-
-  def test_colors
-    assert_nothing_raised { @img.colors }
-    assert_equal(0, @img.colors)
-    img = @img.copy
-    img.class_type = Magick::PseudoClass
-    assert_kind_of(Integer, img.colors)
-    assert_raise(NoMethodError) { img.colors = 2 }
-  end
-
-  def test_colorspace
-    assert_nothing_raised { @img.colorspace }
-    assert_instance_of(Magick::ColorspaceType, @img.colorspace)
-    assert_equal(Magick::SRGBColorspace, @img.colorspace)
-    img = @img.copy
-
-    Magick::ColorspaceType.values do |colorspace|
-      assert_nothing_raised { img.colorspace = colorspace }
-    end
-    assert_raise(TypeError) { @img.colorspace = 2 }
-    Magick::ColorspaceType.values.each do |cs|
-      assert_nothing_raised { img.colorspace = cs }
-    end
-  end
-
-  def test_columns
-    assert_nothing_raised { @img.columns }
-    assert_equal(100, @img.columns)
-    assert_raise(NoMethodError) { @img.columns = 2 }
-  end
-
-  def test_compose
-    assert_nothing_raised { @img.compose }
-    assert_instance_of(Magick::CompositeOperator, @img.compose)
-    assert_equal(Magick::OverCompositeOp, @img.compose)
-    assert_raise(TypeError) { @img.compose = 2 }
-    assert_nothing_raised { @img.compose = Magick::UndefinedCompositeOp }
-    assert_equal(Magick::UndefinedCompositeOp, @img.compose)
-
-    Magick::CompositeOperator.values do |composite|
-      assert_nothing_raised { @img.compose = composite }
-    end
-    assert_raise(TypeError) { @img.compose = 2 }
-  end
-
-  def test_compression
-    assert_nothing_raised { @img.compression }
-    assert_instance_of(Magick::CompressionType, @img.compression)
-    assert_equal(Magick::UndefinedCompression, @img.compression)
-    assert_nothing_raised { @img.compression = Magick::BZipCompression }
-    assert_equal(Magick::BZipCompression, @img.compression)
-
-    Magick::CompressionType.values do |compression|
-      assert_nothing_raised { @img.compression = compression }
-    end
-    assert_raise(TypeError) { @img.compression = 2 }
-  end
-
-  def test_delay
-    assert_nothing_raised { @img.delay }
-    assert_equal(0, @img.delay)
-    assert_nothing_raised { @img.delay = 10 }
-    assert_equal(10, @img.delay)
-    assert_raise(TypeError) { @img.delay = 'x' }
-  end
-
-  def test_density
-    assert_nothing_raised { @img.density }
-    assert_nothing_raised { @img.density = '90x90' }
-    assert_nothing_raised { @img.density = 'x90' }
-    assert_nothing_raised { @img.density = '90' }
-    assert_nothing_raised { @img.density = Magick::Geometry.new(@img.columns / 2, @img.rows / 2, 5, 5) }
-    assert_raise(TypeError) { @img.density = 2 }
-  end
-
-  def test_depth
-    assert_equal(Magick::MAGICKCORE_QUANTUM_DEPTH, @img.depth)
-    assert_raise(NoMethodError) { @img.depth = 2 }
-  end
-
-  def test_directory
-    assert_nothing_raised { @img.directory }
-    assert_nil(@img.directory)
-    assert_raise(NoMethodError) { @img.directory = nil }
-  end
-
-  def test_dispose
-    assert_nothing_raised { @img.dispose }
-    assert_instance_of(Magick::DisposeType, @img.dispose)
-    assert_equal(Magick::UndefinedDispose, @img.dispose)
-    assert_nothing_raised { @img.dispose = Magick::NoneDispose }
-    assert_equal(Magick::NoneDispose, @img.dispose)
-
-    Magick::DisposeType.values do |dispose|
-      assert_nothing_raised { @img.dispose = dispose }
-    end
-    assert_raise(TypeError) { @img.dispose = 2 }
-  end
-
-  def test_endian
-    assert_nothing_raised { @img.endian }
-    assert_instance_of(Magick::EndianType, @img.endian)
-    assert_equal(Magick::UndefinedEndian, @img.endian)
-    assert_nothing_raised { @img.endian = Magick::LSBEndian }
-    assert_equal(Magick::LSBEndian, @img.endian)
-    assert_nothing_raised { @img.endian = Magick::MSBEndian }
-    assert_raise(TypeError) { @img.endian = 2 }
-  end
-
-  def test_extract_info
-    assert_nothing_raised { @img.extract_info }
-    assert_instance_of(Magick::Rectangle, @img.extract_info)
-    ext = @img.extract_info
-    assert_equal(0, ext.x)
-    assert_equal(0, ext.y)
-    assert_equal(0, ext.width)
-    assert_equal(0, ext.height)
-    ext = Magick::Rectangle.new(1, 2, 3, 4)
-    assert_nothing_raised { @img.extract_info = ext }
-    assert_equal(1, ext.width)
-    assert_equal(2, ext.height)
-    assert_equal(3, ext.x)
-    assert_equal(4, ext.y)
-    assert_raise(TypeError) { @img.extract_info = 2 }
-  end
-
-  def test_filename
-    assert_nothing_raised { @img.filename }
-    assert_equal('', @img.filename)
-    assert_raises(NoMethodError) { @img.filename = 'xxx' }
-  end
-
-  def test_filter
-    assert_nothing_raised { @img.filter }
-    assert_instance_of(Magick::FilterType, @img.filter)
-    assert_equal(Magick::UndefinedFilter, @img.filter)
-    assert_nothing_raised { @img.filter = Magick::PointFilter }
-    assert_equal(Magick::PointFilter, @img.filter)
-
-    Magick::FilterType.values do |filter|
-      assert_nothing_raised { @img.filter = filter }
-    end
-    assert_raise(TypeError) { @img.filter = 2 }
-  end
-
-  def test_format
-    assert_nothing_raised { @img.format }
-    assert_nil(@img.format)
-    assert_nothing_raised { @img.format = 'GIF' }
-    assert_nothing_raised { @img.format = 'JPG' }
-    assert_nothing_raised { @img.format = 'TIFF' }
-    assert_nothing_raised { @img.format = 'MIFF' }
-    assert_nothing_raised { @img.format = 'MPEG' }
-    v = $VERBOSE
-    $VERBOSE = nil
-    assert_raise(ArgumentError) { @img.format = 'shit' }
-    $VERBOSE = v
-    assert_raise(TypeError) { @img.format = 2 }
-  end
-
-  def test_fuzz
-    assert_nothing_raised { @img.fuzz }
-    assert_instance_of(Float, @img.fuzz)
-    assert_equal(0.0, @img.fuzz)
-    assert_nothing_raised { @img.fuzz = 50 }
-    assert_equal(50.0, @img.fuzz)
-    assert_nothing_raised { @img.fuzz = '50%' }
-    assert_in_delta(Magick::QuantumRange * 0.50, @img.fuzz, 0.1)
-    assert_raise(TypeError) { @img.fuzz = [] }
-    assert_raise(ArgumentError) { @img.fuzz = 'xxx' }
-  end
-
-  def test_gamma
-    assert_nothing_raised { @img.gamma }
-    assert_instance_of(Float, @img.gamma)
-    assert_equal(0.45454543828964233, @img.gamma)
-    assert_nothing_raised { @img.gamma = 2.0 }
-    assert_equal(2.0, @img.gamma)
-    assert_raise(TypeError) { @img.gamma = 'x' }
-  end
-
-  def test_geometry
-    assert_nothing_raised { @img.geometry }
-    assert_nil(@img.geometry)
-    assert_nothing_raised { @img.geometry = nil }
-    assert_nothing_raised { @img.geometry = '90x90' }
-    assert_equal('90x90', @img.geometry)
-    assert_nothing_raised { @img.geometry = Magick::Geometry.new(100, 80) }
-    assert_equal('100x80', @img.geometry)
-    assert_raise(TypeError) { @img.geometry = [] }
-  end
-
-  def test_gravity
-    assert_instance_of(Magick::GravityType, @img.gravity)
-
-    Magick::GravityType.values do |gravity|
-      assert_nothing_raised { @img.gravity = gravity }
-    end
-    assert_raise(TypeError) { @img.gravity = nil }
-    assert_raise(TypeError) { @img.gravity = Magick::PointFilter }
-  end
-
-  def test_image_type
-    assert_instance_of(Magick::ImageType, @img.image_type)
-
-    Magick::ImageType.values do |image_type|
-      assert_nothing_raised { @img.image_type = image_type }
-    end
-    assert_raise(TypeError) { @img.image_type = nil }
-    assert_raise(TypeError) { @img.image_type = Magick::PointFilter }
-  end
-
-  def test_interlace_type
-    assert_nothing_raised { @img.interlace }
-    assert_instance_of(Magick::InterlaceType, @img.interlace)
-    assert_equal(Magick::NoInterlace, @img.interlace)
-    assert_nothing_raised { @img.interlace = Magick::LineInterlace }
-    assert_equal(Magick::LineInterlace, @img.interlace)
-
-    Magick::InterlaceType.values do |interlace|
-      assert_nothing_raised { @img.interlace = interlace }
-    end
-    assert_raise(TypeError) { @img.interlace = 2 }
-  end
-
-  def test_iptc_profile
-    assert_nothing_raised { @img.iptc_profile }
-    assert_nil(@img.iptc_profile)
-    assert_nothing_raised { @img.iptc_profile = 'xxx' }
-    assert_equal('xxx', @img.iptc_profile)
-    assert_raise(TypeError) { @img.iptc_profile = 2 }
-  end
-
-  def test_mean_error
-    assert_nothing_raised { @hat.mean_error_per_pixel }
-    assert_nothing_raised { @hat.normalized_mean_error }
-    assert_nothing_raised { @hat.normalized_maximum_error }
-    assert_equal(0.0, @hat.mean_error_per_pixel)
-    assert_equal(0.0, @hat.normalized_mean_error)
-    assert_equal(0.0, @hat.normalized_maximum_error)
-
-    hat = @hat.quantize(16, Magick::RGBColorspace, true, 0, true)
-
-    assert_not_equal(0.0, hat.mean_error_per_pixel)
-    assert_not_equal(0.0, hat.normalized_mean_error)
-    assert_not_equal(0.0, hat.normalized_maximum_error)
-    assert_raise(NoMethodError) { hat.mean_error_per_pixel = 1 }
-    assert_raise(NoMethodError) { hat.normalized_mean_error = 1 }
-    assert_raise(NoMethodError) { hat.normalized_maximum_error = 1 }
-  end
-
-  def test_mime_type
-    img = @img.copy
-    img.format = 'GIF'
-    assert_nothing_raised { img.mime_type }
-    assert_equal('image/gif', img.mime_type)
-    img.format = 'JPG'
-    assert_equal('image/jpeg', img.mime_type)
-    assert_raise(NoMethodError) { img.mime_type = 'image/jpeg' }
-  end
-
-  def test_monitor
-    assert_raise(NoMethodError) { @img.monitor }
-    monitor = proc { |name, _q, _s| puts name }
-    assert_nothing_raised { @img.monitor = monitor }
-    assert_nothing_raised { @img.monitor = nil }
-  end
-
-  def test_montage
-    assert_nothing_raised { @img.montage }
-    assert_nil(@img.montage)
-  end
-
-  def test_number_colors
-    assert_nothing_raised { @hat.number_colors }
-    assert_kind_of(Integer, @hat.number_colors)
-    assert_raise(NoMethodError) { @hat.number_colors = 2 }
-  end
-
-  def test_offset
-    assert_nothing_raised { @img.offset }
-    assert_equal(0, @img.offset)
-    assert_nothing_raised { @img.offset = 10 }
-    assert_equal(10, @img.offset)
-    assert_raise(TypeError) { @img.offset = 'x' }
-  end
-
-  def test_orientation
-    assert_nothing_raised { @img.orientation }
-    assert_instance_of(Magick::OrientationType, @img.orientation)
-    assert_equal(Magick::UndefinedOrientation, @img.orientation)
-    assert_nothing_raised { @img.orientation = Magick::TopLeftOrientation }
-    assert_equal(Magick::TopLeftOrientation, @img.orientation)
-
-    Magick::OrientationType.values do |orientation|
-      assert_nothing_raised { @img.orientation = orientation }
-    end
-    assert_raise(TypeError) { @img.orientation = 2 }
-  end
-
-  def test_page
-    assert_nothing_raised { @img.page }
-    page = @img.page
-    assert_equal(0, page.width)
-    assert_equal(0, page.height)
-    assert_equal(0, page.x)
-    assert_equal(0, page.y)
-    page = Magick::Rectangle.new(1, 2, 3, 4)
-    assert_nothing_raised { @img.page = page }
-    assert_equal(1, page.width)
-    assert_equal(2, page.height)
-    assert_equal(3, page.x)
-    assert_equal(4, page.y)
-    assert_raise(TypeError) { @img.page = 2 }
-  end
-
-  def test_pixel_interpolation_method
-    assert_nothing_raised { @img.pixel_interpolation_method }
-    assert_instance_of(Magick::PixelInterpolateMethod, @img.pixel_interpolation_method)
-    assert_equal(Magick::UndefinedInterpolatePixel, @img.pixel_interpolation_method)
-    assert_nothing_raised { @img.pixel_interpolation_method = Magick::AverageInterpolatePixel }
-    assert_equal(Magick::AverageInterpolatePixel, @img.pixel_interpolation_method)
-
-    Magick::PixelInterpolateMethod.values do |interpolate_pixel_method|
-      assert_nothing_raised { @img.pixel_interpolation_method = interpolate_pixel_method }
-    end
-    assert_raise(TypeError) { @img.pixel_interpolation_method = 2 }
-  end
-
-  def test_quality
-    assert_nothing_raised { @hat.quality }
-    assert_equal(75, @hat.quality)
-    assert_raise(NoMethodError) { @img.quality = 80 }
-  end
-
-  def test_quantum_depth
-    assert_nothing_raised { @img.quantum_depth }
-    assert_equal(Magick::MAGICKCORE_QUANTUM_DEPTH, @img.quantum_depth)
-    assert_raise(NoMethodError) { @img.quantum_depth = 8 }
-  end
-
-  def test_rendering_intent
-    assert_nothing_raised { @img.rendering_intent }
-    assert_instance_of(Magick::RenderingIntent, @img.rendering_intent)
-    assert_equal(Magick::PerceptualIntent, @img.rendering_intent)
-
-    Magick::RenderingIntent.values do |rendering_intent|
-      assert_nothing_raised { @img.rendering_intent = rendering_intent }
-    end
-    assert_raise(TypeError) { @img.rendering_intent = 2 }
-  end
-
-  def test_rows
-    assert_nothing_raised { @img.rows }
-    assert_equal(100, @img.rows)
-    assert_raise(NoMethodError) { @img.rows = 2 }
-  end
-
-  def test_scene
-    ilist = Magick::ImageList.new
-    ilist << @img
-    img = @img.copy
-    ilist << img
-    ilist.write('temp.gif')
-    FileUtils.rm('temp.gif')
-
-    assert_nothing_raised { img.scene }
-    assert_equal(0, @img.scene)
-    assert_equal(1, img.scene)
-    assert_raise(NoMethodError) { img.scene = 2 }
-  end
-
-  def test_start_loop
-    assert_nothing_raised { @img.start_loop }
-    assert(!@img.start_loop)
-    assert_nothing_raised { @img.start_loop = true }
-    assert(@img.start_loop)
-  end
-
-  def test_ticks_per_second
-    assert_nothing_raised { @img.ticks_per_second }
-    assert_equal(100, @img.ticks_per_second)
-    assert_nothing_raised { @img.ticks_per_second = 1000 }
-    assert_equal(1000, @img.ticks_per_second)
-    assert_raise(TypeError) { @img.ticks_per_second = 'x' }
-  end
-
-  def test_total_colors
-    assert_nothing_raised { @hat.total_colors }
-    assert_kind_of(Integer, @hat.total_colors)
-    assert_raise(NoMethodError) { @img.total_colors = 2 }
-  end
-
-  def test_units
-    assert_nothing_raised { @img.units }
-    assert_instance_of(Magick::ResolutionType, @img.units)
-    assert_equal(Magick::UndefinedResolution, @img.units)
-    assert_nothing_raised { @img.units = Magick::PixelsPerInchResolution }
-    assert_equal(Magick::PixelsPerInchResolution, @img.units)
-
-    Magick::ResolutionType.values do |resolution|
-      assert_nothing_raised { @img.units = resolution }
-    end
-    assert_raise(TypeError) { @img.units = 2 }
-  end
-
-  def test_virtual_pixel_method
-    assert_nothing_raised { @img.virtual_pixel_method }
-    assert_equal(Magick::UndefinedVirtualPixelMethod, @img.virtual_pixel_method)
-    assert_nothing_raised { @img.virtual_pixel_method = Magick::EdgeVirtualPixelMethod }
-    assert_equal(Magick::EdgeVirtualPixelMethod, @img.virtual_pixel_method)
-
-    Magick::VirtualPixelMethod.values do |virtual_pixel_method|
-      assert_nothing_raised { @img.virtual_pixel_method = virtual_pixel_method }
-    end
-    assert_raise(TypeError) { @img.virtual_pixel_method = 2 }
-  end
-
-  def test_x_resolution
-    assert_nothing_raised { @img.x_resolution }
-    assert_nothing_raised { @img.x_resolution = 90 }
-    assert_equal(90.0, @img.x_resolution)
-    assert_raise(TypeError) { @img.x_resolution = 'x' }
-  end
-
-  def test_y_resolution
-    assert_nothing_raised { @img.y_resolution }
-    assert_nothing_raised { @img.y_resolution = 90 }
-    assert_equal(90.0, @img.y_resolution)
-    assert_raise(TypeError) { @img.y_resolution = 'x' }
-  end
-
-  def test_frozen
-    @img.freeze
-    assert_raise(FreezeError) { @img.background_color = 'xxx' }
-    assert_raise(FreezeError) { @img.border_color = 'xxx' }
-    rp = Magick::Point.new(1, 1)
-    gp = Magick::Point.new(1, 1)
-    bp = Magick::Point.new(1, 1)
-    wp = Magick::Point.new(1, 1)
-    assert_raise(FreezeError) { @img.chromaticity = Magick::Chromaticity.new(rp, gp, bp, wp) }
-    assert_raise(FreezeError) { @img.class_type = Magick::DirectClass }
-    assert_raise(FreezeError) { @img.color_profile = 'xxx' }
-    assert_raise(FreezeError) { @img.colorspace = Magick::RGBColorspace }
-    assert_raise(FreezeError) { @img.compose = Magick::OverCompositeOp }
-    assert_raise(FreezeError) { @img.compression = Magick::RLECompression }
-    assert_raise(FreezeError) { @img.delay = 2 }
-    assert_raise(FreezeError) { @img.density = '72.0x72.0' }
-    assert_raise(FreezeError) { @img.dispose = Magick::NoneDispose }
-    assert_raise(FreezeError) { @img.endian = Magick::MSBEndian }
-    assert_raise(FreezeError) { @img.extract_info = Magick::Rectangle.new(1, 2, 3, 4) }
-    assert_raise(FreezeError) { @img.filter = Magick::PointFilter }
-    assert_raise(FreezeError) { @img.format = 'GIF' }
-    assert_raise(FreezeError) { @img.fuzz = 50.0 }
-    assert_raise(FreezeError) { @img.gamma = 2.0 }
-    assert_raise(FreezeError) { @img.geometry = '100x100' }
-    assert_raise(FreezeError) { @img.interlace = Magick::NoInterlace }
-    assert_raise(FreezeError) { @img.iptc_profile = 'xxx' }
-    assert_raise(FreezeError) { @img.monitor = proc { |name, _q, _s| puts name } }
-    assert_raise(FreezeError) { @img.offset = 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 }
-    assert_raise(FreezeError) { @img.ticks_per_second = 1000 }
-    assert_raise(FreezeError) { @img.units = Magick::PixelsPerInchResolution }
-    assert_raise(FreezeError) { @img.x_resolution = 72.0 }
-    assert_raise(FreezeError) { @img.y_resolution = 72.0 }
-  end
-end # class Image_Attributes_UT
-
-if $PROGRAM_NAME == __FILE__
-  FLOWER_HAT = '../doc/ex/images/Flower_Hat.jpg'
-  Test::Unit::UI::Console::TestRunner.run(ImageAttributesUT)
-end