free-image 0.5.0

data/test/test_free_image.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class FreeImageTest < Test::Unit::TestCase
+  def test_copyright
+    assert_equal("This program uses FreeImage, a free, open source image library supporting all common bitmap formats. See http://freeimage.sourceforge.net for details",
+                 FreeImage.copyright)
+  end
+  
+  def test_version
+    assert_equal("3.15.1", FreeImage.version)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+
+# To make testing/debugging easier, test within this source tree versus an installed gem
+dir = File.dirname(__FILE__)
+ROOT_DIR = File.expand_path(File.join(dir, '..'))
+LIB_DIR = File.expand_path(File.join(ROOT_DIR, 'lib'))
+
+$LOAD_PATH << LIB_DIR
+
+require 'rubygems'
+require 'free-image'
+require 'tempfile'
+
+def image_path(image)
+  File.join(ROOT_DIR, 'test', 'images', image)
+end
+
+def image_data(image)
+  path = File.join(ROOT_DIR, 'test', 'images', image)
+  result = nil
+  File.open(path, 'rb') do |file|
+    result = file.read
+  end
+  result
+end
+
+def sample_image
+  path = File.join(ROOT_DIR, 'test', 'images', 'sample.png')
+  FreeImage::Bitmap.open(path)
+end
+
+def lena_image
+  path = File.join(ROOT_DIR, 'test', 'images', 'lena.png')
+  FreeImage::Bitmap.open(path)
+end

data/test/test_information.rb

@@ -0,0 +1,118 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class InformationTest < Test::Unit::TestCase
+  def test_background_color
+    background_color = sample_image.background_color
+    assert_kind_of(FreeImage::RGBQuad, background_color)
+    assert_equal(112, background_color[:red])
+    assert_equal(176, background_color[:green])
+    assert_equal(240, background_color[:blue])
+  end
+
+  def test_background_color_set
+    image = sample_image
+    rgb = FreeImage::RGBQuad.create(7, 8, 9)
+
+    image.background_color = rgb
+    background_color = image.background_color
+    assert_equal(rgb, background_color)
+  end
+
+  def test_bits_per_pixel
+    assert_equal(8, sample_image.bits_per_pixel)
+  end
+
+  def test_blue_mask
+    assert_equal(0, sample_image.blue_mask)
+    assert_equal(FreeImage::RGBQuad::BLUE_MASK, lena_image.blue_mask)
+  end
+  
+  def test_color_type
+    assert_equal(:palette, sample_image.color_type)
+  end
+
+  def test_dib_size
+    assert_equal(52664, sample_image.dib_size)
+  end
+
+  def test_dots_per_meter_x
+    assert_equal(2835, sample_image.dots_per_meter_x)
+  end
+
+  def test_dots_per_meter_x_set
+    image = sample_image
+    image.dots_per_meter_x = 3000
+    assert_equal(3000, image.dots_per_meter_x)
+  end
+
+  def test_dots_per_meter_y
+    assert_equal(2835, sample_image.dots_per_meter_y)
+  end
+
+  def test_dots_per_meter_y_set
+    image = sample_image
+    image.dots_per_meter_y = 4000
+    assert_equal(4000, image.dots_per_meter_y)
+  end
+
+  def test_green_mask
+    assert_equal(0, sample_image.green_mask)
+    assert_equal(FreeImage::RGBQuad::GREEN_MASK, lena_image.green_mask)
+  end
+
+  def test_has_background_color
+    assert(sample_image.has_background_color)
+  end
+
+  def test_has_pixels
+    assert(sample_image.has_pixels)
+  end
+
+  def test_height
+    assert_equal(215, sample_image.height)
+  end
+
+  def test_image_type
+    assert_equal(:bitmap, sample_image.image_type)
+  end
+
+  def test_line
+    assert_equal(240, sample_image.line)
+  end
+
+  def test_pitch
+    assert_equal(240, sample_image.pitch)
+  end
+
+  def test_red_mask
+    assert_equal(0, sample_image.red_mask)
+    assert_equal(FreeImage::RGBQuad::RED_MASK, lena_image.red_mask)
+  end
+
+  def test_transparent
+    assert(sample_image.transparent)
+  end
+
+  def test_transparent_set
+    image = sample_image
+    image.transparent = false
+    assert(!image.transparent)
+  end
+
+  def test_transparent_index
+    assert_equal(6, sample_image.transparent_index)
+  end
+
+  def test_transparent_index_set
+    image = sample_image
+    image.transparent_index = 4
+    assert_equal(4, image.transparent_index)
+  end
+
+  def test_width
+    assert_equal(240, sample_image.width)
+  end
+end

