chunky_png 1.3.2 → 1.3.3

data/spec/chunky_png/canvas/stream_exporting_spec.rb

@@ -1,18 +1,18 @@
 require 'spec_helper'
 
 describe ChunkyPNG::Canvas do
-  
+
   describe '#to_rgba_stream' do
     it "should export a sample canvas to an RGBA stream correctly" do
       canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.rgba(1,2,3,4), ChunkyPNG::Color.rgba(5,6,7,8),
                                             ChunkyPNG::Color.rgba(4,3,2,1), ChunkyPNG::Color.rgba(8,7,6,5)])
 
-      canvas.to_rgba_stream.should ==  [1,2,3,4,5,6,7,8,4,3,2,1,8,7,6,5].pack('C16')
+      expect(canvas.to_rgba_stream).to eql  [1,2,3,4,5,6,7,8,4,3,2,1,8,7,6,5].pack('C16')
     end
-    
+
     it "should export an image to an RGBA datastream correctly" do
-      reference_canvas('pixelstream_reference').to_rgba_stream.should == resource_data('pixelstream.rgba')
-    end    
+      expect(reference_canvas('pixelstream_reference').to_rgba_stream).to eql resource_data('pixelstream.rgba')
+    end
   end
 
   describe '#to_rgb_stream' do
@@ -20,40 +20,40 @@ describe ChunkyPNG::Canvas do
       canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.rgba(1,2,3,4), ChunkyPNG::Color.rgba(5,6,7,8),
                                             ChunkyPNG::Color.rgba(4,3,2,1), ChunkyPNG::Color.rgba(8,7,6,5)])
 
-      canvas.to_rgb_stream.should == [1,2,3,5,6,7,4,3,2,8,7,6].pack('C12')
-    end    
-    
+      expect(canvas.to_rgb_stream).to eql [1,2,3,5,6,7,4,3,2,8,7,6].pack('C12')
+    end
+
     it "should export an image to an RGB datastream correctly" do
-      reference_canvas('pixelstream_reference').to_rgb_stream.should == resource_data('pixelstream.rgb')
+      expect(reference_canvas('pixelstream_reference').to_rgb_stream).to eql resource_data('pixelstream.rgb')
     end
   end
-  
+
   describe '#to_grayscale_stream' do
-    
+
     it "should export a grayscale image to a grayscale datastream correctly" do
       canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.grayscale(1), ChunkyPNG::Color.grayscale(2),
                                             ChunkyPNG::Color.grayscale(3), ChunkyPNG::Color.grayscale(4)])
-      canvas.to_grayscale_stream.should == [1,2,3,4].pack('C4')
-    end    
+      expect(canvas.to_grayscale_stream).to eql [1,2,3,4].pack('C4')
+    end
+
 
-    
     it "should export a color image to a grayscale datastream, using B values" do
       canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.rgba(1,2,3,4), ChunkyPNG::Color.rgba(5,6,7,8),
                                             ChunkyPNG::Color.rgba(4,3,2,1), ChunkyPNG::Color.rgba(8,7,6,5)])
-      canvas.to_grayscale_stream.should == [3,7,2,6].pack('C4')
-    end    
+      expect(canvas.to_grayscale_stream).to eql [3,7,2,6].pack('C4')
+    end
   end
-  
+
   describe '#to_alpha_channel_stream' do
     it "should export an opaque image to an alpha channel datastream correctly" do
       grayscale_array = Array.new(reference_canvas('pixelstream_reference').pixels.length, 255)
-      reference_canvas('pixelstream_reference').to_alpha_channel_stream.should == grayscale_array.pack('C*')
+      expect(reference_canvas('pixelstream_reference').to_alpha_channel_stream).to eql grayscale_array.pack('C*')
     end
-    
+
     it "should export a transparent image to an alpha channel datastream correctly" do
       canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.rgba(1,2,3,4), ChunkyPNG::Color.rgba(5,6,7,8),
                                             ChunkyPNG::Color.rgba(4,3,2,1), ChunkyPNG::Color.rgba(8,7,6,5)])
-      canvas.to_alpha_channel_stream.should == [4,8,1,5].pack('C4')
+      expect(canvas.to_alpha_channel_stream).to eql [4,8,1,5].pack('C4')
     end
   end
 end

data/spec/chunky_png/canvas/stream_importing_spec.rb

@@ -6,7 +6,7 @@ describe ChunkyPNG::Canvas do
     it "should load an image correctly from a datastream" do
       File.open(resource_file('pixelstream.rgb')) do |stream|
         matrix = ChunkyPNG::Canvas.from_rgb_stream(240, 180, stream)
-        matrix.should == reference_canvas('pixelstream_reference')
+        expect(matrix).to eql reference_canvas('pixelstream_reference')
       end
     end
   end
@@ -15,7 +15,7 @@ describe ChunkyPNG::Canvas do
     it "should load an image correctly from a datastream" do
       File.open(resource_file('pixelstream.bgr')) do |stream|
         matrix = ChunkyPNG::Canvas.from_bgr_stream(240, 180, stream)
-        matrix.should == reference_canvas('pixelstream_reference')
+        expect(matrix).to eql reference_canvas('pixelstream_reference')
       end
     end
   end
@@ -24,7 +24,7 @@ describe ChunkyPNG::Canvas do
     it "should load an image correctly from a datastream" do
       File.open(resource_file('pixelstream.rgba')) do |stream|
         matrix = ChunkyPNG::Canvas.from_rgba_stream(240, 180, stream)
-        matrix.should == reference_canvas('pixelstream_reference')
+        expect(matrix).to eql reference_canvas('pixelstream_reference')
       end
     end
   end

data/spec/chunky_png/canvas_spec.rb

