axon 0.0.2 → 0.1.0

data/test/test_jpeg_reader.rb

@@ -1,108 +1,110 @@
 require 'helper'
+require 'reader_tests'
 
 module Axon
-  class TestJPEGReader < AxonTestCase
-    include ReaderTests
-
-    def setup
-      super
-      @readerclass = JPEGReader
-      @data = @image.to_jpeg.data
-      @io_in = StringIO.new @data
-      @reader = @readerclass.new(@io_in)
-    end
+  module JPEG
+    class TestJPEGReader < AxonTestCase
+      include ReaderTests
 
-    def test_in_color_model
-      assert_equal :YCbCr, @reader.in_color_model
-    end
-    
-    def test_set_in_color_model
-      @reader.in_color_model = :RGB
-      assert_equal :RGB, @reader.in_color_model
-      
-      assert_raises(RuntimeError){ @reader.in_color_model = "foobar" }
-    end
-    
-    def test_set_out_color_model
-      @reader.color_model = :YCbCr
-      assert_equal :YCbCr, @reader.color_model
-      
-      assert_raises(RuntimeError){ @reader.color_model = "foobar" }
-    end
-    
-    def test_scale_num
-      assert @reader.scale_num > 0
-    end
-    
-    def test_set_scale_num
-      @reader.scale_num = 5
-      assert_equal 5, @reader.scale_num
-    end
-    
-    def test_scale_denom
-      assert @reader.scale_denom > 0
-    end
-    
-    def test_set_scale_denom
-      @reader.scale_denom = 8
-      
-      assert_equal 8, @reader.scale_denom
-    end
-    
-    def test_scale_denom_affects_image_size
-      pre_width = @reader.width
-      pre_height = @reader.height
-      
-      @reader.scale_denom = 2
-      
-      assert @reader.width < pre_width
-      assert @reader.height < pre_height
-    end
+      def setup
+        super
+        io = StringIO.new
+        JPEG.write(@image, io)
+        @data = io.string
+        @readerclass = Reader
+        @reader = Reader.new(StringIO.new(@data))
+      end
 
-    def test_scale_denom_affects_written_image
-      pre_width = @reader.width
-      pre_height = @reader.height
+      def test_in_color_model
+        assert_equal :YCbCr, @reader.in_color_model
+      end
 
-      writer = JPEGWriter.new(@reader)
-      @reader.scale_denom = 2
+      def test_set_in_color_model
+        @reader.in_color_model = :RGB
+        assert_equal :RGB, @reader.in_color_model
 
-      new_velvet_io = StringIO.new(writer.data)
+        assert_raises(RuntimeError){ @reader.in_color_model = "foobar" }
+      end
 
-      new_velvet_reader = JPEGReader.new(new_velvet_io)
+      def test_set_out_color_model
+        @reader.color_model = :YCbCr
+        assert_equal :YCbCr, @reader.color_model
 
-      assert new_velvet_reader.width < pre_width
-      assert new_velvet_reader.height < pre_height
-    end
-    
-    def test_dct_method
-      assert_equal JPEGReader::DEFAULT_DCT, @reader.dct_method
-    end
-    
-    def test_set_dct_method
-      @reader.dct_method = :IFAST
-      
-      assert_equal :IFAST, @reader.dct_method
-    end
-    
-    def test_markers_read_by_default
-      refute_empty @reader[:APP0]
-    end
-    
-    def test_empty_marker_prevents_reads
-      @io_in.rewind
-      r = JPEGReader.new @io_in, []
-      assert_empty r[:APP0]
-    end
-    
-    def test_marker_read
-      assert_match(/^JFIF/, @reader[:APP0].first)
-    end
-    
-    def test_no_configuration_after_initiated
-      @reader.each do |sl|
+        assert_raises(RuntimeError){ @reader.color_model = "foobar" }
+      end
+
+      def test_scale_num
+        assert @reader.scale_num > 0
+      end
+
+      def test_set_scale_num
+        @reader.scale_num = 5
+        assert_equal 5, @reader.scale_num
+      end
+
+      unless LIB_TURBO
+        def test_scale_denom
+          assert @reader.scale_denom > 0
+        end
+
+        def test_set_scale_denom
+          @reader.scale_denom = 8
+          assert_equal 8, @reader.scale_denom
+        end
+
+        def test_scale_denom_affects_image_size
+          pre_width = @reader.width
+          pre_height = @reader.height
+
+          @reader.scale_denom = 2
+
+          assert @reader.width < pre_width
+          assert @reader.height < pre_height
+        end
+
+        def test_scale_denom_affects_written_image
+          pre_width = @reader.width
+          pre_height = @reader.height
+
+          @reader.scale_denom = 2
+
+          io_out = StringIO.new
+          JPEG.write(@reader, io_out)
+          io_out.rewind
+
+          new_velvet_reader = Reader.new(io_out)
+
+          assert new_velvet_reader.width < pre_width
+          assert new_velvet_reader.height < pre_height
+        end
+      end
+
+      def test_dct_method
+        assert_equal Reader::DEFAULT_DCT, @reader.dct_method
+      end
+
+      def test_set_dct_method
+        @reader.dct_method = :IFAST
+        assert_equal :IFAST, @reader.dct_method
+      end
+
+      def test_markers_read_by_default
+        refute_empty @reader[:APP0]
+      end
+
+      def test_empty_marker_prevents_reads
+        r = Reader.new StringIO.new(@data), []
+        assert_empty r[:APP0]
+      end
+
+      def test_marker_content
+        assert_match(/^JFIF/, @reader[:APP0].first)
+      end
+
+      def test_no_configuration_after_initiated
+        @reader.gets
         assert_raises(RuntimeError) { @reader.dct_method = :IFAST }
         assert_raises(RuntimeError) { @reader.scale_denom = 4 }
