rmagick 3.0.0 → 3.1.0

data/test/ImageList2.rb

@@ -133,6 +133,9 @@ class ImageList2UT < Test::Unit::TestCase
     map = Magick::ImageList.new('netscape:')
     img = @ilist.map(map, true)
     assert_instance_of(Magick::ImageList, img)
+
+    assert_raise(ArgumentError) { @ilist.map }
+    assert_raise(ArgumentError) { @ilist.map(map, true, 42) }
   end
 
   def test_marshal
@@ -156,6 +159,7 @@ class ImageList2UT < Test::Unit::TestCase
         self.border_color = Magick::Pixel.new(0, 0, 0)
         self.border_width = 2
         self.compose = Magick::OverCompositeOp
+        self.filename = 'test.png'
         self.fill = 'green'
         self.font = 'Arial'
         self.frame = '20x20+4+4'
@@ -164,11 +168,15 @@ class ImageList2UT < Test::Unit::TestCase
         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)
@@ -193,6 +201,10 @@ class ImageList2UT < Test::Unit::TestCase
       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)
@@ -201,8 +213,8 @@ class ImageList2UT < Test::Unit::TestCase
       montage = ilist.montage { self.font = 2 }
       assert_equal(@ilist, ilist)
     end
-    assert_raise(Magick::ImageMagickError) do
-      montage = ilist.montage { self.frame = 'z' }
+    assert_raise(TypeError) do
+      montage = ilist.montage { self.gravity = 2 }
       assert_equal(@ilist, ilist)
     end
     assert_raise(TypeError) do
@@ -217,6 +229,10 @@ class ImageList2UT < Test::Unit::TestCase
       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
@@ -241,6 +257,12 @@ class ImageList2UT < Test::Unit::TestCase
     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)
@@ -257,27 +279,34 @@ class ImageList2UT < Test::Unit::TestCase
 
   def test_optimize_layers
     layer_methods = [
-      Magick::CompareAnyLayer,
-      Magick::CompareClearLayer,
-      Magick::CompareOverlayLayer,
-      Magick::OptimizeLayer,
-      Magick::OptimizePlusLayer,
       Magick::CoalesceLayer,
       Magick::DisposeLayer,
       Magick::OptimizeTransLayer,
       Magick::RemoveDupsLayer,
-      Magick::RemoveZeroLayer
+      Magick::RemoveZeroLayer,
+      Magick::OptimizeImageLayer,
+      Magick::OptimizeLayer,
+      Magick::OptimizePlusLayer,
+      Magick::CompareAnyLayer,
+      Magick::CompareClearLayer,
+      Magick::CompareOverlayLayer,
+      Magick::MosaicLayer,
+      Magick::FlattenLayer,
+      Magick::MergeLayer
     ]
     @ilist.read(IMAGES_DIR + '/Button_0.gif', IMAGES_DIR + '/Button_1.gif')
     layer_methods.each do |method|
       assert_nothing_raised do
         res = @ilist.optimize_layers(method)
         assert_instance_of(Magick::ImageList, res)
-        assert_equal(2, res.length)
+        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
@@ -309,6 +338,9 @@ class ImageList2UT < Test::Unit::TestCase
     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

data/test/Image_attributes.rb

@@ -35,10 +35,20 @@ class Image_Attributes_UT < Test::Unit::TestCase
     assert_equal('white', @img.background_color)
     assert_nothing_raised { @img.background_color = '#dfdfdf' }
     # assert_equal("rgb(223,223,223)", @img.background_color)
