chunky_png 1.3.2 → 1.3.3

data/spec/chunky_png/datastream_spec.rb

@@ -5,12 +5,12 @@ describe ChunkyPNG::Datastream do
   describe '.from_io'do
     it "should raise an error when loading a file with a bad signature" do
       filename = resource_file('damaged_signature.png')
-      lambda { ChunkyPNG::Datastream.from_file(filename) }.should raise_error
+      expect { ChunkyPNG::Datastream.from_file(filename) }.to raise_error
     end
 
     it "should raise an error if the CRC of a chunk is incorrect" do
       filename = resource_file('damaged_chunk.png')
-      lambda { ChunkyPNG::Datastream.from_file(filename) }.should raise_error
+      expect { ChunkyPNG::Datastream.from_file(filename) }.to raise_error
     end
   end
 
@@ -18,15 +18,15 @@ describe ChunkyPNG::Datastream do
     it "should load uncompressed tXTt chunks correctly" do
       filename = resource_file('text_chunk.png')
       ds = ChunkyPNG::Datastream.from_file(filename)
-      ds.metadata['Title'].should  == 'My amazing icon!'
-      ds.metadata['Author'].should == "Willem van Bergen"
+      expect(ds.metadata['Title']).to  eql 'My amazing icon!'
+      expect(ds.metadata['Author']).to eql "Willem van Bergen"
     end
 
     it "should load compressed zTXt chunks correctly" do
       filename = resource_file('ztxt_chunk.png')
       ds = ChunkyPNG::Datastream.from_file(filename)
-      ds.metadata['Title'].should == 'PngSuite'
-      ds.metadata['Copyright'].should == "Copyright Willem van Schaik, Singapore 1995-96"
+      expect(ds.metadata['Title']).to eql 'PngSuite'
+      expect(ds.metadata['Copyright']).to eql "Copyright Willem van Schaik, Singapore 1995-96"
     end
   end
 end

data/spec/chunky_png/dimension_spec.rb

@@ -2,30 +2,30 @@ require 'spec_helper'
 
 describe ChunkyPNG::Dimension do
   subject { ChunkyPNG::Dimension.new(2, 3) }
-  
+
   it { should respond_to(:width) }
   it { should respond_to(:height) }
-  
+
   describe '#area' do
     it "should calculate the area correctly" do
-      subject.area.should == 6
+      expect(subject.area).to eql 6
     end
   end
 end
 
 describe 'ChunkyPNG.Dimension' do
   subject { ChunkyPNG::Dimension.new(1, 2) }
-  
+
   it "should create a dimension from a 2-item array" do
-    ChunkyPNG::Dimension([1, 2]).should     == subject
-    ChunkyPNG::Dimension(['1', '2']).should == subject
+    expect(ChunkyPNG::Dimension([1, 2])).to     eql subject
+    expect(ChunkyPNG::Dimension(['1', '2'])).to eql subject
   end
-  
+
   it "should create a dimension from a hash with x and y keys" do
-    ChunkyPNG::Dimension(:width => 1, :height => 2).should       == subject
-    ChunkyPNG::Dimension('width' => '1', 'height' => '2').should == subject
+    expect(ChunkyPNG::Dimension(:width => 1, :height => 2)).to       eql subject
+    expect(ChunkyPNG::Dimension('width' => '1', 'height' => '2')).to eql subject
   end
-  
+
   it "should create a dimension from a point-like string" do
     [
       ChunkyPNG::Dimension('1,2'),
@@ -35,14 +35,14 @@ describe 'ChunkyPNG.Dimension' do
       ChunkyPNG::Dimension("[1\t2}"),
     ].all? { |point| point == subject }
   end
-  
+
   it "should create a dimension from an object that responds to width and height" do
     mock_object = Struct.new(:width, :height).new(1, 2)
-    ChunkyPNG::Dimension(mock_object).should == subject
+    expect(ChunkyPNG::Dimension(mock_object)).to eql subject
   end
-  
+
   it "should raise an exception if the input is not understood" do
-    lambda { ChunkyPNG::Dimension(Object.new) }.should raise_error(ArgumentError)
-    lambda { ChunkyPNG::Dimension(1, 2, 3) }.should raise_error(ArgumentError)
+    expect { ChunkyPNG::Dimension(Object.new) }.to raise_error(ArgumentError)
+    expect { ChunkyPNG::Dimension(1, 2, 3) }.to raise_error(ArgumentError)
   end
 end