@@ -11,216 +11,219 @@ describe ChunkyPNG::Canvas do
   describe '#initialize' do
     it "should accept a single color value as background color" do
       canvas = ChunkyPNG::Canvas.new(2, 2, 'red @ 0.8')
-      canvas[1, 0].should == ChunkyPNG::Color.parse('red @ 0.8')
+      expect(canvas[1, 0]).to eql ChunkyPNG::Color.parse('red @ 0.8')
     end
-    
+
     it "should raise an error if the color value is not understood" do
-      lambda { ChunkyPNG::Canvas.new(2, 2, :nonsense) }.should raise_error(ArgumentError)
+      expect { ChunkyPNG::Canvas.new(2, 2, :nonsense) }.to raise_error(ArgumentError)
     end
-    
+
     it "should accept an array as initial pixel values" do
       canvas = ChunkyPNG::Canvas.new(2, 2, [1,2,3,4])
-      canvas[0, 0].should == 1
-      canvas[1, 0].should == 2
-      canvas[0, 1].should == 3
-      canvas[1, 1].should == 4
+      expect(canvas[0, 0]).to eql 1
+      expect(canvas[1, 0]).to eql 2
+      expect(canvas[0, 1]).to eql 3
+      expect(canvas[1, 1]).to eql 4
     end
-    
+
     it "should raise an ArgumentError if the initial array does not have the correct number of elements" do
-      lambda { ChunkyPNG::Canvas.new(2, 2, [1,2,3]) }.should raise_error(ArgumentError)
-      lambda { ChunkyPNG::Canvas.new(2, 2, [1,2,3,4,5]) }.should raise_error(ArgumentError)      
+      expect { ChunkyPNG::Canvas.new(2, 2, [1,2,3]) }.to raise_error(ArgumentError)
+      expect { ChunkyPNG::Canvas.new(2, 2, [1,2,3,4,5]) }.to raise_error(ArgumentError)
     end
-    
+
     it "should use a transparent background by default" do
       canvas = ChunkyPNG::Canvas.new(1, 1)
-      canvas[0,0].should == ChunkyPNG::Color::TRANSPARENT
+      expect(canvas[0,0]).to eql ChunkyPNG::Color::TRANSPARENT
     end
   end
 
   describe '#dimension' do
     it "should return the dimensions as a Dimension instance" do
-      subject.dimension.should == ChunkyPNG::Dimension('1x1')
+      expect(subject.dimension).to eql ChunkyPNG::Dimension('1x1')
     end
   end
-  
+
   describe '#area' do
     it "should return the dimensions as two-item array" do
-      subject.area.should == ChunkyPNG::Dimension('1x1').area
+      expect(subject.area).to eql ChunkyPNG::Dimension('1x1').area
     end
   end
 
   describe '#include?' do
     it "should return true if the coordinates are within bounds, false otherwise" do
-      subject.include_xy?( 0,  0).should be_true
-      
-      subject.include_xy?(-1,  0).should be_false
-      subject.include_xy?( 1,  0).should be_false
-      subject.include_xy?( 0, -1).should be_false
-      subject.include_xy?( 0,  1).should be_false
-      subject.include_xy?(-1, -1).should be_false
-      subject.include_xy?(-1,  1).should be_false
-      subject.include_xy?( 1, -1).should be_false
-      subject.include_xy?( 1,  1).should be_false
-    end
-    
+      expect(subject.include_xy?( 0,  0)).to eql true
+
+      expect(subject.include_xy?(-1,  0)).to eql false
+      expect(subject.include_xy?( 1,  0)).to eql false
+      expect(subject.include_xy?( 0, -1)).to eql false
+      expect(subject.include_xy?( 0,  1)).to eql false
+      expect(subject.include_xy?(-1, -1)).to eql false
+      expect(subject.include_xy?(-1,  1)).to eql false
+      expect(subject.include_xy?( 1, -1)).to eql false
+      expect(subject.include_xy?( 1,  1)).to eql false
+    end
+
     it "should accept strings, arrays, hashes and points as well" do
-      subject.should     include('0, 0')
+      expect(subject).to     include('0, 0')
       subject.should_not include('0, 1')
-      subject.should     include([0, 0])
+      expect(subject).to     include([0, 0])
       subject.should_not include([0, 1])
-      subject.should     include(:y => 0, :x => 0)
+      expect(subject).to     include(:y => 0, :x => 0)
       subject.should_not include(:y => 1, :x => 0)
-      subject.should     include(ChunkyPNG::Point.new(0, 0))
+      expect(subject).to     include(ChunkyPNG::Point.new(0, 0))
       subject.should_not include(ChunkyPNG::Point.new(0, 1))
     end
   end
-  
+
   describe '#include_x?' do
     it "should return true if the x-coordinate is within bounds, false otherwise" do
-      subject.include_x?( 0).should be_true
-      subject.include_x?(-1).should be_false
-      subject.include_x?( 1).should be_false
+      expect(subject.include_x?( 0)).to eql true
+      expect(subject.include_x?(-1)).to eql false
+      expect(subject.include_x?( 1)).to eql false
     end
   end
-  
+
   describe '#include_y?' do
     it "should return true if the y-coordinate is within bounds, false otherwise" do
-      subject.include_y?( 0).should be_true
-      subject.include_y?(-1).should be_false
-      subject.include_y?( 1).should be_false
+      expect(subject.include_y?( 0)).to eql true
+      expect(subject.include_y?(-1)).to eql false
+      expect(subject.include_y?( 1)).to eql false
     end
   end
-  
+
   describe '#assert_xy!' do
     it "should not raise an exception if the coordinates are within bounds" do
