rmagick 3.2.0 → 4.3.0

data/test/Draw.rb

@@ -1,351 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class DrawUT < Test::Unit::TestCase
-  def setup
-    @draw = Magick::Draw.new
-  end
-
-  def test_affine
-    assert_nothing_raised do
-      @draw.affine = Magick::AffineMatrix.new(1, 2, 3, 4, 5, 6)
-    end
-    assert_raise(TypeError) { @draw.affine = [1, 2, 3, 4, 5, 6] }
-  end
-
-  def test_align
-    Magick::AlignType.values do |align|
-      assert_nothing_raised { @draw.align = align }
-    end
-  end
-
-  def test_decorate
-    Magick::DecorationType.values do |decoration|
-      assert_nothing_raised { @draw.decorate = decoration }
-    end
-  end
-
-  def test_density
-    assert_nothing_raised { @draw.density = '90x90' }
-    assert_nothing_raised { @draw.density = 'x90' }
-    assert_nothing_raised { @draw.density = '90' }
-    assert_raise(TypeError) { @draw.density = 2 }
-  end
-
-  def test_encoding
-    assert_nothing_raised { @draw.encoding = 'AdobeCustom' }
-    assert_raise(TypeError) { @draw.encoding = 2 }
-  end
-
-  def test_fill
-    assert_nothing_raised { @draw.fill = 'white' }
-    assert_nothing_raised { @draw.fill = Magick::Pixel.from_color('white') }
-    assert_raise(TypeError) { @draw.fill = 2 }
-  end
-
-  def test_fill_pattern
-    assert_nothing_raised { @draw.fill_pattern = nil }
-    assert_nothing_raised do
-      img1 = Magick::Image.new(10, 10)
-      img2 = Magick::Image.new(20, 20)
-
-      @draw.fill_pattern = img1
-      @draw.fill_pattern = img2
-    end
-
-    assert_raise(NoMethodError) { @draw.fill_pattern = 'x' }
-  end
-
-  def test_font
-    assert_nothing_raised { @draw.font = 'Arial-Bold' }
-    assert_raise(TypeError) { @draw.font = 2 }
-  end
-
-  def test_font_family
-    assert_nothing_raised { @draw.font_family = 'Arial' }
-    assert_raise(TypeError) { @draw.font_family = 2 }
-  end
-
-  def test_font_stretch
-    Magick::StretchType.values do |stretch|
-      assert_nothing_raised { @draw.font_stretch = stretch }
-    end
-
-    assert_raise(TypeError) { @draw.font_stretch = 2 }
-  end
-
-  def test_font_style
-    Magick::StyleType.values do |style|
-      assert_nothing_raised { @draw.font_style = style }
-    end
-
-    assert_raise(TypeError) { @draw.font_style = 2 }
-  end
-
-  def test_font_weight
-    Magick::WeightType.values do |weight|
-      assert_nothing_raised { @draw.font_weight = weight }
-    end
-
-    assert_raise(ArgumentError) { @draw.font_weight = 99 }
-    assert_raise(ArgumentError) { @draw.font_weight = 901 }
-  end
-
-  def test_gravity
-    Magick::GravityType.values do |gravity|
-      assert_nothing_raised { @draw.gravity = gravity }
-    end
-
-    assert_raise(TypeError) { @draw.gravity = 2 }
-  end
-
-  def test_interline_spacing
-    assert_nothing_raised { @draw.interline_spacing = 2 }
-    assert_raise(TypeError) { @draw.interline_spacing = 'x' }
-  end
-
-  def test_interword_spacing
-    assert_nothing_raised { @draw.interword_spacing = 2 }
-    assert_raise(TypeError) { @draw.interword_spacing = 'x' }
-  end
-
-  def test_kerning
-    assert_nothing_raised { @draw.kerning = 2 }
-    assert_raise(TypeError) { @draw.kerning = 'x' }
-  end
-
-  def test_pointsize
-    assert_nothing_raised { @draw.pointsize = 2 }
-    assert_raise(TypeError) { @draw.pointsize = 'x' }
-  end
-
-  def test_rotation
-    assert_nothing_raised { @draw.rotation = 15 }
-    assert_raise(TypeError) { @draw.rotation = 'x' }
-  end
-
-  def test_stroke
-    assert_nothing_raised { @draw.stroke = Magick::Pixel.from_color('white') }
-    assert_nothing_raised { @draw.stroke = 'white' }
-    assert_raise(TypeError) { @draw.stroke = 2 }
-  end
-
-  def test_stroke_pattern
-    assert_nothing_raised { @draw.stroke_pattern = nil }
-    assert_nothing_raised do
-      img1 = Magick::Image.new(10, 10)
-      img2 = Magick::Image.new(20, 20)
-
-      @draw.stroke_pattern = img1
-      @draw.stroke_pattern = img2
-    end
-
-    assert_raise(NoMethodError) { @draw.stroke_pattern = 'x' }
-  end
-
-  def test_stroke_width
-    assert_nothing_raised { @draw.stroke_width = 15 }
-    assert_raise(TypeError) { @draw.stroke_width = 'x' }
-  end
-
-  def test_text_antialias
-    assert_nothing_raised { @draw.text_antialias = true }
-    assert_nothing_raised { @draw.text_antialias = false }
-  end
-
-  def test_tile
-    assert_nothing_raised { @draw.tile = nil }
-    assert_nothing_raised do
-      img1 = Magick::Image.new(10, 10)
-      img2 = Magick::Image.new(20, 20)
-
-      @draw.tile = img1
-      @draw.tile = img2
-    end
-  end
-
-  def test_undercolor
-    assert_nothing_raised { @draw.undercolor = Magick::Pixel.from_color('white') }
-    assert_nothing_raised { @draw.undercolor = 'white' }
-    assert_raise(TypeError) { @draw.undercolor = 2 }
-  end
-
-  def test_annotate
-    assert_nothing_raised do
-      img = Magick::Image.new(10, 10)
-      @draw.annotate(img, 0, 0, 0, 20, 'Hello world')
-
-      yield_obj = nil
-      @draw.annotate(img, 100, 100, 20, 20, 'Hello world 2') do |draw|
-        yield_obj = draw
-      end
-      assert_instance_of(Magick::Draw, yield_obj)
-    end
-
-    assert_raise(TypeError) do
-      img = Magick::Image.new(10, 10)
-      @draw.annotate(img, 0, 0, 0, 20, nil)
-    end
-
-    assert_raise(NoMethodError) { @draw.annotate('x', 0, 0, 0, 20, 'Hello world') }
-  end
-
-  def test_annotate_stack_buffer_overflow
-    assert_nothing_raised do
-      if 1.size == 8
-        # 64-bit environment can use larger value for Integer and it can causes stack buffer overflow.
-        img = Magick::Image.new(10, 10)
-        @draw.annotate(img, 2**63, 2**63, 2**62, 2**62, 'Hello world')
-      end
-    end
-  end
-
-  def test_dup
-    @draw.path('M110,100 h-75 a75,75 0 1,0 75,-75 z')
-    @draw.taint
-    @draw.freeze
-    dup = @draw.dup
-    assert_instance_of(Magick::Draw, dup)
-  end
-
-  def test_clone
-    @draw.taint
-    @draw.freeze
-    clone = @draw.clone
-    assert_instance_of(Magick::Draw, clone)
-  end
-
-  def test_composite
-    img = Magick::Image.new(10, 10)
-    assert_nothing_raised { @draw.composite(0, 0, 10, 10, img) }
-
-    Magick::CompositeOperator.values do |op|
-      assert_nothing_raised { @draw.composite(0, 0, 10, 10, img, op) }
-    end
-
-    assert_raise(TypeError) { @draw.composite('x', 0, 10, 10, img) }
-    assert_raise(TypeError) { @draw.composite(0, 'y', 10, 10, img) }
-    assert_raise(TypeError) { @draw.composite(0, 0, 'w', 10, img) }
-    assert_raise(TypeError) { @draw.composite(0, 0, 10, 'h', img) }
-    assert_raise(TypeError) { @draw.composite(0, 0, 10, 10, img, Magick::CenterAlign) }
-    assert_raise(NoMethodError) { @draw.composite(0, 0, 10, 10, 'image') }
-    assert_raise(ArgumentError) { @draw.composite(0, 0, 10, 10) }
-    assert_raise(ArgumentError) { @draw.composite(0, 0, 10, 10, img, Magick::ModulusAddCompositeOp, 'x') }
-  end
-
-  def test_draw
-    draw = @draw.dup
-
-    img = Magick::Image.new(10, 10)
-    @draw.path('M110,100 h-75 a75,75 0 1,0 75,-75 z')
-    assert_nothing_raised { @draw.draw(img) }
-
-    assert_raise(ArgumentError) { draw.draw(img) }
-    assert_raise(NoMethodError) { draw.draw('x') }
-  end
-
-  def test_get_type_metrics
-    img = Magick::Image.new(10, 10)
-    assert_nothing_raised { @draw.get_type_metrics('ABCDEF') }
-    assert_nothing_raised { @draw.get_type_metrics(img, 'ABCDEF') }
-
-    assert_raise(ArgumentError) { @draw.get_type_metrics }
-    assert_raise(ArgumentError) { @draw.get_type_metrics(img, 'ABCDEF', 20) }
-    assert_raise(ArgumentError) { @draw.get_type_metrics(img, '') }
-    assert_raise(NoMethodError) { @draw.get_type_metrics('x', 'ABCDEF') }
-  end
-
-  def test_get_multiline_type_metrics
-    img = Magick::Image.new(10, 10)
-    assert_nothing_raised { @draw.get_multiline_type_metrics('ABCDEF') }
-    assert_nothing_raised { @draw.get_multiline_type_metrics(img, 'ABCDEF') }
-
-    assert_raise(ArgumentError) { @draw.get_multiline_type_metrics }
-    assert_raise(ArgumentError) { @draw.get_multiline_type_metrics(img, 'ABCDEF', 20) }
-    assert_raise(ArgumentError) { @draw.get_multiline_type_metrics(img, '') }
-  end
-
-  def test_inspect
-    assert_equal('(no primitives defined)', @draw.inspect)
-
-    @draw.path('M110,100 h-75 a75,75 0 1,0 75,-75 z')
-    @draw.fill('yellow')
-    assert_equal("path 'M110,100 h-75 a75,75 0 1,0 75,-75 z'\nfill \"yellow\"", @draw.inspect)
-  end
-
-  def test_marshal
-    draw = @draw.dup
-    draw.affine = Magick::AffineMatrix.new(1, 2, 3, 4, 5, 6)
-    draw.decorate = Magick::LineThroughDecoration
-    draw.encoding = 'AdobeCustom'
-    draw.gravity = Magick::CenterGravity
-    draw.fill = Magick::Pixel.from_color('red')
-    draw.fill_pattern = Magick::Image.new(10, 10) { self.format = 'miff' }
-    draw.stroke = Magick::Pixel.from_color('blue')
-    draw.stroke_width = 5
-    draw.text_antialias = true
-    draw.font = 'Arial-Bold'
-    draw.font_family = 'arial'
-    draw.font_style = Magick::ItalicStyle
-    draw.font_stretch = Magick::CondensedStretch
-    draw.font_weight = Magick::BoldWeight
-    draw.pointsize = 12
-    draw.density = '72x72'
-    draw.align = Magick::CenterAlign
-    draw.undercolor = Magick::Pixel.from_color('green')
-    draw.kerning = 10.5
-    draw.interword_spacing = 3.75
-
-    draw.circle(20, 25, 20, 28)
-
-    dumped = nil
-    assert_nothing_raised { dumped = draw.marshal_dump }
-
-    draw2 = @draw.dup
-    assert_nothing_raised do
-      draw2.marshal_load(dumped)
-    end
-    assert_equal(draw.inspect, draw2.inspect)
-  end
-
-  def test_primitive
-    assert_nothing_raised { @draw.primitive('ABCDEF') }
-    assert_nothing_raised { @draw.primitive('12345') }
-    assert_raise(TypeError) { @draw.primitive(nil) }
-  end
-
-  def test_draw_options
-    assert_nothing_raised do
-      yield_obj = nil
-
-      Magick::Draw.new do |option|
-        yield_obj = option
-      end
-      assert_instance_of(Magick::Image::DrawOptions, yield_obj)
-    end
-  end
-
-  def test_issue_604
-    points = [0, 0, 1, 1, 2, 2]
-
-    pr = Magick::Draw.new
-
-    pr.define_clip_path('example') do
-      pr.polygon(*points)
-    end
-
-    pr.push
-    pr.clip_path('example')
-
-    composite = Magick::Image.new(10, 10)
-    pr.composite(0, 0, 10, 10, composite)
-
-    pr.pop
-
-    canvas = Magick::Image.new(10, 10)
-    pr.draw(canvas)
-  end
-end

