bench9000 0.1

data/vendor/chunky_png/spec/chunky_png/canvas/data_url_exporting_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas do
+  
+  describe '#to_data_url' 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_data_url.should == "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACAgMAAAAP2OW3AAAADFBMVEUBAgMEAwIFBgcIBwazgAAdAAAABHRSTlMEAQgFhYDlfQAAAAxJREFUeJxjUmAKAAAAwAB1GNhIEwAAAABJRU5ErkJggg=="
+    end
+  end
+end

data/vendor/chunky_png/spec/chunky_png/canvas/data_url_importing_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas do
+  
+  describe '.from_data_url' do
+    it "should import an image from a data URL" do
+      data_url = reference_canvas('operations').to_data_url
+      ChunkyPNG::Canvas.from_data_url(data_url).should == reference_canvas('operations')
+    end
+    
+    it "should raise an exception if the string is not a proper data URL" do
+      lambda { ChunkyPNG::Canvas.from_data_url('whatever') }.should raise_error(ChunkyPNG::SignatureMismatch)
+    end
+  end
+end

data/vendor/chunky_png/spec/chunky_png/canvas/drawing_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas::Drawing do
+  
+  describe '#compose_pixel' do
+    subject { ChunkyPNG::Canvas.new(1, 1, ChunkyPNG::Color.rgb(200, 150, 100)) }
+    
+    it "should compose colors correctly" do
+      subject.compose_pixel(0,0, ChunkyPNG::Color(100, 150, 200, 128))
+      subject[0, 0].should == ChunkyPNG::Color(150, 150, 150)
+    end
+    
+    it "should return the composed color" do
+      subject.compose_pixel(0, 0, ChunkyPNG::Color.rgba(100, 150, 200, 128)).should == ChunkyPNG::Color.rgb(150, 150, 150)
+    end
+    
+    it "should do nothing when the coordinates are out of bounds" do
+      subject.compose_pixel(1, -1, :black).should be_nil
+      lambda { subject.compose_pixel(1, -1, :black) }.should_not change { subject[0, 0] }
+    end
+  end
+  
+  describe '#line' do
+    it "should draw lines correctly with anti-aliasing" do
+      
+      canvas = ChunkyPNG::Canvas.new(31, 31, ChunkyPNG::Color::WHITE)
+      
+      canvas.line( 0,  0, 30, 30, ChunkyPNG::Color::BLACK)
+      canvas.line( 0, 30, 30,  0, ChunkyPNG::Color::BLACK)
+      canvas.line(15, 30, 15,  0, ChunkyPNG::Color.rgba(200,   0,   0, 128))
+      canvas.line( 0, 15, 30, 15, ChunkyPNG::Color.rgba(200,   0,   0, 128))
+      canvas.line(30, 30,  0, 15, ChunkyPNG::Color.rgba(  0, 200,   0, 128), false)
+      canvas.line( 0, 15, 30,  0, ChunkyPNG::Color.rgba(  0, 200,   0, 128))
+      canvas.line( 0, 30, 15,  0, ChunkyPNG::Color.rgba(  0,   0, 200, 128), false)
+      canvas.line(15,  0, 30, 30, ChunkyPNG::Color.rgba(  0,   0, 200, 128))
+
+      canvas.should == reference_canvas('lines')
+    end
+    
+    it "should draw partial lines if the coordinates are partially out of bounds" do
+      canvas = ChunkyPNG::Canvas.new(1, 2, ChunkyPNG::Color::WHITE)
+      canvas.line(-5, -5, 0, 0, '#000000')
+      canvas.pixels.should == [ChunkyPNG::Color::BLACK, ChunkyPNG::Color::WHITE]
+    end
+    
+    it "should return itself to allow chaining" do
+      canvas = ChunkyPNG::Canvas.new(16, 16, ChunkyPNG::Color::WHITE)
+      canvas.line(1, 1, 10, 10, :black).should equal(canvas)
+    end
+  end
+  
+  describe '#rect' do
+    subject { ChunkyPNG::Canvas.new(16, 16, '#ffffff') }
+    
+    it "should draw a rectangle with the correct colors" do
+      subject.rect(1, 1, 10, 10, ChunkyPNG::Color.rgba(0, 255, 0,  80), ChunkyPNG::Color.rgba(255, 0, 0, 100))
+      subject.rect(5, 5, 14, 14, ChunkyPNG::Color.rgba(0, 0, 255, 160), ChunkyPNG::Color.rgba(255, 255, 0, 100))
+      subject.should == reference_canvas('rect')
+    end
+    
+    it "should return itself to allow chaining" do
+      subject.rect(1, 1, 10, 10).should equal(subject)
+    end
+    
+    it "should draw partial rectangles if the coordinates are partially out of bounds" do
+      subject.rect(0, 0, 20, 20, :black, :white)
+      subject[0, 0].should == ChunkyPNG::Color::BLACK
+    end
+    
+    it "should draw the rectangle fill only if the coordinates are fully out of bounds" do
+      subject.rect(-1, -1, 20, 20, :black, :white)
+      subject[0, 0].should == ChunkyPNG::Color::WHITE
+    end
+  end
+  
+  describe '#circle' do
+    subject { ChunkyPNG::Canvas.new(32, 32, ChunkyPNG::Color.rgba(0, 0, 255, 128)) } 
+    
+    it "should draw circles" do
+      subject.circle(11, 11, 10, ChunkyPNG::Color('red @ 0.5'), ChunkyPNG::Color('white @ 0.2'))
+      subject.circle(21, 21, 10, ChunkyPNG::Color('green @ 0.5'))
+      subject.should == reference_canvas('circles')
+    end
+    
+    it "should draw partial circles when going of the canvas bounds" do
+      subject.circle(0, 0, 10, ChunkyPNG::Color(:red))
+      subject.circle(31, 16, 10, ChunkyPNG::Color(:black), ChunkyPNG::Color(:white, 0xaa))
+      subject.should == reference_canvas('partial_circles')
+    end
+
+    it "should return itself to allow chaining" do
+      subject.circle(10, 10, 5, :red).should equal(subject)
+    end
+  end
+  
+  describe '#polygon' do
+    subject { ChunkyPNG::Canvas.new(22, 22) }
+
+    it "should draw an filled triangle when using 3 control points" do
+      subject.polygon('(2,2) (20,5) (5,20)', ChunkyPNG::Color(:black, 0xaa), ChunkyPNG::Color(:red, 0x44))
+      subject.should == reference_canvas('polygon_triangle_filled')
+    end
+
+    it "should draw a unfilled polygon with 6 control points" do
+      subject.polygon('(2,2) (12, 1) (20,5) (18,18) (5,20) (1,12)', ChunkyPNG::Color(:black))
+      subject.should == reference_canvas('polygon_unfilled')
+    end
+    
+    it "should draw a vertically crossed filled polygon with 4 control points" do
+      subject.polygon('(2,2) (21,2) (2,21) (21,21)', ChunkyPNG::Color(:black), ChunkyPNG::Color(:red))
+      subject.should == reference_canvas('polygon_filled_vertical')
+    end
+
+    it "should draw a vertically crossed filled polygon with 4 control points" do
+      subject.polygon('(2,2) (2,21) (21,2) (21,21)', ChunkyPNG::Color(:black), ChunkyPNG::Color(:red))
+      subject.should == reference_canvas('polygon_filled_horizontal')
+    end
+
+    it "should return itself to allow chaining" do
+      subject.polygon('(2,2) (20,5) (5,20)').should equal(subject)
+    end
+  end
+  
+  describe '#bezier_curve' do
+    subject { ChunkyPNG::Canvas.new(24, 24, ChunkyPNG::Color::WHITE) }
+    
+    it "should draw a bezier curve starting at the first point" do
+      subject.bezier_curve('3,20 10,10, 20,20')
+      subject[3, 20].should == ChunkyPNG::Color::BLACK
+    end
+    
+    it "should draw a bezier curve ending at the last point" do
+      subject.bezier_curve('3,20 10,10, 20,20')
+      subject[20, 20].should == ChunkyPNG::Color::BLACK
+    end
+    
+    it "should draw a bezier curve with a color of green" do
+      subject.bezier_curve('3,20 10,10, 20,20', :green)
+      subject[3, 20].should == ChunkyPNG::Color(:green)
+    end
+    
+    it "should draw a three point bezier curve" do
+      subject.bezier_curve('1,23 12,10 23,23').should == reference_canvas('bezier_three_point')
+    end
+    
+    it "should draw a three point bezier curve flipped" do
+      subject.bezier_curve('1,1 12,15 23,1').should == reference_canvas('bezier_three_point_flipped')
+    end
+    
+    it "should draw a four point bezier curve" do
+      subject.bezier_curve('1,23 1,5 22,5 22,23').should == reference_canvas('bezier_four_point')
+    end
+    
+    it "should draw a four point bezier curve flipped" do
+      subject.bezier_curve('1,1 1,19 22,19 22,1').should == reference_canvas('bezier_four_point_flipped')
+    end
+    
+    it "should draw a four point bezier curve with a shape of an s" do
+      subject.bezier_curve('1,23 1,5 22,23 22,5').should == reference_canvas('bezier_four_point_s')
+    end
+    
+    it "should draw a five point bezier curve" do
+      subject.bezier_curve('10,23 1,10 12,5 23,10 14,23').should == reference_canvas('bezier_five_point')
+    end
+    
+    it "should draw a six point bezier curve" do
+      subject.bezier_curve('1,23 4,15 8,20 2,2 23,15 23,1').should == reference_canvas('bezier_six_point')
+    end
+  end
+end