-      subject.should_receive(:include_xy?).with(0, 0).and_return(true)
-      lambda { subject.send(:assert_xy!, 0, 0) }.should_not raise_error
+      expect(subject).to receive(:include_xy?).with(0, 0).and_return(true)
+      expect { subject.send(:assert_xy!, 0, 0) }.to_not raise_error
     end
-    
+
     it "should raise an exception if the coordinates are out of bounds bounds" do
-      subject.should_receive(:include_xy?).with(0, -1).and_return(false)
-      lambda { subject.send(:assert_xy!, 0, -1) }.should raise_error(ChunkyPNG::OutOfBounds)
+      expect(subject).to receive(:include_xy?).with(0, -1).and_return(false)
+      expect { subject.send(:assert_xy!, 0, -1) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
-  
+
   describe '#assert_x!' do
     it "should not raise an exception if the x-coordinate is within bounds" do
-      subject.should_receive(:include_x?).with(0).and_return(true)
-      lambda { subject.send(:assert_x!, 0) }.should_not raise_error
+      expect(subject).to receive(:include_x?).with(0).and_return(true)
+      expect { subject.send(:assert_x!, 0) }.to_not raise_error
     end
-    
+
     it "should raise an exception if the x-coordinate is out of bounds bounds" do
-      subject.should_receive(:include_y?).with(-1).and_return(false)
-      lambda { subject.send(:assert_y!, -1) }.should raise_error(ChunkyPNG::OutOfBounds)
+      expect(subject).to receive(:include_y?).with(-1).and_return(false)
+      expect { subject.send(:assert_y!, -1) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
-  
+
   describe '#[]' do
     it "should return the pixel value if the coordinates are within bounds" do
-      subject[0, 0].should == ChunkyPNG::Color::WHITE
+      expect(subject[0, 0]).to eql ChunkyPNG::Color::WHITE
     end
-    
+
     it "should assert the coordinates to be within bounds" do
-      subject.should_receive(:assert_xy!).with(0, 0)
+      expect(subject).to receive(:assert_xy!).with(0, 0)
       subject[0, 0]
     end
   end
-  
+
   describe '#get_pixel' do
     it "should return the pixel value if the coordinates are within bounds" do
-      subject.get_pixel(0, 0).should == ChunkyPNG::Color::WHITE
+      expect(subject.get_pixel(0, 0)).to eql ChunkyPNG::Color::WHITE
     end
-    
+
     it "should not assert nor check the coordinates" do
-      subject.should_not_receive(:assert_xy!)
-      subject.should_not_receive(:include_xy?)
+      expect(subject).to_not receive(:assert_xy!)
+      expect(subject).to_not receive(:include_xy?)
       subject.get_pixel(0, 0)
     end
   end
-  
+
   describe '#[]=' do
     it "should change the pixel's color value" do
-      lambda { subject[0, 0] = ChunkyPNG::Color::BLACK }.should change { subject[0, 0] }.from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
+      expect { subject[0, 0] = ChunkyPNG::Color::BLACK }.to change { subject[0, 0] }.
+        from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
     end
-    
+
     it "should assert the bounds of the image" do
-      subject.should_receive(:assert_xy!).with(0, 0)
+      expect(subject).to receive(:assert_xy!).with(0, 0)
       subject[0, 0] = ChunkyPNG::Color::BLACK
     end
   end
-  
+
   describe 'set_pixel' do
     it "should change the pixel's color value" do
-      lambda { subject.set_pixel(0, 0, ChunkyPNG::Color::BLACK) }.should change { subject[0, 0] }.from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
+      expect { subject.set_pixel(0, 0, ChunkyPNG::Color::BLACK) }.to change { subject[0, 0] }.
+          from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
     end
-    
+
     it "should not assert or check the bounds of the image" do
-      subject.should_not_receive(:assert_xy!)
-      subject.should_not_receive(:include_xy?)
+      expect(subject).to_not receive(:assert_xy!)
+      expect(subject).to_not receive(:include_xy?)
       subject.set_pixel(0, 0, ChunkyPNG::Color::BLACK)
     end
   end
-  
+
   describe '#set_pixel_if_within_bounds' do
     it "should change the pixel's color value" do
-      lambda { subject.set_pixel_if_within_bounds(0, 0, ChunkyPNG::Color::BLACK) }.should change { subject[0, 0] }.from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
+      expect { subject.set_pixel_if_within_bounds(0, 0, ChunkyPNG::Color::BLACK) }.to change { subject[0, 0] }.
+          from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
     end
 
     it "should not assert, but only check the coordinates" do
-      subject.should_not_receive(:assert_xy!)
-      subject.should_receive(:include_xy?).with(0, 0)
+      expect(subject).to_not receive(:assert_xy!)
+      expect(subject).to receive(:include_xy?).with(0, 0)
       subject.set_pixel_if_within_bounds(0, 0, ChunkyPNG::Color::BLACK)
     end
 
     it "should do nothing if the coordinates are out of bounds" do
-      subject.set_pixel_if_within_bounds(-1, 1, ChunkyPNG::Color::BLACK).should be_nil
-      subject[0, 0].should == ChunkyPNG::Color::WHITE
+      expect(subject.set_pixel_if_within_bounds(-1, 1, ChunkyPNG::Color::BLACK)).to be_nil
+      expect(subject[0, 0]).to eql ChunkyPNG::Color::WHITE
     end
   end
-  
+
   describe '#row' do
     before { @canvas = reference_canvas('operations') }
 
     it "should give an out of bounds exception when y-coordinate is out of bounds" do
-      lambda { @canvas.row(-1) }.should raise_error(ChunkyPNG::OutOfBounds)
-      lambda { @canvas.row(16) }.should raise_error(ChunkyPNG::OutOfBounds)
+      expect { @canvas.row(-1) }.to raise_error(ChunkyPNG::OutOfBounds)
+      expect { @canvas.row(16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
 
     it "should return the correct pixels" do
       data = @canvas.row(0)
-      data.should have(@canvas.width).items
-      data.should == [65535, 268500991, 536936447, 805371903, 1073807359, 1342242815, 1610678271, 1879113727, 2147549183, 2415984639, 2684420095, 2952855551, 3221291007, 3489726463, 3758161919, 4026597375]
+      expect(data.length).to eql @canvas.width
+      expect(data).to eql [65535, 268500991, 536936447, 805371903, 1073807359, 1342242815, 1610678271, 1879113727, 2147549183, 2415984639, 2684420095, 2952855551, 3221291007, 3489726463, 3758161919, 4026597375]
     end
   end
-  
+
   describe '#column' do
     before { @canvas = reference_canvas('operations') }
 
     it "should give an out of bounds exception when x-coordinate is out of bounds" do
-      lambda { @canvas.column(-1) }.should raise_error(ChunkyPNG::OutOfBounds)
-      lambda { @canvas.column(16) }.should raise_error(ChunkyPNG::OutOfBounds)
+      expect { @canvas.column(-1) }.to raise_error(ChunkyPNG::OutOfBounds)
+      expect { @canvas.column(16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
 
     it "should return the correct pixels" do
       data = @canvas.column(0)
-      data.should have(@canvas.height).items
-      data.should == [65535, 1114111, 2162687, 3211263, 4259839, 5308415, 6356991, 7405567, 8454143, 9502719, 10551295, 11599871, 12648447, 13697023, 14745599, 15794175]
+      expect(data.length).to eql @canvas.height
+      expect(data).to eql [65535, 1114111, 2162687, 3211263, 4259839, 5308415, 6356991, 7405567, 8454143, 9502719, 10551295, 11599871, 12648447, 13697023, 14745599, 15794175]
     end
   end
-  
+
   describe '#replace_canvas' do
     it "should change the dimension of the canvas" do
-      lambda { subject.send(:replace_canvas!, 2, 2, [1,2,3,4]) }.should change(subject, :dimension).
+      expect { subject.send(:replace_canvas!, 2, 2, [1,2,3,4]) }.to change { subject.dimension }.
           from(ChunkyPNG::Dimension('1x1')).to(ChunkyPNG::Dimension('2x2'))
     end
-    
+
     it "should change the pixel array" do
-      lambda { subject.send(:replace_canvas!, 2, 2, [1,2,3,4]) }.should change(subject, :pixels).
+      expect { subject.send(:replace_canvas!, 2, 2, [1,2,3,4]) }.to change { subject.pixels }.
           from([ChunkyPNG::Color('white')]).to([1,2,3,4])
     end
-    
+
     it "should return itself" do
-      subject.send(:replace_canvas!, 2, 2, [1,2,3,4]).should equal(subject)
+      expect(subject.send(:replace_canvas!, 2, 2, [1,2,3,4])).to equal(subject)
     end
   end
 end

data/spec/chunky_png/color_spec.rb

@@ -2,20 +2,20 @@ require 'spec_helper'
 
 describe 'ChunyPNG.Color' do
   it 'should interpret 4 arguments as RGBA values' do
-    ChunkyPNG::Color(1, 2, 3, 4).should == ChunkyPNG::Color.rgba(1, 2, 3, 4)
+    expect(ChunkyPNG::Color(1, 2, 3, 4)).to eql ChunkyPNG::Color.rgba(1, 2, 3, 4)
   end
 
   it 'should interpret 3 arguments as RGBA values' do
-    ChunkyPNG::Color(1, 2, 3).should == ChunkyPNG::Color.rgb(1, 2, 3)
+    expect(ChunkyPNG::Color(1, 2, 3)).to eql ChunkyPNG::Color.rgb(1, 2, 3)
   end
 
   it 'should interpret 2 arguments as a color to parse and an opacity value' do
-    ChunkyPNG::Color('0x0a649664', 0xaa).should == 0x0a6496aa
-    ChunkyPNG::Color('spring green @ 0.6666', 0xff).should == 0x00ff7fff
+    expect(ChunkyPNG::Color('0x0a649664', 0xaa)).to eql 0x0a6496aa
+    expect(ChunkyPNG::Color('spring green @ 0.6666', 0xff)).to eql 0x00ff7fff
   end
 
   it 'should interpret 1 argument as a color to parse' do
-    ChunkyPNG::Color.should_receive(:parse).with('0x0a649664')
+    expect(ChunkyPNG::Color).to receive(:parse).with('0x0a649664')
     ChunkyPNG::Color('0x0a649664')
   end
 end
@@ -36,128 +36,128 @@ describe ChunkyPNG::Color do
 
   describe '#parse' do
     it 'should interpret a hex string correctly' do
-      parse('0x0a649664').should == ChunkyPNG::Color.from_hex('#0a649664')
+      expect(parse('0x0a649664')).to eql ChunkyPNG::Color.from_hex('#0a649664')
     end
 
     it 'should interpret a color name correctly' do
-      parse(:spring_green).should == 0x00ff7fff
-      parse('spring green').should == 0x00ff7fff
-      parse('spring green @ 0.6666').should == 0x00ff7faa
+      expect(parse(:spring_green)).to eql 0x00ff7fff
+      expect(parse('spring green')).to eql 0x00ff7fff
+      expect(parse('spring green @ 0.6666')).to eql 0x00ff7faa
     end
 
     it 'should return numbers as is' do
-      parse('12345').should == 12345
-      parse(12345).should == 12345
+      expect(parse('12345')).to eql 12345
+      expect(parse(12345)).to eql 12345
     end
   end
 
   describe '#pixel_bytesize' do
     it 'should return the normal amount of bytes with a bit depth of 8' do
-      pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8).should == 3
+      expect(pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8)).to eql 3
     end
 
     it 'should return a multiple of the normal amount of bytes with a bit depth greater than 8' do
-      pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 16).should == 6
-      pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 16).should == 8
-      pixel_bytesize(ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 16).should == 4
+      expect(pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 16)).to eql 6
+      expect(pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 16)).to eql 8
+      expect(pixel_bytesize(ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 16)).to eql 4
     end
 
     it 'should return 1 with a bit depth lower than 0' do