data/spec/chunky_png/image_spec.rb

@@ -5,8 +5,8 @@ describe ChunkyPNG::Image do
 
     it "should load metadata from an existing file" do
       image = ChunkyPNG::Image.from_file(resource_file('text_chunk.png'))
-      image.metadata['Title'].should  == 'My amazing icon!'
-      image.metadata['Author'].should == 'Willem van Bergen'
+      expect(image.metadata['Title']).to  eql 'My amazing icon!'
+      expect(image.metadata['Author']).to eql 'Willem van Bergen'
     end
 
     it "should write metadata to the file correctly" do
@@ -18,8 +18,8 @@ describe ChunkyPNG::Image do
       image.save(filename)
 
       metadata = ChunkyPNG::Datastream.from_file(filename).metadata
-      metadata['Title'].should  == 'My amazing icon!'
-      metadata['Author'].should == 'Willem van Bergen'
+      expect(metadata['Title']).to  eql 'My amazing icon!'
+      expect(metadata['Author']).to eql 'Willem van Bergen'
     end
 
     it "should load empty images correctly" do

data/spec/chunky_png/point_spec.rb

@@ -1,42 +1,42 @@
 require 'spec_helper'
 
 describe ChunkyPNG::Point do
-  
+
   subject { ChunkyPNG::Point.new(1, 2) }
-  
+
   it { should respond_to(:x) }
   it { should respond_to(:y) }
-  
+
   describe '#within_bounds?' do
     it { should     be_within_bounds(2, 3)  }
     it { should_not be_within_bounds('1x3') }
     it { should_not be_within_bounds(2, 2) }
     it { should_not be_within_bounds('[1 2]') }
   end
-  
+
   describe '#<=>' do
     it "should return 0 if the coordinates are identical" do
-      (subject <=> ChunkyPNG::Point.new(1, 2)).should == 0
+      expect((subject <=> ChunkyPNG::Point.new(1, 2))).to eql 0
     end
 
     it "should return -1 if the y coordinate is smaller than the other one" do
-      (subject <=> ChunkyPNG::Point.new(1, 3)).should == -1
-      (subject <=> ChunkyPNG::Point.new(0, 3)).should == -1 # x doesn't matter
-      (subject <=> ChunkyPNG::Point.new(2, 3)).should == -1 # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(1, 3))).to eql -1
+      expect((subject <=> ChunkyPNG::Point.new(0, 3))).to eql -1 # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(2, 3))).to eql -1 # x doesn't matter
     end
 
     it "should return 1 if the y coordinate is larger than the other one" do
-      (subject <=> ChunkyPNG::Point.new(1, 0)).should == 1
-      (subject <=> ChunkyPNG::Point.new(0, 0)).should == 1 # x doesn't matter
-      (subject <=> ChunkyPNG::Point.new(2, 0)).should == 1 # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(1, 0))).to eql 1
+      expect((subject <=> ChunkyPNG::Point.new(0, 0))).to eql 1 # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(2, 0))).to eql 1 # x doesn't matter
     end
 
     it "should return -1 if the x coordinate is smaller and y is the same" do
-      (subject <=> ChunkyPNG::Point.new(2, 2)).should == -1
+      expect((subject <=> ChunkyPNG::Point.new(2, 2))).to eql -1
     end
 
     it "should return 1 if the x coordinate is larger and y is the same" do
-      (subject <=> ChunkyPNG::Point.new(0, 2)).should == 1
+      expect((subject <=> ChunkyPNG::Point.new(0, 2))).to eql 1
     end
   end
 end
@@ -44,22 +44,22 @@ end
 describe 'ChunkyPNG.Point' do
   subject { ChunkyPNG::Point.new(1, 2) }
 
-  
+
   it "should create a point from a 2-item array" do
-    ChunkyPNG::Point([1, 2]).should     == subject
-    ChunkyPNG::Point(['1', '2']).should == subject
+    expect(ChunkyPNG::Point([1, 2])).to     eql subject
+    expect(ChunkyPNG::Point(['1', '2'])).to eql subject
   end
-  
+
   it "should create a point from a hash with x and y keys" do
-    ChunkyPNG::Point(:x => 1, :y => 2).should       == subject
-    ChunkyPNG::Point('x' => '1', 'y' => '2').should == subject
+    expect(ChunkyPNG::Point(:x => 1, :y => 2)).to       eql subject
+    expect(ChunkyPNG::Point('x' => '1', 'y' => '2')).to eql subject
   end
 
   it "should create a point from a ChunkyPNG::Dimension object" do
     dimension = ChunkyPNG::Dimension.new(1, 2)
     ChunkyPNG::Point(dimension) == subject
   end
