bench9000 0.1

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

@@ -0,0 +1,59 @@
+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')
+    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    
+  end
+
+  describe '#to_rgb_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_rgb_stream.should == [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')
+    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    
+
+    
+    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    
+  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*')
+    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')
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas do
+
+  describe '.from_rgb_stream' 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')
+      end
+    end
+  end
+
+  describe '.from_bgr_stream' 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')
+      end
+    end
+  end
+
+  describe '.from_rgba_stream' 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')
+      end
+    end
+  end
+end

data/vendor/chunky_png/spec/chunky_png/canvas_spec.rb

@@ -0,0 +1,226 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas do
+
+  subject { ChunkyPNG::Canvas.new(1, 1, ChunkyPNG::Color::WHITE) }
+
+  it { should respond_to(:width) }
+  it { should respond_to(:height) }
+  it { should respond_to(:pixels) }
+
+  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')
+    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)
+    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
+    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)      
+    end
+    
+    it "should use a transparent background by default" do
+      canvas = ChunkyPNG::Canvas.new(1, 1)
+      canvas[0,0].should == ChunkyPNG::Color::TRANSPARENT
+    end
+  end
+
+  describe '#dimension' do
+    it "should return the dimensions as a Dimension instance" do
+      subject.dimension.should == 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
+    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
+    
+    it "should accept strings, arrays, hashes and points as well" do
+      subject.should     include('0, 0')
+      subject.should_not include('0, 1')
+      subject.should     include([0, 0])
+      subject.should_not include([0, 1])
+      subject.should     include(:y => 0, :x => 0)
+      subject.should_not include(:y => 1, :x => 0)
+      subject.should     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
+    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
+    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
+    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)
+    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
+    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)
+    end
+  end
+  
+  describe '#[]' do
+    it "should return the pixel value if the coordinates are within bounds" do
+      subject[0, 0].should == ChunkyPNG::Color::WHITE
+    end
+    
+    it "should assert the coordinates to be within bounds" do
+      subject.should_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
+    end
+    
+    it "should not assert nor check the coordinates" do
+      subject.should_not_receive(:assert_xy!)
+      subject.should_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)
+    end
+    
+    it "should assert the bounds of the image" do
+      subject.should_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)
+    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?)
+      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)
+    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)
+      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
+    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)
+    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]
+    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)
+    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]
+    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).
+          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).
+          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)
+    end
+  end
+end

data/vendor/chunky_png/spec/chunky_png/color_spec.rb

@@ -0,0 +1,251 @@
+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)
+  end
+  
+  it "should interpret 3 arguments as RGBA values" do
+    ChunkyPNG::Color(1, 2, 3).should == 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
+  end
+  
+  it "should interpret 1 argument as a color to parse" do
+    ChunkyPNG::Color.should_receive(:parse).with('0x0a649664')
+    ChunkyPNG::Color('0x0a649664')
+  end
+end
+
+describe ChunkyPNG::Color do
+  include ChunkyPNG::Color
+
+  before(:each) do
+    @white             = 0xffffffff
+    @black             = 0x000000ff
+    @opaque            = 0x0a6496ff
+    @non_opaque        = 0x0a649664
+    @fully_transparent = 0x0a649600
+  end
+  
+  describe '#parse' do
+    it "should interpret a hex string correctly" do
+      parse('0x0a649664').should == 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
+    end
+    
+    it "should return numbers as is" do
+      parse('12345').should == 12345
+      parse(12345).should == 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
+    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
+    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
+    end
+  end
+  
+  describe '#pass_bytesize' do
+    it "should calculate a pass size correctly" do
+      pass_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8, 10, 10).should == 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
+    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
+    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
+    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
+    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
+    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
+    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
+    end
+    
+    it "should raise for an unkown color name" do
+      lambda { html_color(:nonsense) }.should 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
+    end
+  end
+  
+  describe 'extractiion 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
+    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
+    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)
+    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
+    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'
+    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'
+    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]
+    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
+    end
+
+    it "should use the foregorund color as is when an opaque color is given as foreground color" do
+      compose(@opaque, @white).should == @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
+    end
+
+    it "should compose pixels correctly with both algorithms" do
+      compose_quick(@non_opaque, @white).should   == 0x9fc2d6ff
+      compose_precise(@non_opaque, @white).should == 0x9fc2d6ff
+    end
+  end
+  
+  describe '#decompose_alpha' do
+    it "should decompose the alpha channel correctly" do
+      decompose_alpha(0x9fc2d6ff, @opaque, @white).should == 0x00000064
+    end
+    
+    it "should return fully transparent if the background channel matches the resulting color" do
+      decompose_alpha(0xabcdefff, 0xff000000, 0xabcdefff).should == 0x00
+    end
+    
+    it "should return fully opaque if the background channel matches the mask color" do
+      decompose_alpha(0xff000000, 0xabcdefff, 0xabcdefff).should == 0xff
+    end
+    
+    it "should return fully opaque if the resulting color matches the mask color" do
+      decompose_alpha(0xabcdefff, 0xabcdefff, 0xffffffff).should == 255
+    end    
+  end
+  
+  describe '#blend' do
+    it "should blend colors correctly" do
+      blend(@opaque, @black).should == 0x05324bff
+    end
+    
+    it "should not matter what color is used as foreground, and what as background" do
+      blend(@opaque, @black).should == blend(@black, @opaque)
+    end
+  end
+end
+