-    assert_equal('#DFDFDFDFDFDF', @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)
-    assert_equal('#FFFF7FFF7FFF', @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
 
@@ -92,12 +102,22 @@ class Image_Attributes_UT < Test::Unit::TestCase
   def test_border_color
     assert_nothing_raised { @img.border_color }
     # assert_equal("rgb(223,223,223)", @img.border_color)
-    assert_equal('#DFDFDFDFDFDF', @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)
-    assert_equal('#FFFF7FFF7FFF', @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
 
@@ -153,7 +173,7 @@ class Image_Attributes_UT < Test::Unit::TestCase
     assert_equal(0, @img.colors)
     img = @img.copy
     img.class_type = Magick::PseudoClass
-    assert_equal(40, img.colors)
+    assert_kind_of(Integer, img.colors)
     assert_raise(NoMethodError) { img.colors = 2 }
   end
 
@@ -236,6 +256,11 @@ class Image_Attributes_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.compose = Magick::SubtractCompositeOp }
     assert_nothing_raised { @img.compose = Magick::ThresholdCompositeOp }
     assert_nothing_raised { @img.compose = Magick::XorCompositeOp }
+    assert_nothing_raised { @img.compose = Magick::MathematicsCompositeOp }
+    assert_nothing_raised { @img.compose = Magick::DivideSrcCompositeOp }
+    assert_nothing_raised { @img.compose = Magick::MinusSrcCompositeOp }
+    assert_nothing_raised { @img.compose = Magick::DarkenIntensityCompositeOp }
+    assert_nothing_raised { @img.compose = Magick::LightenIntensityCompositeOp }
     assert_raise(TypeError) { @img.compose = 2 }
   end
 
@@ -263,6 +288,9 @@ class Image_Attributes_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.compression = Magick::RLECompression }
     assert_nothing_raised { @img.compression = Magick::ZipCompression }
     assert_nothing_raised { @img.compression = Magick::ZipSCompression }
+    assert_nothing_raised { @img.compression = Magick::LZMACompression }
+    assert_nothing_raised { @img.compression = Magick::JBIG1Compression }
+    assert_nothing_raised { @img.compression = Magick::JBIG2Compression }
     assert_raise(TypeError) { @img.compression = 2 }
   end
 
@@ -357,6 +385,15 @@ class Image_Attributes_UT < Test::Unit::TestCase
     assert_nothing_raised { @img.filter = Magick::LanczosFilter }
     assert_nothing_raised { @img.filter = Magick::BesselFilter }
     assert_nothing_raised { @img.filter = Magick::SincFilter }
+    assert_nothing_raised { @img.filter = Magick::JincFilter }
+    assert_nothing_raised { @img.filter = Magick::SincFastFilter }
+    assert_nothing_raised { @img.filter = Magick::LanczosSharpFilter }
+    assert_nothing_raised { @img.filter = Magick::Lanczos2Filter }
+    assert_nothing_raised { @img.filter = Magick::Lanczos2SharpFilter }
+    assert_nothing_raised { @img.filter = Magick::RobidouxFilter }
+    assert_nothing_raised { @img.filter = Magick::RobidouxSharpFilter }
+    assert_nothing_raised { @img.filter = Magick::CosineFilter }
+    assert_nothing_raised { @img.filter = Magick::SplineFilter }
     assert_raise(TypeError) { @img.filter = 2 }
   end
 
@@ -409,7 +446,6 @@ class Image_Attributes_UT < Test::Unit::TestCase
   def test_image_type
     assert_nothing_raised { @img.image_type }
     assert_instance_of(Magick::ImageType, @img.image_type)
-    assert_equal(Magick::GrayscaleMatteType, @img.image_type)
   end
 
   def test_interlace_type
@@ -427,6 +463,7 @@ class Image_Attributes_UT < Test::Unit::TestCase
     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
 
@@ -479,7 +516,7 @@ class Image_Attributes_UT < Test::Unit::TestCase
 
   def test_number_colors
     assert_nothing_raised { @hat.number_colors }
-    assert_equal(27_942, @hat.number_colors)
+    assert_kind_of(Integer, @hat.number_colors)
     assert_raise(NoMethodError) { @hat.number_colors = 2 }
   end
 
@@ -587,7 +624,7 @@ class Image_Attributes_UT < Test::Unit::TestCase
 
   def test_total_colors
     assert_nothing_raised { @hat.total_colors }
-    assert_equal(27_942, @hat.total_colors)
+    assert_kind_of(Integer, @hat.total_colors)
     assert_raise(NoMethodError) { @img.total_colors = 2 }
   end
 

data/test/Info.rb

@@ -30,6 +30,7 @@ class InfoUT < Test::Unit::TestCase
 
     assert_nothing_raised { @info.undefine('tiff', 'bits-per-sample') }
     assert_nil(@info['tiff', 'bits-per-sample'])
