chunky_png 1.3.2 → 1.3.3

data/spec/chunky_png/canvas/png_decoding_spec.rb

@@ -8,24 +8,24 @@ describe ChunkyPNG::Canvas::PNGDecoding do
     it "should decode a line without filtering as is" do
       stream = [ChunkyPNG::FILTER_NONE, 255, 255, 255, 255, 255, 255, 255, 255, 255].pack('C*')
       decode_png_str_scanline(stream, 0, nil, 9, 3)
-      stream.unpack('@1C*').should == [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      expect(stream.unpack('@1C*')).to eql [255, 255, 255, 255, 255, 255, 255, 255, 255]
     end
 
     it "should decode a line with sub filtering correctly" do
       # all white pixels
       stream = [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0].pack('C*')
       decode_png_str_scanline(stream, 0, nil, 9, 3)
-      stream.unpack('@1C*').should == [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      expect(stream.unpack('@1C*')).to eql [255, 255, 255, 255, 255, 255, 255, 255, 255]
 
       # all black pixels
       stream = [ChunkyPNG::FILTER_SUB, 0, 0, 0, 0, 0, 0, 0, 0, 0].pack('C*')
       decode_png_str_scanline(stream, 0, nil, 9, 3)
-      stream.unpack('@1C*').should == [0, 0, 0, 0, 0, 0, 0, 0, 0]
+      expect(stream.unpack('@1C*')).to eql [0, 0, 0, 0, 0, 0, 0, 0, 0]
 
       # various colors
       stream = [ChunkyPNG::FILTER_SUB, 255, 0, 45, 0, 255, 0, 112, 200, 178].pack('C*')
       decode_png_str_scanline(stream, 0, nil, 9, 3)
-      stream.unpack('@1C*').should == [255, 0, 45, 255, 255, 45, 111, 199, 223]
+      expect(stream.unpack('@1C*')).to eql [255, 0, 45, 255, 255, 45, 111, 199, 223]
     end
 
     it "should decode a line with up filtering correctly" do
@@ -34,15 +34,15 @@ describe ChunkyPNG::Canvas::PNGDecoding do
       current  = [ChunkyPNG::FILTER_UP, 0, 127, 255, 0, 127, 255, 0, 127, 255]
       stream   = (previous + current).pack('C*')
       decode_png_str_scanline(stream, 10, 0, 9, 3)
-      stream.unpack('@11C9').should == [255, 126, 254, 127, 254, 126, 0, 127, 255]
+      expect(stream.unpack('@11C9')).to eql [255, 126, 254, 127, 254, 126, 0, 127, 255]
     end
-    
+
     it "should decode a line with average filtering correctly" do
       previous = [ChunkyPNG::FILTER_AVERAGE, 10, 20, 30, 40, 50, 60, 70, 80, 80, 100, 110, 120]
       current  = [ChunkyPNG::FILTER_AVERAGE,  0,  0, 10, 23, 15, 13, 23, 63, 38,  60, 253,  53]
       stream   = (previous + current).pack('C*')
       decode_png_str_scanline(stream, 13, 0, 12, 3)
-      stream.unpack('@14C12').should == [5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165]
+      expect(stream.unpack('@14C12')).to eql [5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165]
     end
 
     it "should decode a line with paeth filtering correctly" do
@@ -50,48 +50,48 @@ describe ChunkyPNG::Canvas::PNGDecoding do
       current  = [ChunkyPNG::FILTER_PAETH,  0,  0, 10, 20, 10,  0,  0, 40, 10,  20, 190,   0]
       stream   = (previous + current).pack('C*')
       decode_png_str_scanline(stream, 13, 0, 12, 3)
-      stream.unpack('@14C12').should == [10, 20, 40, 60, 60, 60, 70, 120, 90, 120, 54, 120]
+      expect(stream.unpack('@14C12')).to eql [10, 20, 40, 60, 60, 60, 70, 120, 90, 120, 54, 120]
     end
   end
-  
+
   describe '#decode_png_extract_4bit_value' do
     it "should extract the high bits successfully" do
-      decode_png_extract_4bit_value('10010110'.to_i(2), 0).should == '1001'.to_i(2)
+      expect(decode_png_extract_4bit_value('10010110'.to_i(2), 0)).to eql '1001'.to_i(2)
     end
-    
+
     it "should extract the low bits successfully" do
-      decode_png_extract_4bit_value('10010110'.to_i(2), 17).should == '0110'.to_i(2)
+      expect(decode_png_extract_4bit_value('10010110'.to_i(2), 17)).to eql '0110'.to_i(2)
     end
   end
-  
+
   describe '#decode_png_extract_2bit_value' do
     it "should extract the first 2 bits successfully" do
-      decode_png_extract_2bit_value('10010110'.to_i(2), 0).should == '10'.to_i(2)
+      expect(decode_png_extract_2bit_value('10010110'.to_i(2), 0)).to eql '10'.to_i(2)
     end
 
     it "should extract the second 2 bits successfully" do
-      decode_png_extract_2bit_value('10010110'.to_i(2), 5).should == '01'.to_i(2)
+      expect(decode_png_extract_2bit_value('10010110'.to_i(2), 5)).to eql '01'.to_i(2)
     end
 
     it "should extract the third 2 bits successfully" do
-      decode_png_extract_2bit_value('10010110'.to_i(2), 2).should == '01'.to_i(2)
+      expect(decode_png_extract_2bit_value('10010110'.to_i(2), 2)).to eql '01'.to_i(2)
     end
 
     it "should extract the low two bits successfully" do
-      decode_png_extract_2bit_value('10010110'.to_i(2), 7).should == '10'.to_i(2)
+      expect(decode_png_extract_2bit_value('10010110'.to_i(2), 7)).to eql '10'.to_i(2)
     end
   end
-  
+
   describe '#decode_png_extract_1bit_value' do
     it "should extract all separate bits correctly" do
-      decode_png_extract_1bit_value('10010110'.to_i(2), 0).should == 1
-      decode_png_extract_1bit_value('10010110'.to_i(2), 1).should == 0
-      decode_png_extract_1bit_value('10010110'.to_i(2), 2).should == 0
-      decode_png_extract_1bit_value('10010110'.to_i(2), 3).should == 1
-      decode_png_extract_1bit_value('10010110'.to_i(2), 4).should == 0
-      decode_png_extract_1bit_value('10010110'.to_i(2), 5).should == 1
-      decode_png_extract_1bit_value('10010110'.to_i(2), 6).should == 1
-      decode_png_extract_1bit_value('10010110'.to_i(2), 7).should == 0
+      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 0)).to eql 1
+      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 1)).to eql 0
+      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 2)).to eql 0
+      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 3)).to eql 1
+      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 4)).to eql 0
+      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 5)).to eql 1
+      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 6)).to eql 1
+      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 7)).to eql 0
     end
   end
 end