-  
+
   it "should create a point from a point-like string" do
     [
       ChunkyPNG::Point('1,2'),
@@ -69,14 +69,14 @@ describe 'ChunkyPNG.Point' do
       ChunkyPNG::Point("[1 2}"),
     ].all? { |point| point == subject }
   end
-  
+
   it "should create a point from an object that responds to x and y" do
     mock_object = Struct.new(:x, :y).new(1, 2)
-    ChunkyPNG::Point(mock_object).should == subject
+    expect(ChunkyPNG::Point(mock_object)).to eql subject
   end
-  
+
   it "should raise an exception if the input is not understood" do
-    lambda { ChunkyPNG::Point(Object.new) }.should raise_error(ArgumentError)
-    lambda { ChunkyPNG::Point(1, 2, 3) }.should raise_error(ArgumentError)
+    expect { ChunkyPNG::Point(Object.new) }.to raise_error(ArgumentError)
+    expect { ChunkyPNG::Point(1, 2, 3) }.to raise_error(ArgumentError)
   end
 end

data/spec/chunky_png/rmagick_spec.rb

@@ -4,18 +4,18 @@ begin
   require 'chunky_png/rmagick'
 
   describe ChunkyPNG::RMagick do
-  
+
     it "should import an image from RMagick correctly" do
       image = Magick::Image.read(resource_file('composited.png')).first
       canvas = ChunkyPNG::RMagick.import(image)
-      canvas.should == reference_canvas('composited')
+      expect(canvas).to eql reference_canvas('composited')
     end
-  
+
     it "should export an image to RMagick correctly" do
       canvas = reference_canvas('composited')
       image  = ChunkyPNG::RMagick.export(canvas)
       image.format = 'PNG32'
-      canvas.should == ChunkyPNG::Canvas.from_blob(image.to_blob)
+      expect(canvas).to eql ChunkyPNG::Canvas.from_blob(image.to_blob)
     end
   end
 rescue LoadError => e

data/spec/chunky_png/vector_spec.rb

@@ -4,75 +4,80 @@ describe ChunkyPNG::Vector do
   subject { ChunkyPNG::Vector.new([ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)]) }
 
   it { should respond_to(:points) }
-  it { should have(3).items }
+
+  describe '#length' do
+    it "shopuld have 3 items" do
+      expect(subject.length).to eql 3
+    end
+  end
 
   describe '#x_range' do
     it "should get the right range of x values" do
-      subject.x_range.should == (1..4)
+      expect(subject.x_range).to eql (1..4)
     end
-    
+
     it "should find the minimum x-coordinate" do
-      subject.min_x.should == 1
+      expect(subject.min_x).to eql 1
     end
-    
+
     it "should find the maximum x-coordinate" do
-      subject.max_x.should == 4
+      expect(subject.max_x).to eql 4
     end
-    
+
     it "should calculate the width correctly" do
-      subject.width.should == 4
+      expect(subject.width).to eql 4
     end
   end
 
   describe '#y_range' do
     it "should get the right range of y values" do
-      subject.y_range.should == (3..6)
+      expect(subject.y_range).to eql (3..6)
     end
-    
+
     it "should find the minimum x-coordinate" do
-      subject.min_y.should == 3
+      expect(subject.min_y).to eql 3
     end
-    
+
     it "should find the maximum x-coordinate" do
-      subject.max_y.should == 6
+      expect(subject.max_y).to eql 6
     end
-    
+
     it "should calculate the height correctly" do
-      subject.height.should == 4
+      expect(subject.height).to eql 4
     end
   end
-  
+
   describe '#offset' do
     it "should return a ChunkyPNG::Point" do
-      subject.offset.should be_kind_of(ChunkyPNG::Point)
+      expect(subject.offset).to be_kind_of(ChunkyPNG::Point)
     end
-    
+
     it "should use the mininum x and y coordinates as values for the point" do
-      subject.offset.x.should == subject.min_x
-      subject.offset.y.should == subject.min_y
+      expect(subject.offset.x).to eql subject.min_x
+      expect(subject.offset.y).to eql subject.min_y
     end
   end
 
   describe '#dimension' do
     it "should return a ChunkyPNG::Dimension" do