data/test/test_io.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class IoTest < Test::Unit::TestCase
+  def io(image = 'sample.png')
+    path = image_path(image)
+    file = File.open(path)
+    FreeImage::IO.new(file)
+  end
+
+  def test_format
+    assert_equal(:png, io.format)
+  end
+
+  def test_format_unknown
+    assert_equal(:unknown, io('not_an_image.txt').format)
+  end
+
+  def test_load
+    bitmap = io.open
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+  end
+
+  def test_load_unknown
+    error = assert_raise(FreeImage::Error) do
+      io('not_an_image.txt').open
+    end
+    assert_equal("Cannot load :unknown image format",
+                 error.message)
+  end
+
+  def test_load_wrong_format
+    error = assert_raise(FreeImage::Error) do
+      io.open(:jpeg)
+    end
+    assert_equal("Not a JPEG file: starts with 0x89 0x50", error.to_s)
+  end
+
+  def test_save
+    tmp_file = Tempfile.new('test_free_image')
+    dst = FreeImage::IO.new(tmp_file)
+
+    bitmap = io.open
+    result = bitmap.save(dst, :png)
+    assert(result)
+    assert(File.exists?(tmp_file))
+  ensure
+    tmp_file.close
+    tmp_file.unlink
+  end
+end

data/test/test_memory.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class MemoryTest < Test::Unit::TestCase
+  def memory(image = 'sample.png')
+    data = image_data(image)
+    FreeImage::Memory.new(data)
+  end
+
+  def test_wrap
+    assert_not_nil(memory)
+  end
+
+  def test_format
+    assert_equal(:png, memory.format)
+  end
+
+  def test_format_unknown
+    assert_equal(:unknown, memory('not_an_image.txt').format)
+  end
+
+  def test_load
+    bitmap = memory.open
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+  end
+
+  def test_load_unknown
+    error = assert_raise(FreeImage::Error) do
+      memory('not_an_image.txt').open
+    end
+    assert_equal("Cannot load :unknown image format",
+                 error.message)
+  end
+
+  def test_load_wrong_format
+    error = assert_raise(FreeImage::Error) do
+      memory.open(:jpeg, 0)
+    end
+    assert_equal("Not a JPEG file: starts with 0x89 0x50", error.to_s)
+  end
+
+  def test_bytes
+    bitmap1 = FreeImage::Bitmap.open(image_path('sample.png'))
+
+    memory = FreeImage::Memory.new(image_data('sample.png'))
+    bitmap2 = memory.open
+
+    assert_equal(bitmap1.bits, bitmap2.bits)
+  end
+
+  def test_save
+    dst = FreeImage::Memory.new
+
+    bitmap = memory.open
+    result = bitmap.save(dst, :png)
+
+    assert(result)
+    assert_not_nil(dst.memory.bytes)
+    if defined?(Encoding)
+      assert_equal(dst.memory.bytes.encoding, Encoding::BINARY)
+    end
+  end
+end