data/vendor/chunky_png/spec/chunky_png/canvas/masking_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas::Masking do
+  
+  subject { reference_canvas('clock') }
+
+  before(:all) do
+    @theme_color      = ChunkyPNG::Color('#e10f7a')
+    @new_color        = ChunkyPNG::Color('#ff0000')
+    @background_color = ChunkyPNG::Color('white')
+  end
+  
+  describe '#change_theme_color!' do
+    it "should change the theme color correctly" do
+      subject.change_theme_color!(@theme_color, @new_color)
+      subject.should == reference_canvas('clock_updated')
+    end
+  end
+  
+  describe '#extract_mask' do
+    it "should create the correct base and mask image" do
+      base, mask = subject.extract_mask(@theme_color, @background_color)
+      base.should == reference_canvas('clock_base')
+      mask.should == reference_canvas('clock_mask')
+    end
+    
+    it "should create a mask image with only one opaque color" do
+      base, mask = subject.extract_mask(@theme_color, @background_color)
+      mask.palette.opaque_palette.size.should == 1
+    end
+  end
+  
+  describe '#change_mask_color!' do
+    before { @mask = reference_canvas('clock_mask') }
+    
+    it "should replace the mask color correctly" do
+      @mask.change_mask_color!(@new_color)
+      @mask.should == reference_canvas('clock_mask_updated')
+    end
+    
+    it "should still only have one opaque color" do
+      @mask.change_mask_color!(@new_color)
+      @mask.palette.opaque_palette.size.should == 1
+    end
+    
+    it "should raise an exception when the mask image has more than once color" do
+      not_a_mask = reference_canvas('operations')
+      lambda { not_a_mask.change_mask_color!(@new_color) }.should raise_error(ChunkyPNG::ExpectationFailed)
+    end
+  end
+end