-      subject.dimension.should be_kind_of(ChunkyPNG::Dimension)
+      expect(subject.dimension).to be_kind_of(ChunkyPNG::Dimension)
     end
-    
+
     it "should use the width and height of the vector for the dimension" do
-      subject.dimension.width.should == subject.width
-      subject.dimension.height.should == subject.height
+      expect(subject.dimension.width).to eql subject.width
+      expect(subject.dimension.height).to eql subject.height
     end
   end
 
   describe '#edges' do
     it "should get three edges when closing the path" do
-      subject.edges(true).to_a.should == [[ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
+      expect(subject.edges(true).to_a).to eql [[ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
                                           [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)],
                                           [ChunkyPNG::Point.new(4, 6), ChunkyPNG::Point.new(2, 5)]]
     end
 
     it "should get two edges when not closing the path" do
-      subject.edges(false).to_a.should == [[ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
+      expect(subject.edges(false).to_a).to eql [[ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
                                            [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)]]
     end
   end
@@ -80,25 +85,25 @@ end
 
 describe 'ChunkyPNG.Vector' do
   let(:example) { ChunkyPNG::Vector.new([ChunkyPNG::Point.new(2, 4), ChunkyPNG::Point.new(1, 2), ChunkyPNG::Point.new(3, 6)]) }
-  
+
   it "should return an empty vector when given an empty array" do
-    ChunkyPNG::Vector().should == ChunkyPNG::Vector.new([])
-    ChunkyPNG::Vector(*[]).should == ChunkyPNG::Vector.new([])
+    expect(ChunkyPNG::Vector()).to eql ChunkyPNG::Vector.new([])
+    expect(ChunkyPNG::Vector(*[])).to eql ChunkyPNG::Vector.new([])
   end
 
   it "should raise an error when an odd number of numerics is given" do
-    lambda { ChunkyPNG::Vector(1, 2, 3) }.should raise_error(ArgumentError)
+    expect { ChunkyPNG::Vector(1, 2, 3) }.to raise_error(ArgumentError)
   end
 
   it "should create a vector from a string" do
-    ChunkyPNG::Vector('(2,4) (1,2) (3,6)').should == example
+    expect(ChunkyPNG::Vector('(2,4) (1,2) (3,6)')).to eql example
   end
-  
+
   it "should create a vector from a flat array" do
-    ChunkyPNG::Vector(2,4,1,2,3,6).should == example
+    expect(ChunkyPNG::Vector(2,4,1,2,3,6)).to eql example
   end
 
   it "should create a vector from a nested array" do
-    ChunkyPNG::Vector('(2,4)', [1, 2], :x => 3, :y => 6).should == example
+    expect(ChunkyPNG::Vector('(2,4)', [1, 2], :x => 3, :y => 6)).to eql example
   end
 end

data/spec/chunky_png_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 describe ChunkyPNG do
-  
   it "should have a VERSION constant" do
-    ChunkyPNG.const_defined?('VERSION').should be_true
+    expect(ChunkyPNG.const_defined?('VERSION')).to eql true
   end
 end

data/spec/png_suite_spec.rb

@@ -1,120 +1,120 @@
 require 'spec_helper'
 
 describe 'PNG testuite' do
-  
+
   context 'Decoding broken images' do
     png_suite_files(:broken).each do |file|
       it "should report #{File.basename(file)} as broken" do
-        lambda { ChunkyPNG::Image.from_file(file) }.should raise_error(ChunkyPNG::Exception)
+        expect { ChunkyPNG::Image.from_file(file) }.to raise_error(ChunkyPNG::Exception)
       end
     end
   end
-  
+
   context 'Decoding supported images' do
     png_suite_files(:basic, '*.png').each do |file|
 
       reference  = file.sub(/\.png$/, '.rgba')
       color_mode = file.match(/[in](\d)[apgc](\d\d)\.png$/)[1].to_i
       bit_depth  = file.match(/[in](\d)[apgc](\d\d)\.png$/)[2].to_i
-      
+
       it "should decode #{File.basename(file)} (color mode: #{color_mode}, bit depth: #{bit_depth}) exactly the same as the reference image" do
         decoded = ChunkyPNG::Canvas.from_file(file)
-        File.open(reference, 'rb') { |f| decoded.to_rgba_stream.should == f.read }
+        File.open(reference, 'rb') { |f| expect(decoded.to_rgba_stream).to eql f.read }
       end
     end
   end
-  
+
   context 'Decoding text chunks' do
-    
+
     it "should not find metadata in a file without text chunks" do
       image = ChunkyPNG::Image.from_file(png_suite_file(:metadata, 'cm0n0g04.png'))
-      image.metadata.should be_empty
+      expect(image.metadata).to be_empty
     end
-    
+
     # it "should find metadata in a file with uncompressed text chunks" do
     #   image = ChunkyPNG::Image.from_file(png_suite_file(:metadata, 'cm7n0g04.png'))
     #   image.metadata.should_not be_empty
     # end
-    # 
+    #
     # it "should find metadata in a file with compressed text chunks" do
     #   image = ChunkyPNG::Image.from_file(png_suite_file(:metadata, 'cm9n0g04.png'))
     #   image.metadata.should_not be_empty
     # end
   end
-  
+
   context 'Decoding filter methods' do
     png_suite_files(:filtering, '*_reference.png').each do |reference_file|
 
       file = reference_file.sub(/_reference\.png$/, '.png')
       filter_method = file.match(/f(\d\d)[a-z0-9]+\.png/)[1].to_i
-      
+
       it "should decode #{File.basename(file)} (filter method: #{filter_method}) exactly the same as the reference image" do
         decoded   = ChunkyPNG::Canvas.from_file(file)
         reference = ChunkyPNG::Canvas.from_file(reference_file)
-        decoded.should == reference
+        expect(decoded).to eql reference
       end
     end
   end
-  
+
   context 'Decoding different chunk splits' do
     it "should decode grayscale images successfully regardless of the data chunk ordering and splitting" do
       reference = ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi1n0g16.png')).imagedata
-      ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi2n0g16.png')).imagedata.should == reference
-      ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi4n0g16.png')).imagedata.should == reference
-      ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi9n0g16.png')).imagedata.should == reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi2n0g16.png')).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi4n0g16.png')).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi9n0g16.png')).imagedata).to eql reference
     end