-      pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 4).should == 1
-      pixel_bytesize(ChunkyPNG::COLOR_INDEXED, 2).should == 1
-      pixel_bytesize(ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 1).should == 1
+      expect(pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 4)).to eql 1
+      expect(pixel_bytesize(ChunkyPNG::COLOR_INDEXED, 2)).to eql 1
+      expect(pixel_bytesize(ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 1)).to eql 1
     end
   end
 
   describe '#pass_bytesize' do
     it 'should calculate a pass size correctly' do
-      pass_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8, 10, 10).should == 310
+      expect(pass_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8, 10, 10)).to eql 310
     end
 
     it 'should return 0 if one of the dimensions is zero' do
-      pass_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8, 0, 10).should == 0
-      pass_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8, 10, 0).should == 0
+      expect(pass_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8, 0, 10)).to eql 0
+      expect(pass_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8, 10, 0)).to eql 0
     end
   end
 
   describe '#rgba' do
     it 'should represent pixels as the correct number' do
-      rgba(255, 255, 255, 255).should == @white
-      rgba(  0,   0,   0, 255).should == @black
-      rgba( 10, 100, 150, 255).should == @opaque
-      rgba( 10, 100, 150, 100).should == @non_opaque
-      rgba( 10, 100, 150,   0).should == @fully_transparent
+      expect(rgba(255, 255, 255, 255)).to eql @white
+      expect(rgba(  0,   0,   0, 255)).to eql @black
+      expect(rgba( 10, 100, 150, 255)).to eql @opaque
+      expect(rgba( 10, 100, 150, 100)).to eql @non_opaque
+      expect(rgba( 10, 100, 150,   0)).to eql @fully_transparent
     end
   end
 
   describe '#from_hex' do
     it 'should load colors correctly from hex notation' do