data/spec/chunky_png/canvas/png_encoding_spec.rb

@@ -9,175 +9,175 @@ describe ChunkyPNG::Canvas::PNGEncoding do
         canvas = ChunkyPNG::Canvas.new(10, 10, ChunkyPNG::Color.rgb(100, 100, 100))
         color_mode = ChunkyPNG.const_get("COLOR_#{color_mode_name.to_s.upcase}")
         blob = canvas.to_blob(:color_mode => color_mode)
-        
+
         ds = ChunkyPNG::Datastream.from_blob(blob)
-        ds.header_chunk.color.should == color_mode
-        ChunkyPNG::Canvas.from_datastream(ds).should == ChunkyPNG::Canvas.new(10, 10, ChunkyPNG::Color.rgb(100, 100, 100))
+        expect(ds.header_chunk.color).to eql color_mode
+        expect(ChunkyPNG::Canvas.from_datastream(ds)).to eql ChunkyPNG::Canvas.new(10, 10, ChunkyPNG::Color.rgb(100, 100, 100))
       end
     end
-    
+
     it "should encode an image with 2 colors using 1-bit indexed color mode" do
       @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p01.png'))
       ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
-      ds.header_chunk.color.should == ChunkyPNG::COLOR_INDEXED
-      ds.header_chunk.depth.should == 1
-      @canvas.should == ChunkyPNG::Canvas.from_datastream(ds)
+      expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_INDEXED
+      expect(ds.header_chunk.depth).to eql 1
+      expect(@canvas).to eql ChunkyPNG::Canvas.from_datastream(ds)
     end