-        break
       end
     end
   end

data/test/test_jpeg_writer.rb

@@ -1,4 +1,5 @@
 require 'helper'
+require 'writer_tests'
 
 module Axon
   class TestJPEGWriter < AxonTestCase
@@ -6,21 +7,107 @@ module Axon
 
     def setup
       super
-      @writerclass = JPEGWriter
-      @writer = @image.to_jpeg
+      @mod = JPEG
     end
 
     def test_output_has_jpeg_header
-      string = @writer.data
-
-      assert_equal "\xFF\xD8\xFF\xE0", string[0..3]
-      assert_equal "JFIF\x00", string[6..10]
+      JPEG.write(@image, @io_out)
+      assert_equal "\xFF\xD8\xFF\xE0", @io_out.string[0..3]
+      assert_equal "JFIF\x00", @io_out.string[6..10]
     end
 
-    def test_bad_bufsize
+    def test_invalid_bufsize
       assert_raises RuntimeError do
-        @writer.write(@io_out, 0)
+        JPEG.write(@image, @io_out, :bufsize => 0)
+      end
+
+      assert_raises RuntimeError do
+        JPEG.write(@image, @io_out, :bufsize => -5)
+      end
+    end
+
+    def test_symbol_bufsize
+      assert_raises TypeError do
+        JPEG.write(@image, @io_out, :bufsize => :foo)
+      end
+    end
+
+    def test_quality_filesize
+      file_sizes = {}
+      [-10, 0, 1, 50, 100, 130].each do |q|
+        im = Solid.new(100, 200)
+        io = StringIO.new
+        JPEG.write(im, io, :quality => q)
+        file_sizes[q] = io.size
       end
+
+      assert file_sizes[-10] > 1
+
+      # libjpeg treats values under 1 as 1
+      assert_equal file_sizes[-10], file_sizes[0]
+      assert_equal file_sizes[0], file_sizes[1]
+
+      assert file_sizes[50] > file_sizes[1]
+      assert file_sizes[100] > file_sizes[50]
+
+      # libjpeg treats values over 100 as 100
+      assert_equal file_sizes[130], file_sizes[100]
+    end
+
+    def test_symbol_quality
+      assert_raises TypeError do
+        JPEG.write(@image, @io_out, :quality => :foo)
+      end
+    end
+
+    def test_exif_roundtrip
+      random_data = ""
+      (100).times do
+        random_data << [rand].pack('d') # 800 bytes random data
+      end
+
+      io_out = StringIO.new
+      JPEG.write(@image, io_out, :exif => random_data)
+      io_out.rewind
+
+      image_with_exif = JPEG::Reader.new(io_out)
+      assert_equal random_data, image_with_exif.exif
+    end
+
+    def test_exif_with_icc_roundtrip
+      random_icc_data = ""
+      (2**16).times do                  # a little larger than one jpeg segment
+        random_icc_data << [rand].pack('d') # 8 bytes random data
+      end
+
+      random_exif_data = ""
+      (100).times do
+        random_exif_data << [rand].pack('d') # 800 bytes random data
+      end
+
+      io_out = StringIO.new
+      JPEG.write(@image, io_out, :icc_profile => random_icc_data,
+                 :exif => random_exif_data)
+      io_out.rewind
+
+      image_with_exif_and_icc = JPEG::Reader.new(io_out)
+
+      assert_equal random_exif_data, image_with_exif_and_icc.exif
+      assert_equal random_icc_data, image_with_exif_and_icc.icc_profile
+    end
+
+    def test_large_icc_roundtrip
+      random_data = ""
+      (2**16).times do                  # a little larger than one jpeg segment
+        random_data << [rand].pack('d') # 8 bytes random data
+      end
+
+      io_out = StringIO.new
+      JPEG.write(@image, io_out, :icc_profile => random_data)
+      io_out.rewind
+
+      image_with_icc = JPEG::Reader.new(io_out)
+      assert_equal random_data, image_with_icc.icc_profile
     end
   end
 end