-      from_hex('0a649664').should   == @non_opaque
-      from_hex('#0a649664').should  == @non_opaque
-      from_hex('0x0a649664').should == @non_opaque
-      from_hex('0a6496').should     == @opaque
-      from_hex('#0a6496').should    == @opaque
-      from_hex('0x0a6496').should   == @opaque
-      from_hex('abc').should        == 0xaabbccff
-      from_hex('#abc').should       == 0xaabbccff
-      from_hex('0xabc').should      == 0xaabbccff
+      expect(from_hex('0a649664')).to   eql @non_opaque
+      expect(from_hex('#0a649664')).to  eql @non_opaque
+      expect(from_hex('0x0a649664')).to eql @non_opaque
+      expect(from_hex('0a6496')).to     eql @opaque
+      expect(from_hex('#0a6496')).to    eql @opaque
+      expect(from_hex('0x0a6496')).to   eql @opaque
+      expect(from_hex('abc')).to        eql 0xaabbccff
+      expect(from_hex('#abc')).to       eql 0xaabbccff
+      expect(from_hex('0xabc')).to      eql 0xaabbccff
     end
 
     it 'should allow setting opacity explicitly' do
-      from_hex('0x0a6496', 0x64).should == @non_opaque
-      from_hex('#0a6496', 0x64).should  == @non_opaque
-      from_hex('0xabc', 0xdd).should    == 0xaabbccdd
-      from_hex('#abc', 0xdd).should     == 0xaabbccdd
+      expect(from_hex('0x0a6496', 0x64)).to eql @non_opaque
+      expect(from_hex('#0a6496', 0x64)).to  eql @non_opaque
+      expect(from_hex('0xabc', 0xdd)).to    eql 0xaabbccdd
+      expect(from_hex('#abc', 0xdd)).to     eql 0xaabbccdd
     end
   end
 
   describe '#from_hsv' do
     it 'should load colors correctly from an HSV triple' do
       # At 0 brightness, should be @black independent of hue or sat
-      from_hsv(0, 0, 0).should        == @black
-      from_hsv(100, 1, 0).should      == @black
-      from_hsv(100, 0.5, 0).should    == @black
-      
+      expect(from_hsv(0, 0, 0)).to        eql @black
+      expect(from_hsv(100, 1, 0)).to      eql @black
+      expect(from_hsv(100, 0.5, 0)).to    eql @black
+
       # At brightness 1 and sat 0, should be @white regardless of hue
-      from_hsv(0, 0, 1).should        == @white
-      from_hsv(100, 0, 1).should      == @white
+      expect(from_hsv(0, 0, 1)).to        eql @white
+      expect(from_hsv(100, 0, 1)).to      eql @white
 
       # Converting the "pure" colors should work
-      from_hsv(0, 1, 1).should        == @red
-      from_hsv(120, 1, 1).should      == @green
-      from_hsv(240, 1, 1).should      == @blue
+      expect(from_hsv(0, 1, 1)).to        eql @red
+      expect(from_hsv(120, 1, 1)).to      eql @green
+      expect(from_hsv(240, 1, 1)).to      eql @blue
 
       # And, finally, one random color
-      from_hsv(120, 0.5, 0.80).should == 0x66cc66ff
+      expect(from_hsv(120, 0.5, 0.80)).to eql 0x66cc66ff
     end
 
     it 'should optionally accept a fourth param for alpha' do