-    
+
     it "should encode an image with 4 colors using 2-bit indexed color mode" do
       @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p02.png'))
       ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
-      ds.header_chunk.color.should == ChunkyPNG::COLOR_INDEXED
-      ds.header_chunk.depth.should == 2
-      @canvas.should == ChunkyPNG::Canvas.from_datastream(ds)
+      expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_INDEXED
+      expect(ds.header_chunk.depth).to eql 2
+      expect(@canvas).to eql ChunkyPNG::Canvas.from_datastream(ds)
     end
-    
+
     it "should encode an image with 16 colors using 4-bit indexed color mode" do
       @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p04.png'))
       ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
-      ds.header_chunk.color.should == ChunkyPNG::COLOR_INDEXED
-      ds.header_chunk.depth.should == 4
-      @canvas.should == ChunkyPNG::Canvas.from_datastream(ds)
+      expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_INDEXED
+      expect(ds.header_chunk.depth).to eql 4
+      expect(@canvas).to eql ChunkyPNG::Canvas.from_datastream(ds)
     end
-    
+
     it "should encode an image with 256 colors using 8-bit indexed color mode" do
       @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p08.png'))
       ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
-      ds.header_chunk.color.should == ChunkyPNG::COLOR_INDEXED
-      ds.header_chunk.depth.should == 8
-      @canvas.should == ChunkyPNG::Canvas.from_datastream(ds)
+      expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_INDEXED
+      expect(ds.header_chunk.depth).to eql 8
+      expect(@canvas).to eql ChunkyPNG::Canvas.from_datastream(ds)
     end
-    
+
     it "should use a higher bit depth than necessary if requested" do
       @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p01.png'))
       ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob(:bit_depth => 4))
-      ds.header_chunk.color.should == ChunkyPNG::COLOR_INDEXED
-      ds.header_chunk.depth.should == 4
-      @canvas.should == ChunkyPNG::Canvas.from_datastream(ds)
+      expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_INDEXED
+      expect(ds.header_chunk.depth).to eql 4
+      expect(@canvas).to eql ChunkyPNG::Canvas.from_datastream(ds)
     end
-    
+
     it "should encode an image with interlacing correctly" do
       input_canvas = ChunkyPNG::Canvas.from_file(resource_file('operations.png'))
       blob = input_canvas.to_blob(:interlace => true)
-      
+
       ds = ChunkyPNG::Datastream.from_blob(blob)
-      ds.header_chunk.interlace.should == ChunkyPNG::INTERLACING_ADAM7
-      ChunkyPNG::Canvas.from_datastream(ds).should == input_canvas
+      expect(ds.header_chunk.interlace).to eql ChunkyPNG::INTERLACING_ADAM7
+      expect(ChunkyPNG::Canvas.from_datastream(ds)).to eql input_canvas
     end
 
     it "should save an image using the normal routine correctly" do
       canvas = reference_canvas('operations')
-      Zlib::Deflate.should_receive(:deflate).with(anything, Zlib::DEFAULT_COMPRESSION).and_return('')
+      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::DEFAULT_COMPRESSION).and_return('')
       canvas.to_blob
     end
 
     it "should save an image using the :fast_rgba routine correctly" do
       canvas = reference_canvas('operations')