data/test/test_nearest_neighbor_scaler.rb

@@ -1,13 +1,37 @@
 require 'helper'
+require 'scaler_tests'
 
 module Axon
   class TestNearestNeighborScaler < AxonTestCase
-    def test_resize_ratio
-      @image.scale_nearest_neighbor(0.9).write_jpeg(@io_out)
+    include ScalerTests
+
+    def setup
+      super
+      @scalerclass = NearestNeighborScaler
+      @scalertestclass = TestNearestNeighborScaler
     end
 
-    def test_resize_dimensions
-      @image.scale_nearest_neighbor(100, 200).write_jpeg(@io_out)
+    class TestNearestNeighborScaler
+      def initialize(original, width, height)
+        @original = original
+        @scale_x_inv = original.width / width.to_f
+        @scale_y_inv = original.height / height.to_f
+        @data = []
+        @original.height.times do
+          sl = @original.gets
+          @data << sl + sl[-@original.components, @original.components]
+        end
+        @data << @data.last
+      end
+
+      def calc(x, y)
+        smp_x = (x * @scale_x_inv).floor
+        smp_y = (y * @scale_y_inv).floor
+        cmp = @original.components
+        @data[smp_y][smp_x * cmp, cmp].chars.map do |c|
+          c.respond_to?(:ord) ? c.ord : c[0]
+        end
+      end
     end
   end
 end

data/test/test_png_reader.rb

@@ -1,15 +1,19 @@
 require 'helper'
+require 'reader_tests'
 
 module Axon
-  class TestPNGReader < AxonTestCase
-    include ReaderTests
+  module PNG
+    class TestPNGReader < AxonTestCase
+      include ReaderTests
 
-    def setup
-      super
-      @readerclass = PNGReader
-      @data = @image.to_png.data
-      @io_in = StringIO.new @data
-      @reader = PNGReader.new(@io_in)
+      def setup
+        super
+        io = StringIO.new
+        PNG.write(@image, io)
+        @data = io.string
+        @readerclass = Reader
+        @reader = Reader.new(StringIO.new(@data))
+      end
     end
   end
 end

data/test/test_png_writer.rb

@@ -1,13 +1,15 @@
 require 'helper'
+require 'writer_tests'
 
 module Axon
-  class TestPNGWriter < AxonTestCase
-    include WriterTests
+  module PNG
+    class TestPNGWriter < AxonTestCase
+      include WriterTests
 
-    def setup
-      super
-      @writerclass = PNGWriter
-      @writer = @image.to_png
+      def setup
+        super
+        @mod = PNG
+      end
     end
   end
 end

data/test/writer_tests.rb

@@ -1,178 +1,196 @@
 module Axon
   module WriterTests
     def test_writes_something
-      @writer.write(@io_out)
+      @mod.write(@image, @io_out)
       refute @io_out.string.empty?
     end
 
-    class ZeroHeightImage < Solid
-      def height; 0; end
+    def test_returns_bytes_written
+      ret = @mod.write(@image, @io_out)
+      assert_equal @io_out.size, ret
     end
 
-    class NegativeHeightImage < Solid
-      def height; -1; end
+    def test_invalid_numeric_height
+      [0, -100, 0.0001].each do |h|
+        assert_raises RuntimeError do
+          @mod.write(CustomHeightImage.new(h), @io_out)
+        end
+      end
     end
 
