#!/usr/bin/env ruby -w require 'rmagick' require 'test/unit' require 'test/unit/ui/console/testrunner' # TODO: improve exif tests - need a benchmark image with EXIF data class Image2_UT < Test::Unit::TestCase def setup @img = Magick::Image.new(20, 20) end def test_composite img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first Magick::CompositeOperator.values do |op| Magick::GravityType.values do |gravity| assert_nothing_raised do res = img1.composite(img2, gravity, 5, 5, op) assert_not_same(img1, res) end end end assert_nothing_raised do res = img1.composite(img2, 5, 5, Magick::OverCompositeOp) assert_not_same(img1, res) end assert_raise(TypeError) { img1.composite(img2, 'x', 5, Magick::OverCompositeOp) } assert_raise(TypeError) { img1.composite(img2, 5, 'y', Magick::OverCompositeOp) } assert_raise(TypeError) { img1.composite(img2, Magick::NorthWestGravity, 'x', 5, Magick::OverCompositeOp) } assert_raise(TypeError) { img1.composite(img2, Magick::NorthWestGravity, 5, 'y', Magick::OverCompositeOp) } img1.freeze assert_nothing_raised { img1.composite(img2, Magick::NorthWestGravity, Magick::OverCompositeOp) } end def test_composite! img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first Magick::CompositeOperator.values do |op| Magick::GravityType.values do |gravity| assert_nothing_raised do res = img1.composite!(img2, gravity, op) assert_same(img1, res) end end end img1.freeze assert_raise(FreezeError) { img1.composite!(img2, Magick::NorthWestGravity, Magick::OverCompositeOp) } end def test_composite_affine affine = Magick::AffineMatrix.new(1, 0, 1, 0, 0, 0) img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first assert_nothing_raised do res = img1.composite_affine(img2, affine) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end end def test_composite_channel img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first Magick::CompositeOperator.values do |op| Magick::GravityType.values do |gravity| assert_nothing_raised do res = img1.composite_channel(img2, gravity, 5, 5, op, Magick::BlueChannel) assert_not_same(img1, res) end end end assert_raise(ArgumentError) { img1.composite_channel(img2, Magick::NorthWestGravity) } assert_raise(TypeError) { img1.composite_channel(img2, Magick::NorthWestGravity, 5, 5, Magick::OverCompositeOp, 'x') } end def test_composite_mathematics bg = Magick::Image.new(50, 50) fg = Magick::Image.new(50, 50) { self.background_color = 'black' } res = nil assert_nothing_raised { res = bg.composite_mathematics(fg, 1, 0, 0, 0, Magick::CenterGravity) } assert_instance_of(Magick::Image, res) assert_not_same(bg, res) assert_not_same(fg, res) assert_nothing_raised { res = bg.composite_mathematics(fg, 1, 0, 0, 0, 0.0, 0.0) } assert_nothing_raised { res = bg.composite_mathematics(fg, 1, 0, 0, 0, Magick::CenterGravity, 0.0, 0.0) } # too few arguments assert_raise(ArgumentError) { bg.composite_mathematics(fg, 1, 0, 0, 0) } # too many arguments assert_raise(ArgumentError) { bg.composite_mathematics(fg, 1, 0, 0, 0, Magick::CenterGravity, 0.0, 0.0, 'x') } end def test_composite_tiled bg = Magick::Image.new(200, 200) fg = Magick::Image.new(50, 100) { self.background_color = 'black' } res = nil assert_nothing_raised do res = bg.composite_tiled(fg) end assert_instance_of(Magick::Image, res) assert_not_same(bg, res) assert_not_same(fg, res) assert_nothing_raised { bg.composite_tiled!(fg) } assert_nothing_raised { bg.composite_tiled(fg, Magick::AtopCompositeOp) } assert_nothing_raised { bg.composite_tiled(fg, Magick::OverCompositeOp) } assert_nothing_raised { bg.composite_tiled(fg, Magick::RedChannel) } assert_nothing_raised { bg.composite_tiled(fg, Magick::RedChannel, Magick::GreenChannel) } assert_raise(ArgumentError) { bg.composite_tiled } assert_raise(TypeError) { bg.composite_tiled(fg, 'x') } assert_raise(TypeError) { bg.composite_tiled(fg, Magick::AtopCompositeOp, Magick::RedChannel, 'x') } fg.destroy! assert_raise(Magick::DestroyedImageError) { bg.composite_tiled(fg) } end def test_compress_colormap! # DirectClass images are converted to PseudoClass in older versions of ImageMagick. assert_equal(Magick::DirectClass, @img.class_type) assert_nothing_raised { @img.compress_colormap! } # assert_equal(Magick::PseudoClass, @img.class_type) @img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first assert_equal(Magick::PseudoClass, @img.class_type) assert_nothing_raised { @img.compress_colormap! } end def test_contrast assert_nothing_raised do res = @img.contrast assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.contrast(true) } assert_raise(ArgumentError) { @img.contrast(true, 2) } end def test_contrast_stretch_channel assert_nothing_raised do res = @img.contrast_stretch_channel(25) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.contrast_stretch_channel(25, 50) } assert_nothing_raised { @img.contrast_stretch_channel('10%') } assert_nothing_raised { @img.contrast_stretch_channel('10%', '50%') } assert_nothing_raised { @img.contrast_stretch_channel(25, 50, Magick::RedChannel) } assert_nothing_raised { @img.contrast_stretch_channel(25, 50, Magick::RedChannel, Magick::GreenChannel) } assert_raise(TypeError) { @img.contrast_stretch_channel(25, 50, 'x') } assert_raise(ArgumentError) { @img.contrast_stretch_channel } assert_raise(ArgumentError) { @img.contrast_stretch_channel('x') } assert_raise(ArgumentError) { @img.contrast_stretch_channel(25, 'x') } end def test_morphology kernel = Magick::KernelInfo.new('Octagon') Magick::MorphologyMethod.values do |method| assert_nothing_raised do res = @img.morphology(method, 2, kernel) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end end end def test_morphology_channel assert_raise(ArgumentError) { @img.morphology_channel } assert_raise(ArgumentError) { @img.morphology_channel(Magick::RedChannel) } assert_raise(ArgumentError) { @img.morphology_channel(Magick::RedChannel, Magick::EdgeOutMorphology) } assert_raise(ArgumentError) { @img.morphology_channel(Magick::RedChannel, Magick::EdgeOutMorphology, 2) } assert_raise(ArgumentError) { @img.morphology_channel(Magick::RedChannel, Magick::EdgeOutMorphology, 2, :not_kernel_info) } kernel = Magick::KernelInfo.new('Octagon') assert_nothing_raised do res = @img.morphology_channel(Magick::RedChannel, Magick::EdgeOutMorphology, 2, kernel) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end end def test_convolve kernel = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] order = 3 assert_nothing_raised do res = @img.convolve(order, kernel) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_raise(ArgumentError) { @img.convolve } assert_raise(ArgumentError) { @img.convolve(0) } assert_raise(ArgumentError) { @img.convolve(-1) } assert_raise(ArgumentError) { @img.convolve(order) } assert_raise(IndexError) { @img.convolve(5, kernel) } assert_raise(IndexError) { @img.convolve(order, 'x') } assert_raise(TypeError) { @img.convolve(3, [1.0, 1.0, 1.0, 1.0, 'x', 1.0, 1.0, 1.0, 1.0]) } assert_raise(ArgumentError) { @img.convolve(-1, [1.0, 1.0, 1.0, 1.0]) } end def test_convolve_channel assert_raise(ArgumentError) { @img.convolve_channel } assert_raise(ArgumentError) { @img.convolve_channel(0) } assert_raise(ArgumentError) { @img.convolve_channel(-1) } assert_raise(ArgumentError) { @img.convolve_channel(3) } kernel = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] order = 3 assert_nothing_raised do res = @img.convolve_channel(order, kernel, Magick::RedChannel) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.convolve_channel(order, kernel, Magick::RedChannel, Magick:: BlueChannel) } assert_raise(TypeError) { @img.convolve_channel(order, kernel, Magick::RedChannel, 2) } end def test_copy assert_nothing_raised do ditto = @img.copy assert_equal(@img, ditto) end ditto = @img.copy assert_equal(@img.tainted?, ditto.tainted?) @img.taint ditto = @img.copy assert_equal(@img.tainted?, ditto.tainted?) end def test_crop assert_raise(ArgumentError) { @img.crop } assert_raise(ArgumentError) { @img.crop(0, 0) } assert_nothing_raised do res = @img.crop(0, 0, @img.columns / 2, @img.rows / 2) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end # 3-argument form Magick::GravityType.values do |grav| assert_nothing_raised { @img.crop(grav, @img.columns / 2, @img.rows / 2) } end assert_raise(TypeError) { @img.crop(2, @img.columns / 2, @img.rows / 2) } assert_raise(TypeError) { @img.crop(Magick::NorthWestGravity, @img.columns / 2, @img.rows / 2, 2) } # 4-argument form assert_raise(TypeError) { @img.crop(0, 0, @img.columns / 2, 'x') } assert_raise(TypeError) { @img.crop(0, 0, 'x', @img.rows / 2) } assert_raise(TypeError) { @img.crop(0, 'x', @img.columns / 2, @img.rows / 2) } assert_raise(TypeError) { @img.crop('x', 0, @img.columns / 2, @img.rows / 2) } assert_raise(TypeError) { @img.crop(0, 0, @img.columns / 2, @img.rows / 2, 2) } # 5-argument form Magick::GravityType.values do |grav| assert_nothing_raised { @img.crop(grav, 0, 0, @img.columns / 2, @img.rows / 2) } end assert_raise(ArgumentError) { @img.crop(Magick::NorthWestGravity, 0, 0, @img.columns / 2, @img.rows / 2, 2) } end def test_crop! assert_nothing_raised do res = @img.crop!(0, 0, @img.columns / 2, @img.rows / 2) assert_same(@img, res) end end def test_cycle_colormap assert_nothing_raised do res = @img.cycle_colormap(5) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) assert_equal(Magick::PseudoClass, res.class_type) end end def test_decipher # tests encipher, too. res = res2 = nil assert_nothing_raised do res = @img.encipher 'passphrase' res2 = res.decipher 'passphrase' end assert_instance_of(Magick::Image, res) assert_not_same(@img, res) assert_equal(@img.columns, res.columns) assert_equal(@img.rows, res.rows) assert_instance_of(Magick::Image, res2) assert_not_same(@img, res2) assert_equal(@img.columns, res2.columns) assert_equal(@img.rows, res2.rows) assert_equal(@img, res2) end def test_define assert_nothing_raised { @img.define('deskew:auto-crop', 40) } assert_nothing_raised { @img.undefine('deskew:auto-crop') } assert_nothing_raised { @img.define('deskew:auto-crop', nil) } end def test_deskew assert_nothing_raised do res = @img.deskew assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.deskew(0.10) } assert_nothing_raised { @img.deskew('95%') } assert_raise(ArgumentError) { @img.deskew('x') } assert_raise(TypeError) { @img.deskew(0.40, 'x') } assert_raise(ArgumentError) { @img.deskew(0.40, 20, [1]) } end def test_despeckle assert_nothing_raised do res = @img.despeckle assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end end # ensure methods detect destroyed images def test_destroy methods = Magick::Image.instance_methods(false).sort methods -= %i[__display__ destroy! destroyed? inspect cur_image marshal_load] assert_equal(false, @img.destroyed?) @img.destroy! assert_equal(true, @img.destroyed?) assert_raises(Magick::DestroyedImageError) { @img.check_destroyed } methods.each do |method| arity = @img.method(method).arity method = method.to_s if method == '[]=' assert_raises(Magick::DestroyedImageError) { @img['foo'] = 1 } elsif method == 'difference' other = Magick::Image.new(20, 20) assert_raises(Magick::DestroyedImageError) { @img.difference(other) } elsif method == 'channel_entropy' && IM_VERSION < Gem::Version.new('6.9') assert_raises(NotImplementedError) { @img.channel_entropy } elsif method == 'get_iptc_dataset' assert_raises(Magick::DestroyedImageError) { @img.get_iptc_dataset('x') } elsif method == 'profile!' assert_raises(Magick::DestroyedImageError) { @img.profile!('x', 'y') } elsif /=\Z/.match(method) assert_raises(Magick::DestroyedImageError) { @img.send(method, 1) } elsif arity.zero? assert_raises(Magick::DestroyedImageError) { @img.send(method) } elsif arity < 0 args = (1..-arity).to_a assert_raises(Magick::DestroyedImageError) { @img.send(method, *args) } elsif arity > 0 args = (1..arity).to_a assert_raises(Magick::DestroyedImageError) { @img.send(method, *args) } else # Don't know how to test! flunk("don't know how to test method #{method}") end end end # ensure destroy! works def test_destroy2 images = {} GC.disable Magick.trace_proc = proc do |which, id, addr, method| m = id.split(/ /) name = File.basename m[0] assert(%i[c d].include?(which), "unexpected value for which: #{which}") assert_equal(:destroy!, method) if which == :d if which == :c assert(!images.key?(addr), 'duplicate image addresses') images[addr] = name else assert(images.key?(addr), 'destroying image that was not created') assert_equal(name, images[addr]) end end unmapped = Magick::ImageList.new(IMAGES_DIR + '/Hot_Air_Balloons.jpg', IMAGES_DIR + '/Violin.jpg', IMAGES_DIR + '/Polynesia.jpg') map = Magick::ImageList.new 'netscape:' mapped = unmapped.remap map unmapped.each(&:destroy!) map.destroy! mapped.each(&:destroy!) ensure GC.enable Magick.trace_proc = nil end def test_difference img1 = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first img2 = Magick::Image.read(IMAGES_DIR + '/Button_1.gif').first assert_nothing_raised do res = img1.difference(img2) assert_instance_of(Array, res) assert_equal(3, res.length) assert_instance_of(Float, res[0]) assert_instance_of(Float, res[1]) assert_instance_of(Float, res[2]) end assert_raise(NoMethodError) { img1.difference(2) } img2.destroy! assert_raise(Magick::DestroyedImageError) { img1.difference(img2) } end def test_displace @img2 = Magick::Image.new(20, 20) { self.background_color = 'black' } assert_nothing_raised { @img.displace(@img2, 25) } res = @img.displace(@img2, 25) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) assert_nothing_raised { @img.displace(@img2, 25, 25) } assert_nothing_raised { @img.displace(@img2, 25, 25, 10) } assert_nothing_raised { @img.displace(@img2, 25, 25, 10, 10) } assert_nothing_raised { @img.displace(@img2, 25, 25, Magick::CenterGravity) } assert_nothing_raised { @img.displace(@img2, 25, 25, Magick::CenterGravity, 10) } assert_nothing_raised { @img.displace(@img2, 25, 25, Magick::CenterGravity, 10, 10) } assert_raise(ArgumentError) { @img.displace } assert_raise(TypeError) { @img.displace(@img2, 'x') } assert_raise(TypeError) { @img.displace(@img2, 25, []) } assert_raise(TypeError) { @img.displace(@img2, 25, 25, 'x') } assert_raise(TypeError) { @img.displace(@img2, 25, 25, Magick::CenterGravity, 'x') } assert_raise(TypeError) { @img.displace(@img2, 25, 25, Magick::CenterGravity, 10, []) } @img2.destroy! assert_raise(Magick::DestroyedImageError) { @img.displace(@img2, 25, 25) } end def test_dissolve src = Magick::Image.new(@img.columns, @img.rows) src_list = Magick::ImageList.new src_list << src.copy assert_nothing_raised { @img.dissolve(src, 0.50) } assert_nothing_raised { @img.dissolve(src_list, 0.50) } assert_nothing_raised { @img.dissolve(src, '50%') } assert_nothing_raised { @img.dissolve(src, 0.50, 0.10) } assert_nothing_raised { @img.dissolve(src, 0.50, 0.10, 10) } assert_nothing_raised { @img.dissolve(src, 0.50, 0.10, Magick::NorthEastGravity) } assert_nothing_raised { @img.dissolve(src, 0.50, 0.10, Magick::NorthEastGravity, 10) } assert_nothing_raised { @img.dissolve(src, 0.50, 0.10, Magick::NorthEastGravity, 10, 10) } assert_raise(ArgumentError) { @img.dissolve } assert_raise(ArgumentError) { @img.dissolve(src, 'x') } assert_raise(ArgumentError) { @img.dissolve(src, 0.50, 'x') } assert_raise(TypeError) { @img.dissolve(src, 0.50, Magick::NorthEastGravity, 'x') } assert_raise(TypeError) { @img.dissolve(src, 0.50, Magick::NorthEastGravity, 10, 'x') } src.destroy! assert_raise(Magick::DestroyedImageError) { @img.dissolve(src, 0.50) } end def test_distort @img = Magick::Image.new(200, 200) assert_nothing_raised { @img.distort(Magick::AffineDistortion, [2, 60, 2, 60, 32, 60, 32, 60, 2, 30, 17, 35]) } assert_nothing_raised { @img.distort(Magick::AffineProjectionDistortion, [1, 0, 0, 1, 0, 0]) } assert_nothing_raised { @img.distort(Magick::BilinearDistortion, [7, 40, 4, 30, 4, 124, 4, 123, 85, 122, 100, 123, 85, 2, 100, 30]) } assert_nothing_raised { @img.distort(Magick::PerspectiveDistortion, [7, 40, 4, 30, 4, 124, 4, 123, 85, 122, 100, 123, 85, 2, 100, 30]) } assert_nothing_raised { @img.distort(Magick::ScaleRotateTranslateDistortion, [28, 24, 0.4, 0.8 - 110, 37.5, 60]) } assert_nothing_raised { @img.distort(Magick::ScaleRotateTranslateDistortion, [28, 24, 0.4, 0.8 - 110, 37.5, 60], true) } assert_raise(ArgumentError) { @img.distort } assert_raise(ArgumentError) { @img.distort(Magick::AffineDistortion) } assert_raise(TypeError) { @img.distort(1, [1]) } assert_raise(TypeError) { @img.distort(Magick::AffineDistortion, [2, 60, 2, 60, 32, 60, 32, 60, 2, 30, 17, 'x']) } end def test_distortion_channel assert_nothing_raised do metric = @img.distortion_channel(@img, Magick::MeanAbsoluteErrorMetric) assert_instance_of(Float, metric) assert_equal(0.0, metric) end assert_nothing_raised { @img.distortion_channel(@img, Magick::MeanSquaredErrorMetric) } assert_nothing_raised { @img.distortion_channel(@img, Magick::PeakAbsoluteErrorMetric) } assert_nothing_raised { @img.distortion_channel(@img, Magick::PeakSignalToNoiseRatioErrorMetric) } assert_nothing_raised { @img.distortion_channel(@img, Magick::RootMeanSquaredErrorMetric) } assert_nothing_raised { @img.distortion_channel(@img, Magick::MeanSquaredErrorMetric, Magick::RedChannel, Magick:: BlueChannel) } assert_nothing_raised { @img.distortion_channel(@img, Magick::NormalizedCrossCorrelationErrorMetric) } assert_nothing_raised { @img.distortion_channel(@img, Magick::FuzzErrorMetric) } assert_raise(TypeError) { @img.distortion_channel(@img, 2) } assert_raise(TypeError) { @img.distortion_channel(@img, Magick::RootMeanSquaredErrorMetric, 2) } assert_raise(ArgumentError) { @img.distortion_channel } assert_raise(ArgumentError) { @img.distortion_channel(@img) } img = Magick::Image.new(20, 20) img.destroy! assert_raise(Magick::DestroyedImageError) { @img.distortion_channel(img, Magick::MeanSquaredErrorMetric) } end def test__dump img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first assert_instance_of(String, img._dump(10)) end def test__load img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first res = img._dump(10) assert_instance_of(Magick::Image, Magick::Image._load(res)) end def test_dup assert_nothing_raised do ditto = @img.dup assert_equal(@img, ditto) end ditto = @img.dup assert_equal(@img.tainted?, ditto.tainted?) @img.taint ditto = @img.dup assert_equal(@img.tainted?, ditto.tainted?) end def test_each_profile assert_nil(@img.each_profile {}) @img.iptc_profile = 'test profile' assert_nothing_raised do @img.each_profile do |name, value| assert_equal('iptc', name) assert_equal('test profile', value) end end end def test_edge assert_nothing_raised do res = @img.edge assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.edge(2.0) } assert_raise(ArgumentError) { @img.edge(2.0, 2) } assert_raise(TypeError) { @img.edge('x') } end def test_emboss assert_nothing_raised do res = @img.emboss assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.emboss(1.0) } assert_nothing_raised { @img.emboss(1.0, 0.5) } assert_raise(ArgumentError) { @img.emboss(1.0, 0.5, 2) } assert_raise(TypeError) { @img.emboss(1.0, 'x') } assert_raise(TypeError) { @img.emboss('x', 1.0) } end def test_enhance assert_nothing_raised do res = @img.enhance assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end end def test_equalize assert_nothing_raised do res = @img.equalize assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end end def test_equalize_channel assert_nothing_raised do res = @img.equalize_channel assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.equalize_channel } assert_nothing_raised { @img.equalize_channel(Magick::RedChannel) } assert_nothing_raised { @img.equalize_channel(Magick::RedChannel, Magick::BlueChannel) } assert_raise(TypeError) { @img.equalize_channel(Magick::RedChannel, 2) } end def test_erase! assert_nothing_raised do res = @img.erase! assert_same(@img, res) end end def test_excerpt res = nil img = Magick::Image.new(200, 200) assert_nothing_raised { res = @img.excerpt(20, 20, 50, 100) } assert_not_same(img, res) assert_equal(50, res.columns) assert_equal(100, res.rows) assert_nothing_raised { img.excerpt!(20, 20, 50, 100) } assert_equal(50, img.columns) assert_equal(100, img.rows) end def test_export_pixels assert_nothing_raised do res = @img.export_pixels assert_instance_of(Array, res) assert_equal(@img.columns * @img.rows * 'RGB'.length, res.length) res.each do |p| assert_kind_of(Integer, p) end end assert_nothing_raised { @img.export_pixels(0) } assert_nothing_raised { @img.export_pixels(0, 0) } assert_nothing_raised { @img.export_pixels(0, 0, 10) } assert_nothing_raised { @img.export_pixels(0, 0, 10, 10) } assert_nothing_raised do res = @img.export_pixels(0, 0, 10, 10, 'RGBA') assert_equal(10 * 10 * 'RGBA'.length, res.length) end assert_nothing_raised do res = @img.export_pixels(0, 0, 10, 10, 'I') assert_equal(10 * 10 * 'I'.length, res.length) end # too many arguments assert_raise(ArgumentError) { @img.export_pixels(0, 0, 10, 10, 'I', 2) } end def test_export_pixels_to_str assert_nothing_raised do res = @img.export_pixels_to_str assert_instance_of(String, res) assert_equal(@img.columns * @img.rows * 'RGB'.length, res.length) end assert_nothing_raised { @img.export_pixels_to_str(0) } assert_nothing_raised { @img.export_pixels_to_str(0, 0) } assert_nothing_raised { @img.export_pixels_to_str(0, 0, 10) } assert_nothing_raised { @img.export_pixels_to_str(0, 0, 10, 10) } assert_nothing_raised do res = @img.export_pixels_to_str(0, 0, 10, 10, 'RGBA') assert_equal(10 * 10 * 'RGBA'.length, res.length) end assert_nothing_raised do res = @img.export_pixels_to_str(0, 0, 10, 10, 'I') assert_equal(10 * 10 * 'I'.length, res.length) end assert_nothing_raised do res = @img.export_pixels_to_str(0, 0, 10, 10, 'I', Magick::CharPixel) assert_equal(10 * 10 * 1, res.length) end assert_nothing_raised do res = @img.export_pixels_to_str(0, 0, 10, 10, 'I', Magick::ShortPixel) assert_equal(10 * 10 * 2, res.length) end assert_nothing_raised do res = @img.export_pixels_to_str(0, 0, 10, 10, 'I', Magick::LongPixel) assert_equal(10 * 10 * [1].pack('L!').length, res.length) end assert_nothing_raised do res = @img.export_pixels_to_str(0, 0, 10, 10, 'I', Magick::FloatPixel) assert_equal(10 * 10 * 4, res.length) end assert_nothing_raised do res = @img.export_pixels_to_str(0, 0, 10, 10, 'I', Magick::DoublePixel) assert_equal(10 * 10 * 8, res.length) end assert_nothing_raised { @img.export_pixels_to_str(0, 0, 10, 10, 'I', Magick::QuantumPixel) } # too many arguments assert_raise(ArgumentError) { @img.export_pixels_to_str(0, 0, 10, 10, 'I', Magick::QuantumPixel, 1) } # last arg s/b StorageType assert_raise(TypeError) { @img.export_pixels_to_str(0, 0, 10, 10, 'I', 2) } end def test_extent assert_nothing_raised { @img.extent(40, 40) } res = @img.extent(40, 40) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) assert_equal(40, res.columns) assert_equal(40, res.rows) assert_nothing_raised { @img.extent(40, 40, 5) } assert_nothing_raised { @img.extent(40, 40, 5, 5) } assert_raises(ArgumentError) { @img.extent(-40) } assert_raises(ArgumentError) { @img.extent(-40, 40) } assert_raises(ArgumentError) { @img.extent(40, -40) } assert_raises(ArgumentError) { @img.extent(40, 40, 5, 5, 0) } assert_raises(ArgumentError) { @img.extent(0, 0, 5, 5) } assert_raises(TypeError) { @img.extent('x', 40) } assert_raises(TypeError) { @img.extent(40, 'x') } assert_raises(TypeError) { @img.extent(40, 40, 'x') } assert_raises(TypeError) { @img.extent(40, 40, 5, 'x') } end def test_find_similar_region girl = Magick::Image.read(IMAGES_DIR + '/Flower_Hat.jpg').first region = girl.crop(10, 10, 50, 50) assert_nothing_raised do x, y = girl.find_similar_region(region) assert_not_nil(x) assert_not_nil(y) assert_equal(10, x) assert_equal(10, y) end assert_nothing_raised do x, y = girl.find_similar_region(region, 0) assert_equal(10, x) assert_equal(10, y) end assert_nothing_raised do x, y = girl.find_similar_region(region, 0, 0) assert_equal(10, x) assert_equal(10, y) end list = Magick::ImageList.new list << region assert_nothing_raised do x, y = girl.find_similar_region(list, 0, 0) assert_equal(10, x) assert_equal(10, y) end x = girl.find_similar_region(@img) assert_nil(x) assert_raise(ArgumentError) { girl.find_similar_region(region, 10, 10, 10) } assert_raise(TypeError) { girl.find_similar_region(region, 10, 'x') } assert_raise(TypeError) { girl.find_similar_region(region, 'x') } region.destroy! assert_raise(Magick::DestroyedImageError) { girl.find_similar_region(region) } end def test_flip assert_nothing_raised do res = @img.flip assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end end def test_flip! assert_nothing_raised do res = @img.flip! assert_same(@img, res) end end def test_flop assert_nothing_raised do res = @img.flop assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end end def test_flop! assert_nothing_raised do res = @img.flop! assert_same(@img, res) end end def test_frame assert_nothing_raised do res = @img.frame assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.frame(50) } assert_nothing_raised { @img.frame(50, 50) } assert_nothing_raised { @img.frame(50, 50, 25) } assert_nothing_raised { @img.frame(50, 50, 25, 25) } assert_nothing_raised { @img.frame(50, 50, 25, 25, 6) } assert_nothing_raised { @img.frame(50, 50, 25, 25, 6, 6) } assert_nothing_raised { @img.frame(50, 50, 25, 25, 6, 6, 'red') } red = Magick::Pixel.new(Magick::QuantumRange) assert_nothing_raised { @img.frame(50, 50, 25, 25, 6, 6, red) } assert_raise(TypeError) { @img.frame(50, 50, 25, 25, 6, 6, 2) } assert_raise(ArgumentError) { @img.frame(50, 50, 25, 25, 6, 6, red, 2) } end def test_fx assert_nothing_raised { @img.fx('1/2') } assert_nothing_raised { @img.fx('1/2', Magick::BlueChannel) } assert_nothing_raised { @img.fx('1/2', Magick::BlueChannel, Magick::RedChannel) } assert_raise(ArgumentError) { @img.fx } assert_raise(ArgumentError) { @img.fx(Magick::BlueChannel) } assert_raise(TypeError) { @img.fx(1) } assert_raise(TypeError) { @img.fx('1/2', 1) } end def test_gamma_channel assert_nothing_raised do res = @img.gamma_channel(0.8) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_raise(ArgumentError) { @img.gamma_channel } assert_nothing_raised { @img.gamma_channel(0.8, Magick::RedChannel) } assert_nothing_raised { @img.gamma_channel(0.8, Magick::RedChannel, Magick::BlueChannel) } assert_raise(TypeError) { @img.gamma_channel(0.8, Magick::RedChannel, 2) } end def test_function_channel img = Magick::Image.read('gradient:') { self.size = '20x600' } img = img.first img.rotate!(90) assert_nothing_raised { img.function_channel Magick::PolynomialFunction, 0.33 } assert_nothing_raised { img.function_channel Magick::PolynomialFunction, 4, -1.5 } assert_nothing_raised { img.function_channel Magick::PolynomialFunction, 4, -4, 1 } assert_nothing_raised { img.function_channel Magick::PolynomialFunction, -25, 53, -36, 8.3, 0.2 } assert_nothing_raised { img.function_channel Magick::SinusoidFunction, 1 } assert_nothing_raised { img.function_channel Magick::SinusoidFunction, 1, 90 } assert_nothing_raised { img.function_channel Magick::SinusoidFunction, 5, 90, 0.25, 0.75 } assert_nothing_raised { img.function_channel Magick::ArcsinFunction, 1 } assert_nothing_raised { img.function_channel Magick::ArcsinFunction, 0.5 } assert_nothing_raised { img.function_channel Magick::ArcsinFunction, 0.4, 0.7 } assert_nothing_raised { img.function_channel Magick::ArcsinFunction, 0.5, 0.5, 0.5, 0.5 } assert_nothing_raised { img.function_channel Magick::ArctanFunction, 1 } assert_nothing_raised { img.function_channel Magick::ArctanFunction, 10, 0.7 } assert_nothing_raised { img.function_channel Magick::ArctanFunction, 5, 0.7, 1.2 } assert_nothing_raised { img.function_channel Magick::ArctanFunction, 15, 0.7, 0.5, 0.75 } # with channel args assert_nothing_raised { img.function_channel Magick::PolynomialFunction, 0.33, Magick::RedChannel } assert_nothing_raised { img.function_channel Magick::SinusoidFunction, 1, Magick::RedChannel, Magick::BlueChannel } # invalid args assert_raise(ArgumentError) { img.function_channel } assert_raise(TypeError) { img.function_channel 1 } assert_raise(ArgumentError) { img.function_channel Magick::PolynomialFunction } assert_raise(TypeError) { img.function_channel Magick::PolynomialFunction, [] } assert_raise(ArgumentError) { img.function_channel Magick::SinusoidFunction, 5, 90, 0.25, 0.75, 0.1 } assert_raise(ArgumentError) { img.function_channel Magick::ArcsinFunction, 0.5, 0.5, 0.5, 0.5, 0.1 } assert_raise(ArgumentError) { img.function_channel Magick::ArctanFunction, 15, 0.7, 0.5, 0.75, 0.1 } end def test_gramma_correct assert_raise(ArgumentError) { @img.gamma_correct } assert_nothing_raised do res = @img.gamma_correct(0.8) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.gamma_correct(0.8, 0.9) } assert_nothing_raised { @img.gamma_correct(0.8, 0.9, 1.0) } assert_nothing_raised { @img.gamma_correct(0.8, 0.9, 1.0, 1.1) } # too many arguments assert_raise(ArgumentError) { @img.gamma_correct(0.8, 0.9, 1.0, 1.1, 2) } end def test_gaussian_blur assert_nothing_raised do res = @img.gaussian_blur assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.gaussian_blur(0.0) } assert_nothing_raised { @img.gaussian_blur(0.0, 3.0) } # sigma must be != 0.0 assert_raise(ArgumentError) { @img.gaussian_blur(1.0, 0.0) } assert_raise(ArgumentError) { @img.gaussian_blur(1.0, 3.0, 2) } end def test_gaussian_blur_channel assert_nothing_raised do res = @img.gaussian_blur_channel assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.gaussian_blur_channel(0.0) } assert_nothing_raised { @img.gaussian_blur_channel(0.0, 3.0) } assert_nothing_raised { @img.gaussian_blur_channel(0.0, 3.0, Magick::RedChannel) } assert_nothing_raised { @img.gaussian_blur_channel(0.0, 3.0, Magick::RedChannel, Magick::BlueChannel) } assert_raise(TypeError) { @img.gaussian_blur_channel(0.0, 3.0, Magick::RedChannel, 2) } end def test_get_exif_by_entry assert_nothing_raised do res = @img.get_exif_by_entry assert_instance_of(Array, res) end end def test_get_exif_by_number assert_nothing_raised do res = @img.get_exif_by_number assert_instance_of(Hash, res) end end def test_get_pixels assert_nothing_raised do pixels = @img.get_pixels(0, 0, @img.columns, 1) assert_instance_of(Array, pixels) assert_equal(@img.columns, pixels.length) assert_block do pixels.all? { |p| p.is_a? Magick::Pixel } end end assert_raise(RangeError) { @img.get_pixels(0, 0, -1, 1) } assert_raise(RangeError) { @img.get_pixels(0, 0, @img.columns, -1) } assert_raise(RangeError) { @img.get_pixels(0, 0, @img.columns + 1, 1) } assert_raise(RangeError) { @img.get_pixels(0, 0, @img.columns, @img.rows + 1) } end def test_gray? gray = Magick::Image.new(20, 20) { self.background_color = 'gray50' } assert(gray.gray?) red = Magick::Image.new(20, 20) { self.background_color = 'red' } assert(!red.gray?) end def test_histogram? assert_nothing_raised { @img.histogram? } assert(@img.histogram?) end def test_implode assert_nothing_raised do res = @img.implode(0.5) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_raise(ArgumentError) { @img.implode(0.5, 0.5) } end def test_import_pixels pixels = @img.export_pixels(0, 0, @img.columns, 1, 'RGB') assert_nothing_raised do res = @img.import_pixels(0, 0, @img.columns, 1, 'RGB', pixels) assert_same(@img, res) end assert_raise(ArgumentError) { @img.import_pixels } assert_raise(ArgumentError) { @img.import_pixels(0) } assert_raise(ArgumentError) { @img.import_pixels(0, 0) } assert_raise(ArgumentError) { @img.import_pixels(0, 0, @img.columns) } assert_raise(ArgumentError) { @img.import_pixels(0, 0, @img.columns, 1) } assert_raise(ArgumentError) { @img.import_pixels(0, 0, @img.columns, 1, 'RGB') } assert_raise(TypeError) { @img.import_pixels('x', 0, @img.columns, 1, 'RGB', pixels) } assert_raise(TypeError) { @img.import_pixels(0, 'x', @img.columns, 1, 'RGB', pixels) } assert_raise(TypeError) { @img.import_pixels(0, 0, 'x', 1, 'RGB', pixels) } assert_raise(TypeError) { @img.import_pixels(0, 0, @img.columns, 'x', 'RGB', pixels) } assert_raise(TypeError) { @img.import_pixels(0, 0, @img.columns, 1, [2], pixels) } assert_raise(ArgumentError) { @img.import_pixels(-1, 0, @img.columns, 1, 'RGB', pixels) } assert_raise(ArgumentError) { @img.import_pixels(0, -1, @img.columns, 1, 'RGB', pixels) } assert_raise(ArgumentError) { @img.import_pixels(0, 0, -1, 1, 'RGB', pixels) } assert_raise(ArgumentError) { @img.import_pixels(0, 0, @img.columns, -1, 'RGB', pixels) } # pixel array is too small assert_raise(ArgumentError) { @img.import_pixels(0, 0, @img.columns, 2, 'RGB', pixels) } # pixel array doesn't contain a multiple of the map length pixels.shift assert_raise(ArgumentError) { @img.import_pixels(0, 0, @img.columns, 1, 'RGB', pixels) } end def test_level assert_nothing_raised do res = @img.level assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.level(0.0) } assert_nothing_raised { @img.level(0.0, 1.0) } assert_nothing_raised { @img.level(0.0, 1.0, Magick::QuantumRange) } assert_raise(ArgumentError) { @img.level(0.0, 1.0, Magick::QuantumRange, 2) } assert_raise(ArgumentError) { @img.level('x') } assert_raise(ArgumentError) { @img.level(0.0, 'x') } assert_raise(ArgumentError) { @img.level(0.0, 1.0, 'x') } end # Ensure that #level properly swaps old-style arg list def test_level2 img1 = @img.level(10, 2, 200) img2 = @img.level(10, 200, 2) assert_equal(img2, img1) # Ensure that level2 uses new arg order img1 = @img.level2(10, 200, 2) assert_equal(img2, img1) assert_nothing_raised { @img.level2 } assert_nothing_raised { @img.level2(10) } assert_nothing_raised { @img.level2(10, 10) } assert_nothing_raised { @img.level2(10, 10, 10) } assert_raise(ArgumentError) { @img.level2(10, 10, 10, 10) } end def test_level_channel assert_raise(ArgumentError) { @img.level_channel } assert_nothing_raised do res = @img.level_channel(Magick::RedChannel) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.level_channel(Magick::RedChannel, 0.0) } assert_nothing_raised { @img.level_channel(Magick::RedChannel, 0.0, 1.0) } assert_nothing_raised { @img.level_channel(Magick::RedChannel, 0.0, 1.0, Magick::QuantumRange) } assert_raise(ArgumentError) { @img.level_channel(Magick::RedChannel, 0.0, 1.0, Magick::QuantumRange, 2) } assert_raise(TypeError) { @img.level_channel(2) } assert_raise(TypeError) { @img.level_channel(Magick::RedChannel, 'x') } assert_raise(TypeError) { @img.level_channel(Magick::RedChannel, 0.0, 'x') } assert_raise(TypeError) { @img.level_channel(Magick::RedChannel, 0.0, 1.0, 'x') } end def test_level_colors res = nil assert_nothing_raised do res = @img.level_colors end assert_instance_of(Magick::Image, res) assert_not_same(@img, res) assert_nothing_raised { @img.level_colors('black') } assert_nothing_raised { @img.level_colors('black', Magick::Pixel.new(0, 0, 0)) } assert_nothing_raised { @img.level_colors(Magick::Pixel.new(0, 0, 0), Magick::Pixel.new(Magick::QuantumRange, Magick::QuantumRange, Magick::QuantumRange)) } assert_nothing_raised { @img.level_colors('black', 'white') } assert_nothing_raised { @img.level_colors('black', 'white', false) } assert_raises(TypeError) { @img.level_colors('black', 'white', false, 1) } assert_raises(TypeError) { @img.level_colors([]) } assert_raises(ArgumentError) { @img.level_colors('xxx') } end def test_levelize_channel res = nil assert_nothing_raised do res = @img.levelize_channel(0, Magick::QuantumRange) end assert_instance_of(Magick::Image, res) assert_not_same(@img, res) assert_nothing_raised { @img.levelize_channel(0) } assert_nothing_raised { @img.levelize_channel(0, Magick::QuantumRange) } assert_nothing_raised { @img.levelize_channel(0, Magick::QuantumRange, 0.5) } assert_nothing_raised { @img.levelize_channel(0, Magick::QuantumRange, 0.5, Magick::RedChannel) } assert_nothing_raised { @img.levelize_channel(0, Magick::QuantumRange, 0.5, Magick::RedChannel, Magick::BlueChannel) } assert_raise(TypeError) { @img.levelize_channel(0, Magick::QuantumRange, 0.5, 1, Magick::RedChannel) } assert_raise(ArgumentError) { @img.levelize_channel } end # def test_liquid_rescale # begin # @img.liquid_rescale(15,15) # rescue NotImplementedError # puts "liquid_rescale not implemented." # return # end # # res = nil # assert_nothing_raised do # res = @img.liquid_rescale(15, 15) # end # assert_equal(15, res.columns) # assert_equal(15, res.rows) # assert_nothing_raised { @img.liquid_rescale(15, 15, 0, 0) } # assert_raise(ArgumentError) { @img.liquid_rescale(15) } # assert_raise(ArgumentError) { @img.liquid_rescale(15, 15, 0, 0, 0) } # assert_raise(TypeError) { @img.liquid_rescale([], 15) } # assert_raise(TypeError) { @img.liquid_rescale(15, []) } # assert_raise(TypeError) { @img.liquid_rescale(15, 15, []) } # assert_raise(TypeError) { @img.liquid_rescale(15, 15, 0, []) } # end def test_magnify assert_nothing_raised do res = @img.magnify assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end res = @img.magnify! assert_same(@img, res) end def test_marshal img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first d = nil img2 = nil assert_nothing_raised { d = Marshal.dump(img) } assert_nothing_raised { img2 = Marshal.load(d) } assert_equal(img, img2) end def test_mask cimg = Magick::Image.new(10, 10) assert_nothing_raised { @img.mask(cimg) } res = nil assert_nothing_raised { res = @img.mask } assert_not_nil(res) assert_not_same(cimg, res) assert_equal(20, res.columns) assert_equal(20, res.rows) assert_raise(ArgumentError) { @img.mask(cimg, 'x') } # mask expects an Image and calls `cur_image' assert_raise(NoMethodError) { @img.mask = 2 } img = @img.copy.freeze assert_raise(FreezeError) { img.mask cimg } @img.destroy! assert_raise(Magick::DestroyedImageError) { @img.mask cimg } end def test_matte_fill_to_border assert_nothing_raised do res = @img.matte_fill_to_border(@img.columns / 2, @img.rows / 2) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.matte_fill_to_border(@img.columns, @img.rows) } assert_raise(ArgumentError) { @img.matte_fill_to_border(@img.columns + 1, @img.rows) } assert_raise(ArgumentError) { @img.matte_fill_to_border(@img.columns, @img.rows + 1) } end def test_matte_floodfill assert_nothing_raised do res = @img.matte_floodfill(@img.columns / 2, @img.rows / 2) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.matte_floodfill(@img.columns, @img.rows) } Magick::PaintMethod.values do |method| next if [Magick::FillToBorderMethod, Magick::FloodfillMethod].include?(method) assert_raise(ArgumentError) { @img.matte_flood_fill('blue', Magick::TransparentAlpha, @img.columns, @img.rows, method) } end assert_raise(ArgumentError) { @img.matte_floodfill(@img.columns + 1, @img.rows) } assert_raise(ArgumentError) { @img.matte_floodfill(@img.columns, @img.rows + 1) } assert_nothing_raised { @img.matte_flood_fill('blue', @img.columns, @img.rows, Magick::FloodfillMethod, alpha: Magick::TransparentAlpha) } assert_raise(ArgumentError) { @img.matte_flood_fill('blue', @img.columns, @img.rows, Magick::FloodfillMethod, wrong: Magick::TransparentAlpha) } end def test_matte_replace assert_nothing_raised do res = @img.matte_replace(@img.columns / 2, @img.rows / 2) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end end def test_matte_reset! assert_nothing_raised do res = @img.matte_reset! assert_same(@img, res) end end def test_median_filter assert_nothing_raised do res = @img.median_filter assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.median_filter(0.5) } assert_raise(ArgumentError) { @img.median_filter(0.5, 'x') } assert_raise(TypeError) { @img.median_filter('x') } end def test_minify assert_nothing_raised do res = @img.minify assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end res = @img.minify! assert_same(@img, res) end def test_modulate assert_nothing_raised do res = @img.modulate assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.modulate(0.5) } assert_nothing_raised { @img.modulate(0.5, 0.5) } assert_nothing_raised { @img.modulate(0.5, 0.5, 0.5) } assert_raise(ArgumentError) { @img.modulate(0.0, 0.5, 0.5) } assert_raise(ArgumentError) { @img.modulate(0.5, 0.5, 0.5, 0.5) } assert_raise(TypeError) { @img.modulate('x', 0.5, 0.5) } assert_raise(TypeError) { @img.modulate(0.5, 'x', 0.5) } assert_raise(TypeError) { @img.modulate(0.5, 0.5, 'x') } end def test_monochrome? # assert_block { @img.monochrome? } @img.pixel_color(0, 0, 'red') assert_block { !@img.monochrome? } end def test_motion_blur assert_nothing_raised do res = @img.motion_blur(1.0, 7.0, 180) assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_raise(ArgumentError) { @img.motion_blur(1.0, 0.0, 180) } assert_nothing_raised { @img.motion_blur(1.0, -1.0, 180) } end def test_negate assert_nothing_raised do res = @img.negate assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.negate(true) } assert_raise(ArgumentError) { @img.negate(true, 2) } end def test_negate_channel assert_nothing_raised do res = @img.negate_channel assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.negate_channel(true) } assert_nothing_raised { @img.negate_channel(true, Magick::RedChannel) } assert_nothing_raised { @img.negate_channel(true, Magick::RedChannel, Magick::BlueChannel) } assert_raise(TypeError) { @img.negate_channel(true, Magick::RedChannel, 2) } end def test_normalize assert_nothing_raised do res = @img.normalize assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end end def test_normalize_channel assert_nothing_raised do res = @img.normalize_channel assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.normalize_channel(Magick::RedChannel) } assert_nothing_raised { @img.normalize_channel(Magick::RedChannel, Magick::BlueChannel) } assert_raise(TypeError) { @img.normalize_channel(Magick::RedChannel, 2) } end def test_oil_paint assert_nothing_raised do res = @img.oil_paint assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.oil_paint(2.0) } assert_raise(ArgumentError) { @img.oil_paint(2.0, 1.0) } end def test_opaque assert_nothing_raised do res = @img.opaque('white', 'red') assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end red = Magick::Pixel.new(Magick::QuantumRange) blue = Magick::Pixel.new(0, 0, Magick::QuantumRange) assert_nothing_raised { @img.opaque(red, blue) } assert_raise(TypeError) { @img.opaque(red, 2) } assert_raise(TypeError) { @img.opaque(2, blue) } end def test_opaque_channel res = nil assert_nothing_raised { res = @img.opaque_channel('white', 'red') } assert_not_nil(res) assert_instance_of(Magick::Image, res) assert_not_same(res, @img) assert_nothing_raised { @img.opaque_channel('red', 'blue', true) } assert_nothing_raised { @img.opaque_channel('red', 'blue', true, 50) } assert_nothing_raised { @img.opaque_channel('red', 'blue', true, 50, Magick::RedChannel) } assert_nothing_raised { @img.opaque_channel('red', 'blue', true, 50, Magick::RedChannel, Magick::GreenChannel) } assert_nothing_raised do @img.opaque_channel('red', 'blue', true, 50, Magick::RedChannel, Magick::GreenChannel, Magick::BlueChannel) end assert_raise(TypeError) { @img.opaque_channel('red', 'blue', true, 50, 50) } assert_raise(TypeError) { @img.opaque_channel('red', 'blue', true, []) } assert_raise(ArgumentError) { @img.opaque_channel('red') } assert_raise(ArgumentError) { @img.opaque_channel('red', 'blue', true, -0.1) } assert_raise(TypeError) { @img.opaque_channel('red', []) } end def test_opaque? assert_nothing_raised do assert_block { @img.opaque? } end @img.alpha(Magick::TransparentAlphaChannel) assert_block { !@img.opaque? } end def test_ordered_dither assert_nothing_raised do res = @img.ordered_dither assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.ordered_dither('3x3') } assert_nothing_raised { @img.ordered_dither(2) } assert_nothing_raised { @img.ordered_dither(3) } assert_nothing_raised { @img.ordered_dither(4) } assert_raise(ArgumentError) { @img.ordered_dither(5) } assert_raise(ArgumentError) { @img.ordered_dither(2, 1) } end def test_paint_transparent res = nil assert_nothing_raised { res = @img.paint_transparent('red') } assert_not_nil(res) assert_instance_of(Magick::Image, res) assert_not_same(res, @img) assert_raise(ArgumentError) { @img.paint_transparent('red', Magick::TransparentAlpha) } assert_nothing_raised { @img.paint_transparent('red', alpha: Magick::TransparentAlpha) } assert_raise(ArgumentError) { @img.paint_transparent('red', wrong: Magick::TransparentAlpha) } assert_raise(ArgumentError) { @img.paint_transparent('red', Magick::TransparentAlpha, true) } assert_nothing_raised { @img.paint_transparent('red', true, alpha: Magick::TransparentAlpha) } assert_raise(ArgumentError) { @img.paint_transparent('red', true, wrong: Magick::TransparentAlpha) } assert_raise(ArgumentError) { @img.paint_transparent('red', true, alpha: Magick::TransparentAlpha, extra: Magick::TransparentAlpha) } assert_raise(ArgumentError) { @img.paint_transparent('red', Magick::TransparentAlpha, true, 50) } assert_nothing_raised { @img.paint_transparent('red', true, 50, alpha: Magick::TransparentAlpha) } assert_raise(ArgumentError) { @img.paint_transparent('red', true, 50, wrong: Magick::TransparentAlpha) } # Too many arguments assert_raise(ArgumentError) { @img.paint_transparent('red', true, 50, 50, 50) } # Not enough assert_raise(ArgumentError) { @img.paint_transparent } assert_raise(TypeError) { @img.paint_transparent('red', true, [], alpha: Magick::TransparentAlpha) } assert_raise(TypeError) { @img.paint_transparent(50) } end def test_palette? img = Magick::Image.read(IMAGES_DIR + '/Flower_Hat.jpg').first assert_nothing_raised do assert_block { !img.palette? } end img = Magick::Image.read(IMAGES_DIR + '/Button_0.gif').first assert_block { img.palette? } end def test_pixel_color assert_nothing_raised do res = @img.pixel_color(0, 0) assert_instance_of(Magick::Pixel, res) end res = @img.pixel_color(0, 0) assert_equal(@img.background_color, res.to_color) res = @img.pixel_color(0, 0, 'red') assert_equal('white', res.to_color) res = @img.pixel_color(0, 0) assert_equal('red', res.to_color) blue = Magick::Pixel.new(0, 0, Magick::QuantumRange) assert_nothing_raised { @img.pixel_color(0, 0, blue) } # If args are out-of-bounds return the background color img = Magick::Image.new(10, 10) { self.background_color = 'blue' } assert_equal('blue', img.pixel_color(50, 50).to_color) assert_nothing_raised do @img.class_type = Magick::PseudoClass res = @img.pixel_color(0, 0, 'red') assert_equal('blue', res.to_color) end end def test_polaroid assert_nothing_raised { @img.polaroid } assert_nothing_raised { @img.polaroid(5) } assert_instance_of(Magick::Image, @img.polaroid) assert_raises(TypeError) { @img.polaroid('x') } assert_raises(ArgumentError) { @img.polaroid(5, 'x') } end def test_posterize assert_nothing_raised do res = @img.posterize assert_instance_of(Magick::Image, res) assert_not_same(@img, res) end assert_nothing_raised { @img.posterize(5) } assert_nothing_raised { @img.posterize(5, true) } assert_raise(ArgumentError) { @img.posterize(5, true, 'x') } end end if $PROGRAM_NAME == __FILE__ IMAGES_DIR = '../doc/ex/images' FILES = Dir[IMAGES_DIR + '/Button_*.gif'] Test::Unit::UI::Console::TestRunner.run(Image2UT) end