-      canvas.should_not_receive(:encode_png_str_scanline_none)
-      canvas.should_not_receive(:encode_png_str_scanline_sub)
-      canvas.should_not_receive(:encode_png_str_scanline_up)
-      canvas.should_not_receive(:encode_png_str_scanline_average)
-      canvas.should_not_receive(:encode_png_str_scanline_paeth)
-      Zlib::Deflate.should_receive(:deflate).with(anything, Zlib::BEST_SPEED).and_return('')
+      expect(canvas).to_not receive(:encode_png_str_scanline_none)
+      expect(canvas).to_not receive(:encode_png_str_scanline_sub)
+      expect(canvas).to_not receive(:encode_png_str_scanline_up)
+      expect(canvas).to_not receive(:encode_png_str_scanline_average)
+      expect(canvas).to_not receive(:encode_png_str_scanline_paeth)
+      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::BEST_SPEED).and_return('')
       canvas.to_blob(:fast_rgba)
     end
 
     it "should save an image using the :good_compression routine correctly" do
       canvas = reference_canvas('operations')
-      canvas.should_not_receive(:encode_png_str_scanline_none)
-      canvas.should_not_receive(:encode_png_str_scanline_sub)
-      canvas.should_not_receive(:encode_png_str_scanline_up)
-      canvas.should_not_receive(:encode_png_str_scanline_average)
-      canvas.should_not_receive(:encode_png_str_scanline_paeth)
-      Zlib::Deflate.should_receive(:deflate).with(anything, Zlib::BEST_COMPRESSION).and_return('')
+      expect(canvas).to_not receive(:encode_png_str_scanline_none)
+      expect(canvas).to_not receive(:encode_png_str_scanline_sub)
+      expect(canvas).to_not receive(:encode_png_str_scanline_up)
+      expect(canvas).to_not receive(:encode_png_str_scanline_average)
+      expect(canvas).to_not receive(:encode_png_str_scanline_paeth)
+      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::BEST_COMPRESSION).and_return('')
       canvas.to_blob(:good_compression)
     end
 
     it "should save an image using the :best_compression routine correctly" do
       canvas = reference_canvas('operations')
-      canvas.should_receive(:encode_png_str_scanline_paeth).exactly(canvas.height).times
-      Zlib::Deflate.should_receive(:deflate).with(anything, Zlib::BEST_COMPRESSION).and_return('')
+      expect(canvas).to receive(:encode_png_str_scanline_paeth).exactly(canvas.height).times
+      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::BEST_COMPRESSION).and_return('')
       canvas.to_blob(:best_compression)
     end
-    
+
     it "should save an image with black and white only if requested" do
       ds = ChunkyPNG::Datastream.from_blob(reference_canvas('lines').to_blob(:black_and_white))
-      ds.header_chunk.color.should == ChunkyPNG::COLOR_GRAYSCALE
-      ds.header_chunk.depth.should == 1
+      expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_GRAYSCALE
+      expect(ds.header_chunk.depth).to eql 1
     end
   end
 
   describe 'different color modes and bit depths' do
-    before do 
+    before do
       @canvas = ChunkyPNG::Canvas.new(2, 2)
-      
+
       @canvas[0, 0] = ChunkyPNG::Color.rgba(  1,   2,   3,   4)
       @canvas[1, 0] = ChunkyPNG::Color.rgba(252, 253, 254, 255)
       @canvas[0, 1] = ChunkyPNG::Color.rgba(255, 254, 253, 252)
       @canvas[1, 1] = ChunkyPNG::Color.rgba(  4,   3,   2,   1)
-            
+
       @canvas.encoding_palette = @canvas.palette
       @canvas.encoding_palette.to_plte_chunk
     end
 
     it "should encode using 8-bit RGBA mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      stream.should == ChunkyPNG.force_binary("\0\x01\x02\x03\x04\xFC\xFD\xFE\xFF\0\xFF\xFE\xFD\xFC\x04\x03\x02\x01")