data/test/test_modify.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class ModifyTest < Test::Unit::TestCase
+  def test_copy
+    bitmap1 = FreeImage::Bitmap.open(image_path('sample.png'))
+    bitmap2 = bitmap1.copy(0, 0, 50, 60)
+
+    assert_kind_of(FreeImage::Bitmap, bitmap2)
+    assert_equal(50, bitmap2.width)
+    assert_equal(60, bitmap2.height)
+  end
+
+  def test_expand_canvas
+    bitmap = FreeImage::Bitmap.open(image_path('sample.png'))
+    color = FreeImage::RGBQuad.create(15, 30, 45)
+
+    result = bitmap.enlarge_canvas(1, 1, 1, 1, color)
+    assert_kind_of(FreeImage::Bitmap, result)
+  end
+
+  def test_fill_background
+    bitmap = FreeImage::Bitmap.open(image_path('sample.png'))
+    color = FreeImage::RGBQuad.create(15, 30, 45)
+
+    result = bitmap.fill_background!(color)
+    assert(result)
+  end
+
+  def test_paste
+    bitmap1 = FreeImage::Bitmap.open(image_path('sample.png'))
+    bitmap2 = FreeImage::Bitmap.open(image_path('sample.png'))
+    result = bitmap1.paste!(bitmap2, 0, 0, 0.5)
+
+    assert_kind_of(TrueClass, result)
+    assert_equal(240, bitmap2.width)
+    assert_equal(215, bitmap2.height)
+  end
+
+  def test_rescale
+    bitmap1 = FreeImage::Bitmap.open(image_path('sample.png'))
+    bitmap2 = bitmap1.rescale(120, 100, :box)
+
+    assert_kind_of(FreeImage::Bitmap, bitmap2)
+    assert_equal(120, bitmap2.width)
+    assert_equal(100, bitmap2.height)
+  end
+
+  def test_thumbnail
+    bitmap1 = FreeImage::Bitmap.open(image_path('sample.png'))
+    bitmap2 = bitmap1.make_thumbnail(100)
+
+    assert_kind_of(FreeImage::Bitmap, bitmap2)
+    assert_equal(100, bitmap2.width)
+    assert_equal(90, bitmap2.height)
+  end
+end

data/test/test_palette.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class PaletteTest < Test::Unit::TestCase
+  def test_palette
+    palette = sample_image.palette
+    assert_not_nil(palette)
+    assert_kind_of(FreeImage::Palette, palette)
+  end
+
+  def test_size
+    palette = sample_image.palette
+    assert_equal(256, palette.size)
+  end
+
+  def test_index
+    palette = sample_image.palette
+    rgb = palette[27]
+
+    assert_kind_of(FreeImage::RGBQuad, rgb)
+    assert_equal(201, rgb[:red])
+    assert_equal(253, rgb[:green])
+    assert_equal(0, rgb[:blue])
+  end
+
+  def test_index_too_small
+    palette = sample_image.palette
+
+    error = assert_raise(RangeError) do
+      palette[-1]
+    end
+    assert_equal("Value is out of range 0..256. Value: -1", error.message)
+  end
+
+  def test_index_too_large
+    palette = sample_image.palette
+
+    error = assert_raise(RangeError) do
+      palette[300]
+    end
+    assert_equal("Value is out of range 0..256. Value: 300", error.message)
+  end
+end

data/test/test_pixels.rb

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class PixelTest < Test::Unit::TestCase
+  def test_bits
+    bytes = sample_image.bits
+    assert_not_nil(bytes)
+  end
+
+  def test_pixel_index
+    index = sample_image.pixel_index(0, 0)
+    assert_equal(113, index)
+
+    index = lena_image.pixel_index(0, 0)
+    assert_nil(index)
+  end
+
+  def test_set_pixel_index
+    image = sample_image
+    result = image.set_pixel_index(0, 0, 14)
+    assert(result)
+
+    index = image.pixel_index(0, 0)
+    assert_equal(14, index)
+  end
+
+  def test_set_pixel_invalid
+    image = lena_image
+    result = image.set_pixel_index(0, 0, 14)
+    assert(!result)
+  end
+
+  def test_pixel_color
+    color = lena_image.pixel_color(0, 0)
+    assert_kind_of(FreeImage::RGBQuad, color)
+
+    color = sample_image.pixel_color(0, 0)
+    assert_nil(color)
+  end
+
+  def test_set_pixel_color
+    image = lena_image
+
+    color1 = FreeImage::RGBQuad.create(0, 0, 255)
+    result = image.set_pixel_color(0, 0, color1)
+    assert(result)
+
+    color2 = image.pixel_color(0, 0)
+    assert_equal(color1, color2)
+  end
+
+  def test_set_pixel_invalid
+    # Pixel colors aren't supported on paletted images
+    image = sample_image
+
+    color1 = FreeImage::RGBQuad.create(0, 0, 255)
+    result = image.set_pixel_color(0, 0, color1)
+    assert(!result)
+  end
+end