-    class NilHeightImage < Solid
-      def height; nil; end
+    def test_invalid_height_type
+      [nil, :foo].each do |h|
+        assert_raises TypeError, "should throw a TypeError when given a #{h.class} for height." do
+          @mod.write(CustomHeightImage.new(h), @io_out)
+        end
+      end
     end
 
-    def test_bad_dimension
-      i = ZeroHeightImage.new 10, 15, @velvet
-      writer = @writerclass.new(i)
-
-      assert_raises RuntimeError do
-        writer.write(@io_out)
+    def test_height_raises_exception
+      im = CustomHeightImage.new(Proc.new{ raise CustomError })
+      assert_raises CustomError do
+        @mod.write(im, @io_out)
       end
-      
-      i = NegativeHeightImage.new 10, 15, @velvet
-      writer = @writerclass.new(i)
+    end
 
-      assert_raises RuntimeError do
-        writer.write(@io_out)
+    def test_invalid_numeric_width
+      [0, -100, 0.0001].each do |w|
+        assert_raises RuntimeError do
+          @mod.write(CustomWidthImage.new(w), @io_out)
+        end
       end
+    end
 
-      i = NilHeightImage.new 10, 15, @velvet
-      writer = @writerclass.new(i)
-
-      assert_raises TypeError do
-        writer.write(@io_out)
+    def test_invalid_width_type
+      [nil, :foo].each do |w|
+        assert_raises TypeError, "should throw a TypeError when given a #{w.class} for width." do
+          @mod.write(CustomWidthImage.new(w), @io_out)
+        end
       end
     end
 
-    class NilColorModelImage < Solid
-      def color_model; nil; end
+    def test_width_raises_exception
+      im = CustomWidthImage.new(Proc.new{ raise CustomError })
+      assert_raises CustomError do
+        @mod.write(im, @io_out)
+      end
     end
 
-    def test_bad_color_model
-      i = NilColorModelImage.new 10, 15, @velvet
-      writer = @writerclass.new(i)
-
-      assert_raises RuntimeError do
-        writer.write(@io_out)
+    def test_nil_image_color_model
+      assert_raises TypeError do
+        @mod.write(CustomColorModelImage.new(nil), @io_out)
       end
     end
 
-    class TooManyComponentsImage < Solid
-      def components; 15; end
+    def test_invalid_color_model
+      assert_raises RuntimeError do
+        @mod.write(CustomColorModelImage.new(:foo), @io_out)
+      end
     end
 
-    class ZeroComponentsImage < Solid
-      def components; 0; end
+    def test_color_model_raises_exception
+      im = CustomColorModelImage.new(Proc.new{ raise CustomError })
+      assert_raises CustomError do
+        @mod.write(im, @io_out)
+      end
     end
 
-    class NilComponentsImage < Solid
-      def components; nil; end
+    def test_invalid_image_components
+      [0, -100, 0.0001, 15].each do |w|
+        assert_raises RuntimeError do
+          @mod.write(CustomComponentsImage.new(w), @io_out)
+        end
+      end
     end
 
-    def test_bad_components
-      i = NilComponentsImage.new 10, 15, @velvet
-      writer = @writerclass.new(i)
-
-      assert_raises TypeError do
-        writer.write(@io_out)
+    def test_invalid_components_type
+      [nil, :foo].each do |w|
+        assert_raises TypeError do
+          @mod.write(CustomComponentsImage.new(w), @io_out)
+        end
       end
+    end
 
-      i = TooManyComponentsImage.new 10, 15, @velvet
-      writer = @writerclass.new(i)
-
-      assert_raises RuntimeError do
-        writer.write(@io_out)
+    def test_invalid_components_type
+      [nil, :foo].each do |w|
+        assert_raises TypeError, "should throw a TypeError when given a #{w.class} for components." do
+          @mod.write(CustomComponentsImage.new(w), @io_out)
+        end
       end
+    end
 
-      i = ZeroComponentsImage.new 10, 15, @velvet
-      writer = @writerclass.new(i)
-
-      assert_raises RuntimeError do
-        writer.write(@io_out)
+    def test_components_raises_exception
+      im = CustomComponentsImage.new(Proc.new{ raise CustomError })
+      assert_raises CustomError do
+        @mod.write(im, @io_out)
       end
     end
-    
-    class RaisingIO
-      def write(data)
-        raise 'hell'
+
+    def test_invalid_lineno_type
+      [-1, nil, :foo].each do |l|
+        # we don't know if the writer will care but test anyways to detect
+        # interpreter crashes and mem leaks.
+        @mod.write(CustomLinenoImage.new(l), @io_out)
       end
     end