+      expect(stream).to eql ChunkyPNG.force_binary("\0\x01\x02\x03\x04\xFC\xFD\xFE\xFF\0\xFF\xFE\xFD\xFC\x04\x03\x02\x01")
     end
 
     it "should encode using 8 bit RGB mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      stream.should == ChunkyPNG.force_binary("\0\x01\x02\x03\xFC\xFD\xFE\0\xFF\xFE\xFD\x04\x03\x02")
+      expect(stream).to eql ChunkyPNG.force_binary("\0\x01\x02\x03\xFC\xFD\xFE\0\xFF\xFE\xFD\x04\x03\x02")
     end
 
     it "should encode using 1-bit grayscale mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_GRAYSCALE, 1, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      stream.should == ChunkyPNG.force_binary("\0\x40\0\x80") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
+      expect(stream).to eql ChunkyPNG.force_binary("\0\x40\0\x80") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
     end
 
     it "should encode using 2-bit grayscale mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_GRAYSCALE, 2, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      stream.should == ChunkyPNG.force_binary("\0\x30\0\xC0") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
+      expect(stream).to eql ChunkyPNG.force_binary("\0\x30\0\xC0") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
     end
 
     it "should encode using 4-bit grayscale mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_GRAYSCALE, 4, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      stream.should == ChunkyPNG.force_binary("\0\x0F\0\xF0") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
+      expect(stream).to eql ChunkyPNG.force_binary("\0\x0F\0\xF0") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
     end
 
     it "should encode using 8-bit grayscale mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_GRAYSCALE, 8, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      stream.should == ChunkyPNG.force_binary("\0\x03\xFE\0\xFD\x02") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
+      expect(stream).to eql ChunkyPNG.force_binary("\0\x03\xFE\0\xFD\x02") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
     end
 
     it "should not encode using 1-bit indexed mode because the image has too many colors" do
-      lambda {
+      expect {
         @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_INDEXED, 1, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      }.should raise_error(ChunkyPNG::ExpectationFailed)
+      }.to raise_error(ChunkyPNG::ExpectationFailed)
     end
-    
+
     it "should encode using 2-bit indexed mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_INDEXED, 2, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      stream.should == ChunkyPNG.force_binary("\0\x20\0\xD0")
+      expect(stream).to eql ChunkyPNG.force_binary("\0\x20\0\xD0")
     end
-    
+
     it "should encode using 4-bit indexed mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_INDEXED, 4, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      stream.should == ChunkyPNG.force_binary("\0\x02\0\x31")
+      expect(stream).to eql ChunkyPNG.force_binary("\0\x02\0\x31")
     end
-    
+
     it "should encode using 8-bit indexed mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_INDEXED, 8, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      stream.should == ChunkyPNG.force_binary("\0\x00\x02\0\x03\x01")
+      expect(stream).to eql ChunkyPNG.force_binary("\0\x00\x02\0\x03\x01")
     end
   end
-  
+
   describe 'different filter methods' do
 
     it "should encode a scanline without filtering correctly" do
       stream = [ChunkyPNG::FILTER_NONE, 0, 0, 0, 1, 1, 1, 2, 2, 2].pack('C*')
       encode_png_str_scanline_none(stream, 0, nil, 9, 3)
-      stream.unpack('C*').should == [ChunkyPNG::FILTER_NONE, 0, 0, 0, 1, 1, 1, 2, 2, 2]
+      expect(stream.unpack('C*')).to eql [ChunkyPNG::FILTER_NONE, 0, 0, 0, 1, 1, 1, 2, 2, 2]
     end
 
     it "should encode a scanline with sub filtering correctly" do
@@ -186,11 +186,11 @@ describe ChunkyPNG::Canvas::PNGEncoding do
 
       # Check line with previous line
       encode_png_str_scanline_sub(stream, 10, 0, 9, 3)
-      stream.unpack('@10C10').should == [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0]
+      expect(stream.unpack('@10C10')).to eql [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0]
 
       # Check line without previous line
       encode_png_str_scanline_sub(stream, 0, nil, 9, 3)