-      from_hsv(0, 1, 1, 255).should   == @red
-      from_hsv(120, 1, 1, 255).should == @green
-      from_hsv(240, 1, 1, 255).should == @blue
-      from_hsv(0, 1, 1, 0).should     == 0xff000000 # transparent red
-      from_hsv(120, 1, 1, 0).should   == 0x00ff0000 # transparent green
-      from_hsv(240, 1, 1, 0).should   == 0x0000ff00 # transparent blue
+      expect(from_hsv(0, 1, 1, 255)).to   eql @red
+      expect(from_hsv(120, 1, 1, 255)).to eql @green
+      expect(from_hsv(240, 1, 1, 255)).to eql @blue
+      expect(from_hsv(0, 1, 1, 0)).to     eql 0xff000000 # transparent red
+      expect(from_hsv(120, 1, 1, 0)).to   eql 0x00ff0000 # transparent green
+      expect(from_hsv(240, 1, 1, 0)).to   eql 0x0000ff00 # transparent blue
     end
   end
 
   describe '#from_hsl' do
     it 'should load colors correctly from an HSL triple' do
       # At 0 lightness, should always be black
-      from_hsl(0, 0, 0).should         == @black
-      from_hsl(100, 0, 0).should       == @black
-      from_hsl(54, 0.5, 0).should      == @black
-      
+      expect(from_hsl(0, 0, 0)).to         eql @black
+      expect(from_hsl(100, 0, 0)).to       eql @black
+      expect(from_hsl(54, 0.5, 0)).to      eql @black
+
       # At 1 lightness, should always be white
-      from_hsl(0, 0, 1).should         == @white
-      from_hsl(0, 0.5, 1).should       == @white
-      from_hsl(110, 0, 1).should       == @white
-      
+      expect(from_hsl(0, 0, 1)).to         eql @white
+      expect(from_hsl(0, 0.5, 1)).to       eql @white
+      expect(from_hsl(110, 0, 1)).to       eql @white
+
       # 'Pure' colors should work
-      from_hsl(0, 1, 0.5).should       == @red
-      from_hsl(120, 1, 0.5).should     == @green
-      from_hsl(240, 1, 0.5).should     == @blue
-      
+      expect(from_hsl(0, 1, 0.5)).to       eql @red
+      expect(from_hsl(120, 1, 0.5)).to     eql @green
+      expect(from_hsl(240, 1, 0.5)).to     eql @blue
+
       # Random colors
       from_hsl(87.27, 0.5, 0.5686)     == 0x96c85aff
       from_hsl(271.83, 0.5399, 0.4176) == 0x6e31a4ff
@@ -165,194 +165,194 @@ describe ChunkyPNG::Color do
     end
 
     it 'should optionally accept a fourth param for alpha' do
-      from_hsl(0, 1, 0.5, 255).should   == @red
-      from_hsl(120, 1, 0.5, 255).should == @green
-      from_hsl(240, 1, 0.5, 255).should == @blue
-      from_hsl(0, 1, 0.5, 0).should     == 0xff000000 # transparent red
-      from_hsl(120, 1, 0.5, 0).should   == 0x00ff0000 # transparent green
-      from_hsl(240, 1, 0.5, 0).should   == 0x0000ff00 # transparent blue
+      expect(from_hsl(0, 1, 0.5, 255)).to   eql @red
+      expect(from_hsl(120, 1, 0.5, 255)).to eql @green
+      expect(from_hsl(240, 1, 0.5, 255)).to eql @blue
+      expect(from_hsl(0, 1, 0.5, 0)).to     eql 0xff000000 # transparent red
+      expect(from_hsl(120, 1, 0.5, 0)).to   eql 0x00ff0000 # transparent green
+      expect(from_hsl(240, 1, 0.5, 0)).to   eql 0x0000ff00 # transparent blue
     end
   end
 
   describe '#html_color' do
     it 'should find the correct color value' do
-      html_color(:springgreen).should   == 0x00ff7fff
-      html_color(:spring_green).should  == 0x00ff7fff
-      html_color('springgreen').should  == 0x00ff7fff
-      html_color('spring green').should == 0x00ff7fff
-      html_color('SpringGreen').should  == 0x00ff7fff
-      html_color('SPRING_GREEN').should == 0x00ff7fff
+      expect(html_color(:springgreen)).to   eql 0x00ff7fff
+      expect(html_color(:spring_green)).to  eql 0x00ff7fff
+      expect(html_color('springgreen')).to  eql 0x00ff7fff
+      expect(html_color('spring green')).to eql 0x00ff7fff
+      expect(html_color('SpringGreen')).to  eql 0x00ff7fff
+      expect(html_color('SPRING_GREEN')).to eql 0x00ff7fff
     end
 
     it 'should set the opacity level explicitly' do
-      html_color(:springgreen, 0xff).should == 0x00ff7fff
-      html_color(:springgreen, 0xaa).should == 0x00ff7faa
-      html_color(:springgreen, 0x00).should == 0x00ff7f00
+      expect(html_color(:springgreen, 0xff)).to eql 0x00ff7fff
+      expect(html_color(:springgreen, 0xaa)).to eql 0x00ff7faa
+      expect(html_color(:springgreen, 0x00)).to eql 0x00ff7f00
     end
 
     it 'should set opacity levels from the color name' do
-      html_color('Spring green @ 1.0').should   == 0x00ff7fff
-      html_color('Spring green @ 0.666').should == 0x00ff7faa
-      html_color('Spring green @ 0.0').should   == 0x00ff7f00
+      expect(html_color('Spring green @ 1.0')).to   eql 0x00ff7fff
+      expect(html_color('Spring green @ 0.666')).to eql 0x00ff7faa
+      expect(html_color('Spring green @ 0.0')).to   eql 0x00ff7f00
     end
 
     it 'should raise for an unkown color name' do