+    assert_raise(ArgumentError) { @info.undefine('tiff', 'a' * 10_000) }
   end
 
   def test_antialias
@@ -38,18 +39,31 @@ class InfoUT < Test::Unit::TestCase
     assert !@info.antialias
   end
 
+  def test_aref_aset
+    assert_nothing_raised { @info['tiff'] = 'xxx' }
+    assert_equal('xxx', @info['tiff'])
+    assert_nothing_raised { @info['tiff', 'bits-per-sample'] = 'abc' }
+    assert_equal('abc', @info['tiff', 'bits-per-sample'])
+    assert_raise(ArgumentError) { @info['tiff', 'a', 'b'] }
+    assert_raise(ArgumentError) { @info['tiff', 'a' * 10_000] }
+    assert_raise(ArgumentError) { @info['tiff', 'a' * 10_000] = 'abc' }
+    assert_raise(ArgumentError) { @info['tiff', 'a', 'b'] = 'abc' }
+  end
+
   def test_attenuate
     assert_nothing_raised { @info.attenuate = 10 }
     assert_equal(10, @info.attenuate)
     assert_nothing_raised { @info.attenuate = 5.25 }
     assert_equal(5.25, @info.attenuate)
     assert_nothing_raised { @info.attenuate = nil }
-    assert_equal(nil, @info.attenuate)
+    assert_nil(@info.attenuate)
   end
 
   def test_authenticate
     assert_nothing_raised { @info.authenticate = 'string' }
     assert_equal('string', @info.authenticate)
+    assert_nothing_raised { @info.authenticate = nil }
+    assert_nil(@info.authenticate)
   end
 
   def test_background_color
@@ -70,11 +84,12 @@ class InfoUT < Test::Unit::TestCase
     assert_equal('red', img.border_color)
   end
 
-  def caption
+  def test_caption
     assert_nothing_raised { @info.caption = 'string' }
     assert_equal('string', @info.caption)
-    img = Magick::Image.new(20, 20) { self.caption = 'string' }
-    assert_equal('string', img.caption)
+    assert_nothing_raised { @info.caption = nil }
+    assert_nil(@info.caption)
+    assert_nothing_raised { Magick::Image.new(20, 20) { self.caption = 'string' } }
   end
 
   def test_channel
@@ -106,6 +121,8 @@ class InfoUT < Test::Unit::TestCase
   def test_define
     assert_nothing_raised { @info.define('tiff', 'bits-per-sample', 2) }
     assert_nothing_raised { @info.undefine('tiff', 'bits-per-sample') }
+    assert_raise(ArgumentError) { @info.define('tiff', 'bits-per-sample', 2, 2) }
+    assert_raise(ArgumentError) { @info.define('tiff', 'a' * 10_000) }
   end
 
   def test_density
@@ -113,11 +130,17 @@ class InfoUT < Test::Unit::TestCase
     assert_equal('72x72', @info.density)
     assert_nothing_raised { @info.density = Magick::Geometry.new(72, 72) }
     assert_equal('72x72', @info.density)
+    assert_nothing_raised { @info.density = nil }
+    assert_nil(@info.density)
+    assert_raise(ArgumentError) { @info.density = 'aaa' }
   end
 
   def test_delay
     assert_nothing_raised { @info.delay = 60 }
     assert_equal(60, @info.delay)
+    assert_nothing_raised { @info.delay = nil }
+    assert_nil(@info.delay)
+    assert_raise(TypeError) { @info.delay = '60' }
   end
 
   def test_depth
@@ -133,6 +156,7 @@ class InfoUT < Test::Unit::TestCase
       assert_nothing_raised { @info.dispose = v }
       assert_equal(v, @info.dispose)
     end
+    assert_nothing_raised { @info.dispose = nil }
   end
 
   def test_dither
@@ -142,16 +166,27 @@ class InfoUT < Test::Unit::TestCase
     assert_equal(false, @info.dither)
   end
 