-      stream.unpack('@0C10').should == [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0]
+      expect(stream.unpack('@0C10')).to eql [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0]
     end
 
     it "should encode a scanline with up filtering correctly" do
@@ -199,37 +199,37 @@ describe ChunkyPNG::Canvas::PNGEncoding do
 
       # Check line with previous line
       encode_png_str_scanline_up(stream, 10, 0, 9, 3)
-      stream.unpack('@10C10').should == [ChunkyPNG::FILTER_UP, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+      expect(stream.unpack('@10C10')).to eql [ChunkyPNG::FILTER_UP, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
       # Check line without previous line
       encode_png_str_scanline_up(stream, 0, nil, 9, 3)
-      stream.unpack('@0C10').should == [ChunkyPNG::FILTER_UP, 255, 255, 255, 255, 255, 255, 255, 255, 255]
+      expect(stream.unpack('@0C10')).to eql [ChunkyPNG::FILTER_UP, 255, 255, 255, 255, 255, 255, 255, 255, 255]
     end
-    
+
     it "should encode a scanline with average filtering correctly" do
       stream = [ChunkyPNG::FILTER_NONE, 10, 20, 30, 40, 50, 60, 70, 80,   80, 100, 110, 120,
                 ChunkyPNG::FILTER_NONE,  5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165].pack('C*')
 
       # Check line with previous line
       encode_png_str_scanline_average(stream, 13, 0, 12, 3)
-      stream.unpack('@13C13').should == [ChunkyPNG::FILTER_AVERAGE, 0, 0, 10, 23, 15, 13, 23, 63, 38, 60, 253, 53]
+      expect(stream.unpack('@13C13')).to eql [ChunkyPNG::FILTER_AVERAGE, 0, 0, 10, 23, 15, 13, 23, 63, 38, 60, 253, 53]
 
       # Check line without previous line
       encode_png_str_scanline_average(stream, 0, nil, 12, 3)
-      stream.unpack('@0C13').should == [ChunkyPNG::FILTER_AVERAGE, 10, 20, 30, 35, 40, 45, 50, 55, 50, 65, 70, 80]
+      expect(stream.unpack('@0C13')).to eql [ChunkyPNG::FILTER_AVERAGE, 10, 20, 30, 35, 40, 45, 50, 55, 50, 65, 70, 80]
     end
-    
+
     it "should encode a scanline with paeth filtering correctly" do
       stream = [ChunkyPNG::FILTER_NONE, 10, 20, 30, 40, 50, 60, 70,  80, 80, 100, 110, 120,
                 ChunkyPNG::FILTER_NONE, 10, 20, 40, 60, 60, 60, 70, 120, 90, 120,  54, 120].pack('C*')
 
       # Check line with previous line
       encode_png_str_scanline_paeth(stream, 13, 0, 12, 3)
-      stream.unpack('@13C13').should == [ChunkyPNG::FILTER_PAETH, 0, 0, 10, 20, 10, 0, 0, 40, 10, 20, 190, 0]
+      expect(stream.unpack('@13C13')).to eql [ChunkyPNG::FILTER_PAETH, 0, 0, 10, 20, 10, 0, 0, 40, 10, 20, 190, 0]
 
       # Check line without previous line
       encode_png_str_scanline_paeth(stream, 0, nil, 12, 3)
-      stream.unpack('@0C13').should == [ChunkyPNG::FILTER_PAETH, 10, 20, 30, 30, 30, 30, 30, 30, 20, 30, 30, 40]
+      expect(stream.unpack('@0C13')).to eql [ChunkyPNG::FILTER_PAETH, 10, 20, 30, 30, 30, 30, 30, 30, 20, 30, 30, 40]
     end
   end
 end

data/spec/chunky_png/canvas/resampling_spec.rb

@@ -2,120 +2,120 @@ require 'spec_helper'
 
 describe ChunkyPNG::Canvas::Resampling do
 
-  subject { reference_canvas('clock') } 
+  subject { reference_canvas('clock') }
 
   describe '#resample_nearest_neighbor' do
-    
+
     it "should downscale from 2x2 to 1x1 correctly" do
       canvas = ChunkyPNG::Canvas.new(2, 2, [1, 2, 3, 4])
-      canvas.resample_nearest_neighbor(1, 1).should == ChunkyPNG::Canvas.new(1, 1, [4])
+      expect(canvas.resample_nearest_neighbor(1, 1)).to eql ChunkyPNG::Canvas.new(1, 1, [4])
     end
-    
+
     it "should upscale from 2x2 to 4x4 correctly" do
       canvas = ChunkyPNG::Canvas.new(2, 2, [1, 2, 3, 4])
-      canvas.resample_nearest_neighbor(4, 4).should == ChunkyPNG::Canvas.new(4, 4, [1, 1, 2, 2, 1, 1, 2, 2, 3, 3, 4, 4, 3, 3, 4, 4])
+      expect(canvas.resample_nearest_neighbor(4, 4)).to eql ChunkyPNG::Canvas.new(4, 4, [1, 1, 2, 2, 1, 1, 2, 2, 3, 3, 4, 4, 3, 3, 4, 4])
     end
-    
+
     it "should upscale both axis of the image" do
-      subject.resample_nearest_neighbor(45, 45).should == reference_canvas('clock_nn_xup_yup')
+      expect(subject.resample_nearest_neighbor(45, 45)).to eql reference_canvas('clock_nn_xup_yup')
     end
-    
+
     it "should downscale both axis of the image" do
-      subject.resample_nearest_neighbor(12, 12).should == reference_canvas('clock_nn_xdown_ydown')
+      expect(subject.resample_nearest_neighbor(12, 12)).to eql reference_canvas('clock_nn_xdown_ydown')
     end
-    
+
     it "should downscale the x-axis and upscale the y-axis of the image" do
-      subject.resample_nearest_neighbor(20, 50).should == reference_canvas('clock_nn_xdown_yup')
+      expect(subject.resample_nearest_neighbor(20, 50)).to eql reference_canvas('clock_nn_xdown_yup')
     end
-    
+
     it "should not return itself" do
       subject.resample_nearest_neighbor(1, 1).should_not equal(subject)
     end
-    
+
     it "should not change the original image's dimensions" do
-      lambda { subject.resample_nearest_neighbor(1, 1) }.should_not change(subject, :dimension)
+      expect { subject.resample_nearest_neighbor(1, 1) }.to_not change { subject.dimension }
     end
   end
-  
+
   describe '#resample_nearest_neighbor!' do
     it "should upscale both axis of the image" do
       subject.resample_nearest_neighbor!(45, 45)
-      subject.should == reference_canvas('clock_nn_xup_yup')
+      expect(subject).to eql reference_canvas('clock_nn_xup_yup')
     end
-    
+
     it "should downscale both axis of the image" do
       subject.resample_nearest_neighbor!(12, 12)
-      subject.should == reference_canvas('clock_nn_xdown_ydown')
+      expect(subject).to eql reference_canvas('clock_nn_xdown_ydown')
     end
-    
+
     it "should downscale the x-axis and upscale the y-axis of the image" do
       subject.resample_nearest_neighbor!(20, 50)
-      subject.should == reference_canvas('clock_nn_xdown_yup')
+      expect(subject).to eql reference_canvas('clock_nn_xdown_yup')
     end
-    
+
     it "should return itself" do
-      subject.resample_nearest_neighbor!(1, 1).should equal(subject)
+      expect(subject.resample_nearest_neighbor!(1, 1)).to equal(subject)
     end
-    
+
     it "should change the original image's dimensions" do
-      lambda { subject.resample_nearest_neighbor!(1, 1) }.should change(subject, :dimension).to(ChunkyPNG::Dimension('1x1'))
+      expect { subject.resample_nearest_neighbor!(1, 1) }.to change { subject.dimension }.to(ChunkyPNG::Dimension('1x1'))
     end
   end
-  
+
   describe "#resample_bilinear" do
     it "should downscale from 2x2 to 1x1 correctly" do
       canvas = ChunkyPNG::Canvas.new(2, 2, [1, 2, 3, 4])
-      canvas.resample_bilinear(1, 1).should == ChunkyPNG::Canvas.new(1, 1, [2])
+      expect(canvas.resample_bilinear(1, 1)).to eql ChunkyPNG::Canvas.new(1, 1, [2])
     end
-    
+
     it "should upscale from 2x2 to 4x4 correctly" do
       canvas = ChunkyPNG::Canvas.new(2, 2, [1, 2, 3, 4])
-      canvas.resample_bilinear(4, 4).should == ChunkyPNG::Canvas.new(4, 4, [1, 2, 1, 2, 2, 2, 2, 2, 2, 3, 3, 4, 3, 3, 4, 4])
+      expect(canvas.resample_bilinear(4, 4)).to eql ChunkyPNG::Canvas.new(4, 4, [1, 2, 1, 2, 2, 2, 2, 2, 2, 3, 3, 4, 3, 3, 4, 4])
     end
-    
+
     it "should upscale both axis of the image" do
-      subject.resample_bilinear(45, 45).should == reference_canvas('clock_bl_xup_yup')
+      expect(subject.resample_bilinear(45, 45)).to eql reference_canvas('clock_bl_xup_yup')
     end
-    
+
     it "should downscale both axis of the image" do
-      subject.resample_bilinear(12, 12).should == reference_canvas('clock_bl_xdown_ydown')
+      expect(subject.resample_bilinear(12, 12)).to eql reference_canvas('clock_bl_xdown_ydown')
     end
-    
+
     it "should downscale the x-axis and upscale the y-axis of the image" do
-      subject.resample_bilinear(20, 50).should == reference_canvas('clock_bl_xdown_yup')
+      expect(subject.resample_bilinear(20, 50)).to eql reference_canvas('clock_bl_xdown_yup')
     end
-    
+
     it "should not return itself" do
       subject.resample_bilinear(1, 1).should_not equal(subject)
     end
-    
+
     it "should not change the original image's dimensions" do
-      lambda { subject.resample_bilinear(1, 1) }.should_not change(subject, :dimension)
+      expect { subject.resample_bilinear(1, 1) }.to_not change { subject.dimension }
     end
   end
-  
+
   describe '#resample_bilinear!' do
     it "should upscale both axis of the image" do
       subject.resample_bilinear!(45, 45)
-      subject.should == reference_canvas('clock_bl_xup_yup')
+      expect(subject).to eql reference_canvas('clock_bl_xup_yup')
     end
-    
+
     it "should downscale both axis of the image" do
       subject.resample_bilinear!(12, 12)
-      subject.should == reference_canvas('clock_bl_xdown_ydown')
+      expect(subject).to eql reference_canvas('clock_bl_xdown_ydown')
     end
-    
+
     it "should downscale the x-axis and upscale the y-axis of the image" do
       subject.resample_bilinear!(20, 50)
-      subject.should == reference_canvas('clock_bl_xdown_yup')
+      expect(subject).to eql reference_canvas('clock_bl_xdown_yup')
     end
-    
+
     it "should return itself" do
-      subject.resample_bilinear!(1, 1).should equal(subject)
+      expect(subject.resample_bilinear!(1, 1)).to equal(subject)
     end
-    
+
     it "should change the original image's dimensions" do
-      lambda { subject.resample_bilinear!(1, 1) }.should change(subject, :dimension).to(ChunkyPNG::Dimension('1x1'))
+      expect { subject.resample_bilinear!(1, 1) }.to change { subject.dimension }.to(ChunkyPNG::Dimension('1x1'))
     end
   end
 end