data/vendor/chunky_png/spec/chunky_png/canvas/operations_spec.rb

@@ -0,0 +1,388 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas::Operations do
+
+  subject { reference_canvas('operations') }
+
+  describe '#grayscale' do
+    it "should not return itself" do
+      subject.grayscale.should_not equal(subject)
+    end
+
+    it "should convert the image correctly" do
+      subject.grayscale.should == reference_canvas('operations_grayscale')
+    end
+
+    it "should not adjust the current image" do
+      lambda { subject.grayscale }.should_not change(subject, :pixels)
+    end
+  end
+
+  describe '#grayscale!' do
+    it "should return itself" do
+      subject.grayscale!.should equal(subject)
+    end
+
+    it "should convert the image correctly" do
+      subject.grayscale!
+      subject.should == reference_canvas('operations_grayscale')
+    end
+  end
+
+  describe '#crop' do
+    it "should crop the right pixels from the original canvas" do
+      subject.crop(10, 5, 4, 8).should == reference_canvas('cropped')
+    end
+
+    it "should not return itself" do
+      subject.crop(10, 5, 4, 8).should_not equal(subject)
+    end
+
+    it "should not adjust the current image" do
+      lambda { subject.crop(10, 5, 4, 8) }.should_not change(subject, :pixels)
+    end
+
+    it "should raise an exception when the cropped image falls outside the oiginal image" do
+      lambda { subject.crop(16, 16, 2, 2) }.should raise_error(ChunkyPNG::OutOfBounds)
+    end
+  end
+
+  describe '#crop!' do
+    it "should crop the right pixels from the original canvas" do
+      subject.crop!(10, 5, 4, 8)
+      subject.should == reference_canvas('cropped')
+    end
+
+    it "should have a new width and height" do
+      lambda { subject.crop!(10, 5, 4, 8) }.should change(subject, :dimension).
+          from(ChunkyPNG::Dimension('16x16')).
+          to(ChunkyPNG::Dimension('4x8'))
+    end
+
+    it "should raise an exception when the cropped image falls outside the oiginal image" do
+      lambda { subject.crop!(16, 16, 2, 2) }.should raise_error(ChunkyPNG::OutOfBounds)
+    end
+
+    it "should return itself" do
+      subject.crop!(10, 5, 4, 8).should equal(subject)
+    end
+  end
+
+  describe '#compose' do
+    it "should compose pixels correctly" do
+      subcanvas = ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75))
+      subject.compose(subcanvas, 8, 4).should == reference_canvas('composited')
+    end
+
+    it "should leave the original intact" do
+      subject.compose(ChunkyPNG::Canvas.new(1,1))
+      subject.should == reference_canvas('operations')
+    end
+
+    it "should not return itself" do
+      subject.compose(ChunkyPNG::Canvas.new(1,1)).should_not equal(subject)
+    end
+
+    it "should raise an exception when the pixels to compose fall outside the image" do
+      lambda { subject.compose(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
+    end
+  end
+
+  describe '#compose!' do
+    it "should compose pixels correctly" do
+      subcanvas = ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75))
+      subject.compose!(subcanvas, 8, 4)
+      subject.should == reference_canvas('composited')
+    end
+
+    it "should return itself" do
+      subject.compose!(ChunkyPNG::Canvas.new(1,1)).should equal(subject)
+    end
+
+    it "should compose a base image and mask correctly" do
+      base = reference_canvas('clock_base')
+      mask = reference_canvas('clock_mask_updated')
+      base.compose!(mask)
+      base.should == reference_canvas('clock_updated')
+    end
+
+    it "should raise an exception when the pixels to compose fall outside the image" do
+      lambda { subject.compose!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
+    end
+  end
+
+  describe '#replace' do
+    it "should replace the correct pixels" do
+      subcanvas = ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0))
+      subject.replace(subcanvas, 5, 4).should == reference_canvas('replaced')
+    end
+
+    it "should not return itself" do
+      subject.replace(ChunkyPNG::Canvas.new(1,1)).should_not equal(subject)
+    end
+
+    it "should leave the original intact" do
+      subject.replace(ChunkyPNG::Canvas.new(1,1))
+      subject.should == reference_canvas('operations')
+    end
+
+    it "should raise an exception when the pixels to replace fall outside the image" do
+      lambda { subject.replace(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
+    end
+  end
+
+  describe '#replace!' do
+    it "should replace the correct pixels" do
+      subcanvas = ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0))
+      subject.replace!(subcanvas, 5, 4)
+      subject.should == reference_canvas('replaced')
+    end
+
+    it "should return itself" do
+      subject.replace!(ChunkyPNG::Canvas.new(1,1)).should equal(subject)
+    end
+
+    it "should raise an exception when the pixels to replace fall outside the image" do
+      lambda { subject.replace!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
+    end
+  end
+end
+
+describe ChunkyPNG::Canvas::Operations do
+
+  subject { ChunkyPNG::Canvas.new(2, 3, [1, 2, 3, 4, 5, 6]) }
+
+  describe '#flip_horizontally!' do
+    it "should flip the pixels horizontally in place" do
+      subject.flip_horizontally!
+      subject.should == ChunkyPNG::Canvas.new(2, 3, [5, 6, 3, 4, 1, 2])
+    end
+
+    it "should return itself" do
+      subject.flip_horizontally!.should equal(subject)
+    end
+  end
+
+  describe '#flip_horizontally' do
+    it "should flip the pixels horizontally" do
+      subject.flip_horizontally.should == ChunkyPNG::Canvas.new(2, 3, [5, 6, 3, 4, 1, 2])
+    end
+
+    it "should not return itself" do
+      subject.flip_horizontally.should_not equal(subject)
+    end
+
+    it "should return a copy of itself when applied twice" do
+      subject.flip_horizontally.flip_horizontally.should == subject
+    end
+  end
+
+  describe '#flip_vertically!' do
+    it "should flip the pixels vertically" do
+      subject.flip_vertically!
+      subject.should == ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
+    end
+
+    it "should return itself" do
+      subject.flip_horizontally!.should equal(subject)
+    end
+  end
+
+  describe '#flip_vertically' do
+    it "should flip the pixels vertically" do
+      subject.flip_vertically.should == ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
+    end
+
+    it "should not return itself" do
+      subject.flip_horizontally.should_not equal(subject)
+    end
+
+    it "should return a copy of itself when applied twice" do
+      subject.flip_vertically.flip_vertically.should == subject
+    end
+  end
+
+  describe '#rotate_left' do
+    it "should rotate the pixels 90 degrees counter-clockwise" do
+      subject.rotate_left.should == ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5] )
+    end
+
+    it "should not return itself" do
+      subject.rotate_left.should_not equal(subject)
+    end
+
+    it "should not change the image dimensions" do
+      lambda { subject.rotate_left }.should_not change(subject, :dimension)
+    end
+
+    it "it should rotate 180 degrees when applied twice" do
+      subject.rotate_left.rotate_left.should == subject.rotate_180
+    end
+
+    it "it should rotate right when applied three times" do
+      subject.rotate_left.rotate_left.rotate_left.should == subject.rotate_right
+    end
+
+    it "should return itself when applied four times" do
+      subject.rotate_left.rotate_left.rotate_left.rotate_left.should == subject
+    end
+  end
+
+  describe '#rotate_left!' do
+    it "should rotate the pixels 90 degrees clockwise" do
+      subject.rotate_left!
+      subject.should == ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5] )
+    end
+
+    it "should return itself" do
+      subject.rotate_left!.should equal(subject)
+    end
+
+    it "should change the image dimensions" do
+      lambda { subject.rotate_left! }.should change(subject, :dimension).from(ChunkyPNG::Dimension('2x3')).to(ChunkyPNG::Dimension('3x2'))
+    end
+  end
+
+  describe '#rotate_right' do
+    it "should rotate the pixels 90 degrees clockwise" do
+      subject.rotate_right.should == ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2] )
+    end
+
+    it "should not return itself" do
+      subject.rotate_right.should_not equal(subject)
+    end
+
+    it "should not change the image dimensions" do
+      lambda { subject.rotate_right }.should_not change(subject, :dimension)
+    end
+
+    it "it should rotate 180 degrees when applied twice" do
+      subject.rotate_right.rotate_right.should == subject.rotate_180
+    end
+
+    it "it should rotate left when applied three times" do
+      subject.rotate_right.rotate_right.rotate_right.should == subject.rotate_left
+    end
+
+    it "should return itself when applied four times" do
+      subject.rotate_right.rotate_right.rotate_right.rotate_right.should == subject
+    end
+  end
+
+  describe '#rotate_right!' do
+    it "should rotate the pixels 90 degrees clockwise" do
+      subject.rotate_right!
+      subject.should == ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2] )
+    end
+
+    it "should return itself" do
+      subject.rotate_right!.should equal(subject)
+    end
+
+    it "should change the image dimensions" do
+      lambda { subject.rotate_right! }.should change(subject, :dimension).from(ChunkyPNG::Dimension('2x3')).to(ChunkyPNG::Dimension('3x2'))
+    end
+  end
+
+  describe '#rotate_180' do
+    it "should rotate the pixels 180 degrees" do
+      subject.rotate_180.should == ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
+    end
+
+    it "should return not itself" do
+      subject.rotate_180.should_not equal(subject)
+    end
+
+    it "should return a copy of itself when applied twice" do
+      subject.rotate_180.rotate_180.should == subject
+    end
+  end
+
+  describe '#rotate_180!' do
+    it "should rotate the pixels 180 degrees" do
+      subject.rotate_180!
+      subject.should == ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
+    end
+
+    it "should return itself" do
+      subject.rotate_180!.should equal(subject)
+    end
+  end
+end
+
+describe ChunkyPNG::Canvas::Operations do
+
+  subject { ChunkyPNG::Canvas.new(4, 4).rect(1, 1, 2, 2, 255, 255) }
+
+  describe "#trim" do
+    it "should trim the border" do
+      subject.trim.should == ChunkyPNG::Canvas.new(2, 2, 255)
+    end
+
+    it "should not return itself" do
+      subject.trim.should_not equal(subject)
+    end
+
+    it "should be able to fail to trim a specified color" do
+      lambda { subject.trim(ChunkyPNG::Color::BLACK) }.should_not change(subject, :pixels)
+    end
+
+    it "should be the same after trimming an added border" do
+      subject.border(2).trim.should == subject
+    end
+  end
+
+  describe "#trim!" do
+    it "should trim the border" do
+      subject.trim!
+      subject.should == ChunkyPNG::Canvas.new(2, 2, 255)
+    end
+
+    it "should return itself" do
+      subject.trim!.should equal(subject)
+    end
+
+    it "should change the image dimensions" do
+      lambda { subject.trim! }.should change(subject, :dimension).from(ChunkyPNG::Dimension('4x4')).to(ChunkyPNG::Dimension('2x2'))
+    end
+  end
+end
+
+describe ChunkyPNG::Canvas::Operations do
+
+  subject { ChunkyPNG::Canvas.new(4, 4) }
+
+  describe "#border" do
+    it "should add the border" do
+      subject.border(2).should == reference_canvas('operations_border')
+    end
+
+    it "should not return itself" do
+      subject.border(1).should_not equal(subject)
+    end
+
+    it "should retain transparency" do
+      ChunkyPNG::Canvas.new(1, 1).border(1).pixels.should include(0)
+    end
+  end
+
+  describe "#border!" do
+    it "should add the border" do
+      subject.border!(2)
+      subject.should == reference_canvas('operations_border')
+    end
+
+    it "should return itself" do
+      subject.border!(1).should equal(subject)
+    end
+
+    it "should retain transparency" do
+      subject.border!(1)
+      subject.pixels.should include(0)
+    end
+
+    it "should change the image dimensions" do
+      lambda { subject.border!(1) }.should change(subject, :dimension).from(ChunkyPNG::Dimension('4x4')).to(ChunkyPNG::Dimension('6x6'))
+    end
+  end
+end