+  def test_endian
+    assert_nothing_raised { @info.endian = Magick::LSBEndian }
+    assert_equal(Magick::LSBEndian, @info.endian)
+    assert_nothing_raised { @info.endian = nil }
+  end
+
   def test_extract
     assert_nothing_raised { @info.extract = '100x100' }
     assert_equal('100x100', @info.extract)
     assert_nothing_raised { @info.extract = Magick::Geometry.new(100, 100) }
     assert_equal('100x100', @info.extract)
+    assert_nothing_raised { @info.extract = nil }
+    assert_nil(@info.extract)
+    assert_raise(ArgumentError) { @info.extract = 'aaa' }
   end
 
   def test_filename
     assert_nothing_raised { @info.filename = 'string' }
     assert_equal('string', @info.filename)
+    assert_nothing_raised { @info.filename = nil }
+    assert_equal('', @info.filename)
   end
 
   def test_fill
@@ -170,11 +205,14 @@ class InfoUT < Test::Unit::TestCase
   def test_font
     assert_nothing_raised { @info.font = 'Arial' }
     assert_equal('Arial', @info.font)
+    assert_nothing_raised { @info.font = nil }
+    assert_nil(@info.font)
   end
 
   def test_format
     assert_nothing_raised { @info.format = 'GIF' }
     assert_equal('GIF', @info.format)
+    assert_raise(TypeError) { @info.format = nil }
   end
 
   def test_fuzz
@@ -182,6 +220,8 @@ class InfoUT < Test::Unit::TestCase
     assert_equal(50, @info.fuzz)
     assert_nothing_raised { @info.fuzz = '50%' }
     assert_equal(Magick::QuantumRange * 0.5, @info.fuzz)
+    assert_raise(TypeError) { @info.fuzz = nil }
+    assert_raise(ArgumentError) { @info.fuzz = 'xxx' }
   end
 
   def test_gravity
@@ -189,6 +229,15 @@ class InfoUT < Test::Unit::TestCase
       assert_nothing_raised { @info.gravity = v }
       assert_equal(v, @info.gravity)
     end
+    assert_nothing_raised { @info.gravity = nil }
+  end
+
+  def test_group
+    assert_kind_of(Integer, @info.group)
+    assert_nothing_raised { @info.group = 50 }
+    assert_equal(50, @info.group)
+    assert_raise(TypeError) { @info.group = nil }
+    assert_raise(TypeError) { @info.group = 'xxx' }
   end
 
   def test_image_type
@@ -196,6 +245,7 @@ class InfoUT < Test::Unit::TestCase
       assert_nothing_raised { @info.image_type = v }
       assert_equal(v, @info.image_type)
     end
+    assert_raise(TypeError) { @info.image_type = nil }
   end
 
   def test_interlace
@@ -203,11 +253,14 @@ class InfoUT < Test::Unit::TestCase
       assert_nothing_raised { @info.interlace = v }
       assert_equal(v, @info.interlace)
     end
+    assert_raise(TypeError) { @info.interlace = nil }
   end
 
   def test_label
     assert_nothing_raised { @info.label = 'string' }
     assert_equal('string', @info.label)
+    assert_nothing_raised { @info.label = nil }
+    assert_nil(@info.label)
   end
 
   def test_matte_color
@@ -217,24 +270,37 @@ class InfoUT < Test::Unit::TestCase
     assert_equal('red', @info.matte_color)
     img = Magick::Image.new(20, 20) { self.matte_color = 'red' }
     assert_equal('red', img.matte_color)
+    assert_raise(TypeError) { @info.matte_color = nil }
   end
 
   def test_monitor
     assert_nothing_raised { @info.monitor = -> {} }
     monitor = proc do |mth, q, s|
       assert_equal('resize!', mth)
-      assert_instance_of(Fixnum, q)
-      assert_instance_of(Fixnum, s)
+      assert_kind_of(Integer, q)
+      assert_kind_of(Integer, s)
+      GC.start
       true
     end
     img = Magick::Image.new(2000, 2000) { self.monitor = monitor }
     img.resize!(20, 20)
     img.monitor = nil
+
+    assert_nothing_raised { @info.monitor = nil }
   end
 
   def test_monochrome
     assert_nothing_raised { @info.monochrome = true }
     assert @info.monochrome