-      lambda { html_color(:nonsense) }.should raise_error(ArgumentError)
+      expect { html_color(:nonsense) }.to raise_error(ArgumentError)
     end
   end
 
   describe '#opaque?' do
     it 'should correctly check for opaqueness' do
-      opaque?(@white).should be_true
-      opaque?(@black).should be_true
-      opaque?(@opaque).should be_true
-      opaque?(@non_opaque).should be_false
-      opaque?(@fully_transparent).should be_false
+      expect(opaque?(@white)).to eql true
+      expect(opaque?(@black)).to eql true
+      expect(opaque?(@opaque)).to eql true
+      expect(opaque?(@non_opaque)).to eql false
+      expect(opaque?(@fully_transparent)).to eql false
     end
   end
 
   describe 'extraction of separate color channels' do
     it 'should extract components from a color correctly' do
-      r(@opaque).should == 10
-      g(@opaque).should == 100
-      b(@opaque).should == 150
-      a(@opaque).should == 255
+      expect(r(@opaque)).to eql 10
+      expect(g(@opaque)).to eql 100
+      expect(b(@opaque)).to eql 150
+      expect(a(@opaque)).to eql 255
     end
   end
 
   describe '#grayscale_teint' do
     it 'should calculate the correct grayscale teint' do
-      grayscale_teint(@opaque).should     == 79
-      grayscale_teint(@non_opaque).should == 79
+      expect(grayscale_teint(@opaque)).to     eql 79
+      expect(grayscale_teint(@non_opaque)).to eql 79
     end
   end
 
   describe '#to_grayscale' do
     it 'should use the grayscale teint for r, g and b' do
       gs = to_grayscale(@non_opaque)
-      r(gs).should == grayscale_teint(@non_opaque)
-      g(gs).should == grayscale_teint(@non_opaque)
-      b(gs).should == grayscale_teint(@non_opaque)
+      expect(r(gs)).to eql grayscale_teint(@non_opaque)
+      expect(g(gs)).to eql grayscale_teint(@non_opaque)
+      expect(b(gs)).to eql grayscale_teint(@non_opaque)
     end
 
     it 'should preserve the alpha channel' do
-      a(to_grayscale(@non_opaque)).should == a(@non_opaque)
-      a(to_grayscale(@opaque)).should == ChunkyPNG::Color::MAX
+      expect(a(to_grayscale(@non_opaque))).to eql a(@non_opaque)
+      expect(a(to_grayscale(@opaque))).to eql ChunkyPNG::Color::MAX
     end
   end
 
   describe '#to_hex' do
     it 'should represent colors correcly using hex notation' do
-      to_hex(@white).should == '#ffffffff'
-      to_hex(@black).should == '#000000ff'
-      to_hex(@opaque).should == '#0a6496ff'
-      to_hex(@non_opaque).should == '#0a649664'
-      to_hex(@fully_transparent).should == '#0a649600'
+      expect(to_hex(@white)).to eql '#ffffffff'
+      expect(to_hex(@black)).to eql '#000000ff'
+      expect(to_hex(@opaque)).to eql '#0a6496ff'
+      expect(to_hex(@non_opaque)).to eql '#0a649664'
+      expect(to_hex(@fully_transparent)).to eql '#0a649600'
     end
 
     it 'should represent colors correcly using hex notation without alpha channel' do
-      to_hex(@white, false).should == '#ffffff'
-      to_hex(@black, false).should == '#000000'
-      to_hex(@opaque, false).should == '#0a6496'
-      to_hex(@non_opaque, false).should == '#0a6496'
-      to_hex(@fully_transparent, false).should == '#0a6496'
+      expect(to_hex(@white, false)).to eql '#ffffff'
+      expect(to_hex(@black, false)).to eql '#000000'
+      expect(to_hex(@opaque, false)).to eql '#0a6496'
+      expect(to_hex(@non_opaque, false)).to eql '#0a6496'
+      expect(to_hex(@fully_transparent, false)).to eql '#0a6496'
     end
   end
 
   describe '#to_hsv' do
     it 'should return a [hue, saturation, value] array' do
-      to_hsv(@white).should     == [0, 0, 1]
-      to_hsv(@black).should     == [0, 0, 0]
-      to_hsv(@red).should       == [0, 1, 1]
-      to_hsv(@blue).should      == [240, 1, 1]
-      to_hsv(@green).should     == [120, 1, 1]
-      to_hsv(0x805440ff)[0].should be_within(1).of(19)
-      to_hsv(0x805440ff)[1].should be_within(0.01).of(0.5)
-      to_hsv(0x805440ff)[2].should be_within(0.01).of(0.5)
+      expect(to_hsv(@white)).to     eql [0,   0.0, 1.0]
+      expect(to_hsv(@black)).to     eql [0,   0.0, 0.0]
+      expect(to_hsv(@red)).to       eql [0,   1.0, 1.0]
+      expect(to_hsv(@blue)).to      eql [240, 1.0, 1.0]
+      expect(to_hsv(@green)).to     eql [120, 1.0, 1.0]
+      expect(to_hsv(0x805440ff)[0]).to be_within(1).of(19)
+      expect(to_hsv(0x805440ff)[1]).to be_within(0.01).of(0.5)
+      expect(to_hsv(0x805440ff)[2]).to be_within(0.01).of(0.5)
     end
 
     it 'should optionally include the alpha channel' do