data/test/Enum.rb

@@ -1,228 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class EnumUT < Test::Unit::TestCase
-  def test_new
-    assert_nothing_raised { Magick::Enum.new(:foo, 42) }
-    assert_nothing_raised { Magick::Enum.new('foo', 42) }
-
-    assert_raise(TypeError) { Magick::Enum.new(Object.new, 42) }
-    assert_raise(TypeError) { Magick::Enum.new(:foo, 'x') }
-  end
-
-  def test_to_s
-    enum = Magick::Enum.new(:foo, 42)
-    assert_equal('foo', enum.to_s)
-
-    enum = Magick::Enum.new('foo', 42)
-    assert_equal('foo', enum.to_s)
-  end
-
-  def test_to_i
-    enum = Magick::Enum.new(:foo, 42)
-    assert_equal(42, enum.to_i)
-  end
-
-  def test_spaceship
-    enum1 = Magick::Enum.new(:foo, 42)
-    enum2 = Magick::Enum.new(:foo, 56)
-    enum3 = Magick::Enum.new(:foo, 36)
-    enum4 = Magick::Enum.new(:foo, 42)
-
-    assert_equal(-1, enum1 <=> enum2)
-    assert_equal(0, enum1 <=> enum4)
-    assert_equal(1, enum1 <=> enum3)
-    assert_nil(enum1 <=> 'x')
-  end
-
-  def test_case_eq
-    enum1 = Magick::Enum.new(:foo, 42)
-    enum2 = Magick::Enum.new(:foo, 56)
-
-    assert_true(enum1 === enum1)
-    assert_false(enum1 === enum2)
-    assert_false(enum1 === 'x')
-  end
-
-  def test_bitwise_or
-    enum1 = Magick::Enum.new(:foo, 42)
-    enum2 = Magick::Enum.new(:bar, 56)
-
-    enum = enum1 | enum2
-    assert_equal(58, enum.to_i)
-    assert_equal('foo|bar', enum.to_s)
-
-    assert_raise(ArgumentError) { enum1 | 'x' }
-  end
-
-  def test_type_values
-    assert_instance_of(Array, Magick::AlignType.values)
-
-    assert_equal('UndefinedAlign', Magick::AlignType.values[0].to_s)
-    assert_equal(0, Magick::AlignType.values[0].to_i)
-
-    Magick::AlignType.values do |enum|
-      assert_kind_of(Magick::Enum, enum)
-      assert_instance_of(Magick::AlignType, enum)
-    end
-  end
-
-  def test_type_inspect
-    assert_equal('UndefinedAlign=0', Magick::AlignType.values[0].inspect)
-  end
-
-  def test_using_compose_does_not_cause_endless_loop
-    img = Magick::Image.new(10, 10)
-    Magick::CompositeOperator.values do |op|
-      img.compose = op
-      assert_equal(op, img.compose)
-    end
-  end
-
-  def test_using_class_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::ClassType.values do |value|
-      next if value == Magick::UndefinedClass
-
-      img.class_type = value
-      assert_equal(value, img.class_type)
-    end
-  end
-
-  def test_using_colorspace_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::ColorspaceType.values do |value|
-      next if value == Magick::SRGBColorspace
-
-      assert_not_equal(value, img.colorspace)
-    end
-  end
-
-  def test_using_compression_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::CompressionType.values do |value|
-      img.compression = value
-      assert_equal(value, img.compression)
-    end
-  end
-
-  def test_using_dispose_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::DisposeType.values do |value|
-      img.dispose = value
-      assert_equal(value, img.dispose)
-    end
-  end
-
-  def test_using_endian_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::EndianType.values do |value|
-      img.endian = value
-      assert_equal(value, img.endian)
-    end
-  end
-
-  def test_using_filter_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::FilterType.values do |value|
-      img.filter = value
-      assert_equal(value, img.filter)
-    end
-  end
-
-  def test_using_gravity_type_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::GravityType.values do |value|
-      img.gravity = value
-      assert_equal(value, img.gravity)
-    end
-  end
-
-  def test_using_image_type_does_not_cause_endless_loop
-    info = Magick::Image::Info.new
-    Magick::ImageType.values do |value|
-      info.image_type = value
-      assert_equal(value, info.image_type)
-    end
-  end
-
-  def test_using_orientation_type_does_not_cause_endless_loop
-    info = Magick::Image::Info.new
-    Magick::OrientationType.values do |value|
-      info.orientation = value
-      assert_equal(value, info.orientation)
-    end
-  end
-
-  def test_using_interlace_type_does_not_cause_endless_loop
-    info = Magick::Image::Info.new
-    Magick::InterlaceType.values do |value|
-      info.interlace = value
-      assert_equal(value, info.interlace)
-    end
-  end
-
-  def test_using_pixel_interpolation_method_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::PixelInterpolateMethod.values do |value|
-      img.pixel_interpolation_method = value
-      assert_equal(value, img.pixel_interpolation_method)
-    end
-  end
-
-  def test_using_rendering_intent_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::RenderingIntent.values do |value|
-      img.rendering_intent = value
-      assert_equal(value, img.rendering_intent)
-    end
-  end
-
-  def test_using_resolution_type_does_not_cause_endless_loop
-    info = Magick::Image::Info.new
-    Magick::ResolutionType.values do |value|
-      info.units = value
-      assert_equal(value, info.units)
-    end
-  end
-
-  def test_using_virtual_pixel_method_does_not_cause_endless_loop
-    img = Magick::Image.new(1, 1)
-    Magick::VirtualPixelMethod.values do |value|
-      img.virtual_pixel_method = value
-      assert_equal(value, img.virtual_pixel_method)
-    end
-  end
-
-  def test_storage_type_name
-    img = Magick::Image.new(20, 20)
-    pixels = img.export_pixels(0, 0, 20, 20, 'RGB').pack('D*')
-
-    assert_raise_message(/UndefinedPixel/) do
-      img.import_pixels(0, 0, 20, 20, 'RGB', pixels, Magick::UndefinedPixel)
-    end
-  end
-
-  def test_stretch_type_name
-    Magick::StretchType.values do |stretch|
-      font = Magick::Font.new('Arial', 'font test', 'Arial family', Magick::NormalStyle, stretch, 400, nil, 'test foundry', 'test format')
-      assert_match(/stretch=#{stretch.to_s}/, font.to_s)
-    end
-
-    font = Magick::Font.new('Arial', 'font test', 'Arial family', Magick::NormalStyle, nil, 400, nil, 'test foundry', 'test format')
-    assert_match(/stretch=UndefinedStretch/, font.to_s)
-  end
-
-  def test_style_type_name
-    Magick::StyleType.values do |style|
-      font = Magick::Font.new('Arial', 'font test', 'Arial family', style, Magick::NormalStretch, 400, nil, 'test foundry', 'test format')
-      assert_match(/style=#{style.to_s}/, font.to_s)
-    end
-
-    font = Magick::Font.new('Arial', 'font test', 'Arial family', nil, Magick::NormalStretch, 400, nil, 'test foundry', 'test format')
-    assert_match(/style=UndefinedStyle/, font.to_s)
-  end
-end

data/test/Fill.rb

@@ -1,93 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'rmagick'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-class GradientFillUT < Test::Unit::TestCase
-  def test_new
-    assert_instance_of(Magick::GradientFill, Magick::GradientFill.new(0, 0, 0, 100, '#900', '#000'))
-    assert_instance_of(Magick::GradientFill, Magick::GradientFill.new(0, 0, 0, 100, 'white', 'red'))
-
-    assert_raise(ArgumentError) { Magick::GradientFill.new(0, 0, 0, 100, 'foo', '#000') }
-    assert_raise(ArgumentError) { Magick::GradientFill.new(0, 0, 0, 100, '#900', 'bar') }
-    assert_raise(TypeError) { Magick::GradientFill.new('x1', 0, 0, 100, '#900', '#000') }
-    assert_raise(TypeError) { Magick::GradientFill.new(0, 'y1', 0, 100, '#900', '#000') }
-    assert_raise(TypeError) { Magick::GradientFill.new(0, 0, 'x2', 100, '#900', '#000') }
-    assert_raise(TypeError) { Magick::GradientFill.new(0, 0, 0, 'y2', '#900', '#000') }
-  end
-
-  def test_fill
-    img = Magick::Image.new(10, 10)
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 0, 0, 0, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 0, 0, 10, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 0, 10, 0, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 0, 10, 10, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 0, 5, 20, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(-10, 0, -10, 10, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, -10, 10, -10, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, -10, 10, -20, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-
-    assert_nothing_raised do
-      gradient = Magick::GradientFill.new(0, 100, 100, 200, '#900', '#000')
-      obj = gradient.fill(img)
-      assert_equal(gradient, obj)
-    end
-  end
-end
-
-class TextureFillUT < Test::Unit::TestCase
-  def test_new
-    granite = Magick::Image.read('granite:').first
-    assert_instance_of(Magick::TextureFill, Magick::TextureFill.new(granite))
-  end
-
-  def test_fill
-    granite = Magick::Image.read('granite:').first
-    texture = Magick::TextureFill.new(granite)
-
-    img = Magick::Image.new(10, 10)
-    obj = texture.fill(img)
-    assert_equal(texture, obj)
-  end
-end