+    assert_nothing_raised { @info.monochrome = nil }
+  end
+
+  def test_number_scenes
+    assert_kind_of(Integer, @info.number_scenes)
+    assert_nothing_raised { @info.number_scenes = 50 }
+    assert_equal(50, @info.number_scenes)
+    assert_raise(TypeError) { @info.number_scenes = nil }
+    assert_raise(TypeError) { @info.number_scenes = 'xxx' }
   end
 
   def test_orientation
@@ -242,6 +308,7 @@ class InfoUT < Test::Unit::TestCase
       assert_nothing_raised { @info.orientation = v }
       assert_equal(v, @info.orientation)
     end
+    assert_raise(TypeError) { @info.orientation = nil }
   end
 
   def test_origin
@@ -249,11 +316,16 @@ class InfoUT < Test::Unit::TestCase
     assert_equal('+10+10', @info.origin)
     assert_nothing_raised { @info.origin = Magick::Geometry.new(nil, nil, 10, 10) }
     assert_equal('+10+10', @info.origin)
+    assert_nothing_raised { @info.origin = nil }
+    assert_nil(@info.origin)
+    assert_raise(ArgumentError) { @info.origin = 'aaa' }
   end
 
   def test_page
     assert_nothing_raised { @info.page = '612x792>' }
     assert_equal('612x792>', @info.page)
+    assert_nothing_raised { @info.page = nil }
+    assert_nil(@info.page)
   end
 
   def test_pointsize
@@ -269,11 +341,21 @@ class InfoUT < Test::Unit::TestCase
   def test_sampling_factor
     assert_nothing_raised { @info.sampling_factor = '2x1' }
     assert_equal('2x1', @info.sampling_factor)
+    assert_nothing_raised { @info.sampling_factor = nil }
+    assert_nil(@info.sampling_factor)
+  end
+
+  def test_scene
+    assert_nothing_raised { @info.scene = 123 }
+    assert_equal(123, @info.scene)
+    assert_raise(TypeError) { @info.scene = 'xxx' }
   end
 
   def test_server_name
     assert_nothing_raised { @info.server_name = 'foo' }
     assert_equal('foo', @info.server_name)
+    assert_nothing_raised { @info.server_name = nil }
+    assert_nil(@info.server_name)
   end
 
   def test_size
@@ -281,6 +363,9 @@ class InfoUT < Test::Unit::TestCase
     assert_equal('200x100', @info.size)
     assert_nothing_raised { @info.size = Magick::Geometry.new(100, 200) }
     assert_equal('100x200', @info.size)
+    assert_nothing_raised { @info.size = nil }
+    assert_nil(@info.size)
+    assert_raise(ArgumentError) { @info.size = 'aaa' }
   end
 
   def test_stroke
@@ -303,11 +388,13 @@ class InfoUT < Test::Unit::TestCase
     assert_equal(5.25, @info.stroke_width)
     assert_nothing_raised { @info.stroke_width = nil }
     assert_equal(nil, @info.stroke_width)
+    assert_raise(TypeError) { @info.stroke_width = 'xxx' }
   end
 
   def test_texture
     img = Magick::Image.read('granite:') { self.size = '20x20' }
     assert_nothing_raised { @info.texture = img.first }
+    assert_nothing_raised { @info.texture = nil }
   end
 
   def test_tile_offset
@@ -315,6 +402,13 @@ class InfoUT < Test::Unit::TestCase
     assert_equal('200x100', @info.tile_offset)
     assert_nothing_raised { @info.tile_offset = Magick::Geometry.new(100, 200) }
     assert_equal('100x200', @info.tile_offset)
+    assert_raise(ArgumentError) { @info.tile_offset = nil }
+  end
+
+  def test_transparent_color
+    assert_nothing_raised { @info.transparent_color = 'white' }
+    assert_equal('white', @info.transparent_color)
+    assert_raise(TypeError) { @info.transparent_color = nil }
   end
 
   def test_undercolor
@@ -340,5 +434,7 @@ class InfoUT < Test::Unit::TestCase
   def test_view
     assert_nothing_raised { @info.view = 'string' }
     assert_equal('string', @info.view)
+    assert_nothing_raised { @info.view = nil }
+    assert_nil(@info.view)
   end
 end