-    
-    def test_io_raises_exception
-      io = RaisingIO.new
-      
-      assert_raises RuntimeError do
-        @writer.write(io)
+
+    def test_odd_gets_type
+      [nil, :foo, 1234].each do |l|
+        assert_raises RuntimeError do
+          @mod.write(CustomGetsImage.new(l), @io_out)
+        end
       end
     end
-    
-    class NilImage < Solid
-      def each
-        10.times{ yield nil }
+
+    def test_gets_raises_exception_immediately
+      im = CustomGetsImage.new(Proc.new{ raise CustomError })
+      assert_raises CustomError do
+        @mod.write(im, @io_out)
       end
     end
     
-    def test_image_scanlines_yield_nil
-      image = NilImage.new(10, 15, @velvet)
-      writer = @writerclass.new(image)
-      
-      assert_raises RuntimeError do
-        writer.write(@io_out)
+    def test_gets_raises_exception_later
+      proc = Proc.new{ |im| im.lineno > 3 ? raise(CustomError) : im.gets }
+      i = CustomGetsImage.new(proc)
+      assert_raises CustomError do
+        @mod.write(i, @io_out)
       end
+      assert_equal 4, i.lineno
     end
 
-    class TooManyScanLinesImage < Solid
-      def each
-        super
-        yield(@color * width)
+    def test_gets_return_is_too_short_immediately
+      proc = Proc.new{ |im| im.gets[2, -1] }
+      assert_raises RuntimeError do
+        @mod.write(CustomGetsImage.new(proc), @io_out)
       end
     end
 
-    def test_image_yields_too_many_scanlines
-      image = TooManyScanLinesImage.new 10, 15, @velvet
-      writer = @writerclass.new(image)
-      writer.write(@io_out)
-    end
-
-    class TooFewScanLinesImage < Solid
-      def each
-        yield(@color * width)
+    def test_gets_return_is_too_short_later
+      proc = Proc.new{ |im| im.lineno > 3 ? im.gets[2, -1] : im.gets }
+      i = CustomGetsImage.new(proc)
+      assert_raises RuntimeError do
+        @mod.write(i, @io_out)
       end
+      assert_equal 5, i.lineno
     end
     
-    def test_image_yields_too_few_scanlines
-      image = TooFewScanLinesImage.new 10, 15, @velvet
-      writer = @writerclass.new(image)
-
+    def test_gets_return_is_too_long_immediately
+      proc = Proc.new{ |im| im.gets * 2 }
       assert_raises RuntimeError do
-        writer.write(@io_out)
+        @mod.write(CustomGetsImage.new(proc), @io_out)
       end
     end
 
-    class RaisingImage < Solid
-      def each
-        raise 'chickens'
+    def test_gets_return_is_too_long_later
+      proc = Proc.new{ |im| im.lineno > 3 ? im.gets * 2 : im.gets }
+      i = CustomGetsImage.new(proc)
+      assert_raises RuntimeError do
+        @mod.write(i, @io_out)
       end
+      assert_equal 5, i.lineno
     end
-    
-    def test_image_scanlines_raises_exception
-      image = RaisingImage.new(10, 15, @velvet)
-      writer = @writerclass.new(image)
 
-      assert_raises RuntimeError do
-        writer.write(@io_out)
+    def test_io_raises_exception_immediately
+      io = CustomIO.new(Proc.new{ raise CustomError })
+      assert_raises CustomError do
+        @mod.write(@image, io)
       end
     end
-    
-    class BigWidthImage < Solid
-      def each
-        sl = @color * width * 10
-        height.times { yield sl }
+
+    def test_io_returns_invalid_type
+      [nil, :foo, "bar"].each do |r|
+        im = Solid.new(200, 100)
+        assert_raises TypeError, "should get a TypeError when IO#write returns a #{r.class}." do
+          @mod.write(im, CustomIO.new(r))
+        end
       end
     end
-    
-    def test_image_scanlines_returns_too_much
-      image = BigWidthImage.new(10, 15, @velvet)
-      writer = @writerclass.new(image)
 
-      assert_raises RuntimeError do
-        writer.write(@io_out)
+    def test_io_returns_invalid_length
+      [0, -1, -100, 2000, 1].each do |r|
+        assert_raises RuntimeError do
+          @mod.write(@image, CustomIO.new(r))
+        end
       end
     end
   end