-      to_hsv(@white, true).should                == [0, 0, 1, 255]
-      to_hsv(@red, true).should                  == [0, 1, 1, 255]
-      to_hsv(@blue, true).should                 == [240, 1, 1, 255]
-      to_hsv(@green, true).should                == [120, 1, 1, 255]
-      to_hsv(@opaque, true)[3].should            == 255
-      to_hsv(@fully_transparent, true)[3].should == 0
+      expect(to_hsv(@white, true)).to                eql [0,   0.0, 1.0, 255]
+      expect(to_hsv(@red, true)).to                  eql [0,   1.0, 1.0, 255]
+      expect(to_hsv(@blue, true)).to                 eql [240, 1.0, 1.0, 255]
+      expect(to_hsv(@green, true)).to                eql [120, 1.0, 1.0, 255]
+      expect(to_hsv(@opaque, true)[3]).to            eql 255
+      expect(to_hsv(@fully_transparent, true)[3]).to eql 0
     end
   end
 
   describe '#to_hsl' do
     it 'should return a [hue, saturation, lightness] array' do
-      to_hsl(@white).should == [0, 0, 1]
-      to_hsl(@black).should == [0, 0, 0]
-      to_hsl(@red).should   == [0, 1, 0.5]
-      to_hsl(@blue).should  == [240, 1, 0.5]
-      to_hsl(@green).should == [120, 1, 0.5]
+      expect(to_hsl(@white)).to eql [0,   0.0, 1.0]
+      expect(to_hsl(@black)).to eql [0,   0.0, 0.0]
+      expect(to_hsl(@red)).to   eql [0,   1.0, 0.5]
+      expect(to_hsl(@blue)).to  eql [240, 1.0, 0.5]
+      expect(to_hsl(@green)).to eql [120, 1.0, 0.5]
     end
 
     it 'should optionally include the alpha channel in the returned array' do
-      to_hsl(@white, true).should          == [0, 0, 1, 255]
-      to_hsl(@black, true).should          == [0, 0, 0, 255]
-      to_hsl(@red, true).should            == [0, 1, 0.5, 255]
-      to_hsl(@blue, true).should           == [240, 1, 0.5, 255]
-      to_hsl(@green, true).should          == [120, 1, 0.5, 255]
-      to_hsl(@opaque, true)[3].should      == 255
-      to_hsl(@fully_transparent, true)[3].should == 0
+      expect(to_hsl(@white, true)).to          eql [0,   0.0, 1.0, 255]
+      expect(to_hsl(@black, true)).to          eql [0,   0.0, 0.0, 255]
+      expect(to_hsl(@red, true)).to            eql [0,   1.0, 0.5, 255]
+      expect(to_hsl(@blue, true)).to           eql [240, 1.0, 0.5, 255]
+      expect(to_hsl(@green, true)).to          eql [120, 1.0, 0.5, 255]
+      expect(to_hsl(@opaque, true)[3]).to      eql 255
+      expect(to_hsl(@fully_transparent, true)[3]).to eql 0
     end
   end
 
   describe 'conversion to other formats' do
     it 'should convert the individual color values back correctly' do
-      to_truecolor_bytes(@opaque).should == [10, 100, 150]
-      to_truecolor_alpha_bytes(@non_opaque).should == [10, 100, 150, 100]
+      expect(to_truecolor_bytes(@opaque)).to eql [10, 100, 150]
+      expect(to_truecolor_alpha_bytes(@non_opaque)).to eql [10, 100, 150, 100]
     end
   end
 
   describe '#compose' do
 
     it 'should use the foregorund color as is when the background color is fully transparent' do
-      compose(@non_opaque, @fully_transparent).should == @non_opaque
+      expect(compose(@non_opaque, @fully_transparent)).to eql @non_opaque
     end
 
     it 'should use the foregorund color as is when an opaque color is given as foreground color' do
-      compose(@opaque, @white).should == @opaque
+      expect(compose(@opaque, @white)).to eql @opaque
     end
 
     it 'should use the background color as is when a fully transparent pixel is given as foreground color' do
-      compose(@fully_transparent, @white).should == @white
+      expect(compose(@fully_transparent, @white)).to eql @white
     end
 
     it 'should compose pixels correctly with both algorithms' do
-      compose_quick(@non_opaque, @white).should   == 0x9fc2d6ff
-      compose_precise(@non_opaque, @white).should == 0x9fc2d6ff
+      expect(compose_quick(@non_opaque, @white)).to   eql 0x9fc2d6ff
+      expect(compose_precise(@non_opaque, @white)).to eql 0x9fc2d6ff
     end
   end
 
   describe '#decompose_alpha' do
     it 'should decompose the alpha channel correctly' do
-      decompose_alpha(0x9fc2d6ff, @opaque, @white).should == 0x00000064
+      expect(decompose_alpha(0x9fc2d6ff, @opaque, @white)).to eql 0x00000064
     end
 
     it 'should return fully transparent if the background channel matches the resulting color' do
-      decompose_alpha(0xabcdefff, 0xff000000, 0xabcdefff).should == 0x00
+      expect(decompose_alpha(0xabcdefff, 0xff000000, 0xabcdefff)).to eql 0x00
     end
 
     it 'should return fully opaque if the background channel matches the mask color' do
-      decompose_alpha(0xff000000, 0xabcdefff, 0xabcdefff).should == 0xff
+      expect(decompose_alpha(0xff000000, 0xabcdefff, 0xabcdefff)).to eql 0xff
     end
 
     it 'should return fully opaque if the resulting color matches the mask color' do
-      decompose_alpha(0xabcdefff, 0xabcdefff, 0xffffffff).should == 255
+      expect(decompose_alpha(0xabcdefff, 0xabcdefff, 0xffffffff)).to eql 255
     end
   end
 
   describe '#blend' do
     it 'should blend colors correctly' do
-      blend(@opaque, @black).should == 0x05324bff
+      expect(blend(@opaque, @black)).to eql 0x05324bff
     end
 
     it 'should not matter what color is used as foreground, and what as background' do
-      blend(@opaque, @black).should == blend(@black, @opaque)
+      expect(blend(@opaque, @black)).to eql blend(@black, @opaque)
     end
   end