-    
+
     it "should decode color images successfully regardless of the data chunk ordering and splitting" do
       reference = ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi1n2c16.png')).imagedata
-      ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi2n2c16.png')).imagedata.should == reference
-      ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi4n2c16.png')).imagedata.should == reference
-      ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi9n2c16.png')).imagedata.should == reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi2n2c16.png')).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi4n2c16.png')).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi9n2c16.png')).imagedata).to eql reference
     end
   end
-  
+
   context 'Decoding different compression levels' do
     it "should decode the image successfully regardless of the compression level" do
       reference = ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z00n2c08.png')).imagedata
-      ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z03n2c08.png')).imagedata.should == reference
-      ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z06n2c08.png')).imagedata.should == reference
-      ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z09n2c08.png')).imagedata.should == reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z03n2c08.png')).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z06n2c08.png')).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z09n2c08.png')).imagedata).to eql reference
     end
   end
-  
+
   context 'Decoding transparency' do
     png_suite_files(:transparency, 'tp0*.png').each do |file|
       it "should not have transparency in #{File.basename(file)}" do
-        ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0,0]).should == 255
+        expect(ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0,0])).to eql 255
       end
     end
-    
+
     png_suite_files(:transparency, 'tp1*.png').each do |file|
       it "should have transparency in #{File.basename(file)}" do
-        ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0,0]).should == 0
+        expect(ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0,0])).to eql 0
       end
     end
-    
+
     png_suite_files(:transparency, 'tb*.png').each do |file|
       it "should have transparency in #{File.basename(file)}" do
-        ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0,0]).should == 0
+        expect(ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0,0])).to eql 0
       end
     end
   end
-  
+
   context 'Decoding different sizes' do
-    
+
     png_suite_files(:sizes, '*n*.png').each do |file|
       dimension = file.match(/s(\d\d)n\dp\d\d/)[1].to_i
-      
+
       it "should create a canvas with a #{dimension}x#{dimension} size" do
         canvas = ChunkyPNG::Image.from_file(file)
-        canvas.width.should == dimension
-        canvas.height.should == dimension
+        expect(canvas.width).to eql dimension
+        expect(canvas.height).to eql dimension
       end
-      
+
       it "should decode the #{dimension}x#{dimension} interlaced image exactly the same the non-interlaced version" do
         interlaced_file = file.sub(/n3p(\d\d)\.png$/, 'i3p\\1.png')
-        ChunkyPNG::Image.from_file(interlaced_file).should == ChunkyPNG::Image.from_file(file)
+        expect(ChunkyPNG::Image.from_file(interlaced_file)).to eql ChunkyPNG::Image.from_file(file)
       end
     end
   end