prawn-layout 0.3.2 → 0.7.1

data/vendor/prawn-core/spec/images_spec.rb

@@ -1,79 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
-
-describe "the image() function" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/pigs.jpg" 
-    create_pdf
-  end
-
-  it "should only embed an image once, even if it's added multiple times" do
-    @pdf.image @filename, :at => [100,100]
-    @pdf.image @filename, :at => [300,300]
-           
-    output = @pdf.render
-    images = PDF::Inspector::XObject.analyze(output)
-    # there should be 2 images in the page resources
-    images.page_xobjects.first.size.should == 2
-    # but only 1 image xobject
-    output.scan(/\/Type \/XObject/).size.should == 1
-  end  
-  
-  it "should return the image info object" do
-    info =  @pdf.image(@filename)
-    
-    info.should.be.kind_of(Prawn::Images::JPG)
-    
-    info.height.should == 453
-  end
-  
-  it "should accept IO objects" do
-    file = File.open(@filename, "rb")
-    info = @pdf.image(file)
-    
-    info.height.should == 453
-  end
-
-  it "should raise an UnsupportedImageType if passed a BMP" do
-    filename = "#{Prawn::BASEDIR}/data/images/tru256.bmp"
-    lambda { @pdf.image filename, :at => [100,100] }.should.raise(Prawn::Errors::UnsupportedImageType)
-  end
-
-  it "should raise an UnsupportedImageType if passed an interlaced PNG" do
-    filename = "#{Prawn::BASEDIR}/data/images/dice_interlaced.png"
-    lambda { @pdf.image filename, :at => [100,100] }.should.raise(Prawn::Errors::UnsupportedImageType)
-  end
-  
-  describe ":fit option" do
-    it "should fit inside the defined constraints" do
-      info = @pdf.image @filename, :fit => [100,400]
-      info.scaled_width.should <= 100
-      info.scaled_height.should <= 400
-
-      info = @pdf.image @filename, :fit => [400,100]
-      info.scaled_width.should <= 400
-      info.scaled_height.should <= 100
-
-      info = @pdf.image @filename, :fit => [604,453]
-      info.scaled_width.should == 604
-      info.scaled_height.should == 453
-    end
-    it "should move text position" do
-      @y = @pdf.y
-      info = @pdf.image @filename, :fit => [100,400]
-      @pdf.y.should < @y
-    end
-  end
-
-  describe ":at option" do
-    it "should not move text position" do
-      @y = @pdf.y
-      info = @pdf.image @filename, :at => [100,400]
-      @pdf.y.should == @y
-    end
-  end
-
-end
-

data/vendor/prawn-core/spec/jpg_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-# Spec'ing the PNG class. Not complete yet - still needs to check the
-# contents of palette and transparency to ensure they're correct.
-# Need to find files that have these sections first.
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
-
-describe "When reading a JPEG file" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/pigs.jpg"
-    @img_data = File.open(@filename, "rb") { |f| f.read }
-  end
-   
-  it "should read the basic attributes correctly" do
-    jpg = Prawn::Images::JPG.new(@img_data)
-    
-    jpg.width.should == 604
-    jpg.height.should == 453
-    jpg.bits.should == 8
-    jpg.channels.should == 3
-  end
-end
-

data/vendor/prawn-core/spec/measurement_units_spec.rb

@@ -1,23 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")           
-require "prawn/measurement_extensions"
-
-describe "Measurement units" do
-  
-  it "should convert units to PostScriptPoints" do
-    1.mm.should.be.close(2.834645669, 0.000000001)
-    1.mm.should == (72 / 25.4)
-    2.mm.should == (2 * 72 / 25.4)
-    3.mm.should == 3 * 72 / 25.4
-    -3.mm.should == -3 * 72/25.4
-    1.cm.should == 10 * 72 / 25.4
-    1.dm.should == 100 * 72 / 25.4
-    1.m.should == 1000 * 72 / 25.4
-    
-    1.in.should == 72
-    1.ft.should == 72 * 12
-    1.yd.should == 72 * 12 * 3
-    1.pt.should == 1
-  end
-  
-end
-  

data/vendor/prawn-core/spec/name_tree_spec.rb

@@ -1,112 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-def tree_dump(tree)
-  if tree.is_a?(Prawn::NameTree::Node)
-    "[" + tree.children.map { |child| tree_dump(child) }.join(",") + "]"
-  else
-    "#{tree.name}=#{tree.value}"
-  end
-end
-
-def tree_add(tree, *args)
-  args.each do |(name, value)|
-    tree.add(name, value)
-  end
-end
-
-def tree_value(name, value)
-  Prawn::NameTree::Value.new(name, value)
-end
-
-class RefExposingDocument < Prawn::Document
-  def object_store
-    @store
-  end
-end
-
-describe "Name Tree" do     
-  before(:each) { create_pdf(RefExposingDocument) }
-
-  it "should have no children when first initialized" do
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    node.children.length.should == 0
-  end
-
-  it "should have no subtrees while child limit is not reached" do
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3])
-    tree_dump(node).should == "[one=1,three=3,two=2]"
-  end
-
-  it "should split into subtrees when limit is exceeded" do
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    tree_dump(node).should == "[[four=4,one=1],[three=3,two=2]]"
-  end
-
-  it "should create a two new references when root is split" do
-    ref_count = @pdf.object_store.length
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    @pdf.object_store.length.should.equal ref_count+2
-  end
-  
-  it "should create a one new reference when subtree is split" do
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-
-    ref_count = @pdf.object_store.length # save when root is split
-    tree_add(node, ["five", 5], ["six", 6], ["seven", 7])
-    tree_dump(node).should == "[[five=5,four=4,one=1],[seven=7,six=6],[three=3,two=2]]"
-    @pdf.object_store.length.should.equal ref_count+1
-  end
-
-  it "should keep tree balanced when subtree split cascades to root" do
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    tree_add(node, ["five", 5], ["six", 6], ["seven", 7], ["eight", 8])
-    tree_dump(node).should == "[[[eight=8,five=5],[four=4,one=1]],[[seven=7,six=6],[three=3,two=2]]]"
-  end
-
-  it "should maintain order of already properly ordered nodes" do
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["eight", 8], ["five", 5], ["four", 4], ["one", 1])
-    tree_add(node, ['seven', 7], ['six', 6], ['three', 3], ['two', 2])
-    tree_dump(node).should == "[[[eight=8,five=5],[four=4,one=1]],[[seven=7,six=6],[three=3,two=2]]]"
-  end
-
-  it "should emit only :Names key with to_hash if root is only node" do
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3])
-    node.to_hash.should.equal(
-      { :Names => [tree_value("one", 1), tree_value("three", 3), tree_value("two", 2)] }
-    )
-  end
-
-  it "should emit only :Kids key with to_hash if root has children" do
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    node.to_hash.should.equal({ :Kids => node.children.map { |child| child.ref } })
-  end
-
-  it "should emit :Limits and :Names keys with to_hash for leaf node" do
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    node.children.first.to_hash.should.equal(
-      { :Limits => %w(four one),
-        :Names => [tree_value("four", 4), tree_value("one", 1)] }
-    )
-  end
-
-  it "should emit :Limits and :Kids keys with to_hash for inner node" do
-    node = Prawn::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    tree_add(node, ["five", 5], ["six", 6], ["seven", 7], ["eight", 8])
-    tree_add(node, ["nine", 9], ["ten", 10], ["eleven", 11], ["twelve", 12])
-    tree_add(node, ["thirteen", 13], ["fourteen", 14], ["fifteen", 15], ["sixteen", 16])
-    node.children.first.to_hash.should.equal(
-      { :Limits => %w(eight one),
-        :Kids => node.children.first.children.map { |child| child.ref } }
-    )
-  end
-end

data/vendor/prawn-core/spec/object_store_spec.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "Prawn::ObjectStore" do
-  before(:each) do
-    @store = Prawn::ObjectStore.new
-  end
-
-  it "should create required roots by default, including info passed to new" do
-    store = Prawn::ObjectStore.new(:Test => 3)
-    store.size.should == 3 # 3 default roots
-    store.info.data[:Test].should == 3
-    store.pages.data[:Count].should == 0
-    store.root.data[:Pages].should == store.pages
-  end
-
-  it "should add to its objects when ref() is called" do
-    count = @store.size
-    @store.ref("blah")
-    @store.size.should == count + 1
-  end
-
-  it "should accept push with a Prawn::Reference" do
-    r = Prawn::Reference(123, "blah")
-    @store.push(r)
-    @store[r.identifier].should == r
-  end
-
-  it "should accept arbitrary data and use it to create a Prawn::Reference" do
-    @store.push(123, "blahblah")
-    @store[123].data.should == "blahblah"
-  end
-
-  it "should be Enumerable, yielding in order of submission" do
-    # higher IDs to bypass the default roots
-    [10, 11, 12].each do |id|
-      @store.push(id, "some data #{id}")
-    end
-    @store.map{|ref| ref.identifier}[-3..-1].should == [10, 11, 12]
-  end
-end

data/vendor/prawn-core/spec/pdf_object_spec.rb

@@ -1,122 +0,0 @@
-# encoding: ASCII-8BIT
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-# See PDF Reference, Sixth Edition (1.7) pp51-60 for details 
-describe "PDF Object Serialization" do     
-              
-  it "should convert Ruby's nil to PDF null" do
-    Prawn::PdfObject(nil).should == "null"
-  end
-  
-  it "should convert Ruby booleans to PDF booleans" do
-    Prawn::PdfObject(true).should  == "true"
-    Prawn::PdfObject(false).should == "false"
-  end
-                                          
-  it "should convert a Ruby number to PDF number" do
-    Prawn::PdfObject(1).should == "1"
-    Prawn::PdfObject(1.214112421).should == "1.214112421" 
-  end
-  
-  it "should convert a Ruby time object to a PDF timestamp" do
-    t = Time.now
-    Prawn::PdfObject(t).should == t.strftime("(D:%Y%m%d%H%M%S%z").chop.chop + "'00')"
-  end
-  
-  it "should convert a Ruby string to PDF string when inside a content stream" do       
-    s = "I can has a string"
-    PDF::Inspector.parse(Prawn::PdfObject(s, true)).should == s
-  end                      
-
-  it "should convert a Ruby string to a UTF-16 PDF string when outside a content stream" do       
-    s = "I can has a string"
-    s_utf16 = "\xFE\xFF" + s.unpack("U*").pack("n*")
-    PDF::Inspector.parse(Prawn::PdfObject(s, false)).should == s_utf16
-  end                      
-
-  it "should pass through bytes regardless of content stream status for ByteString" do
-    Prawn::PdfObject(Prawn::ByteString.new("\xDE\xAD\xBE\xEF")).upcase.
-      should == "<DEADBEEF>"
-  end
-  
-  it "should escape parens when converting from Ruby string to PDF" do
-    s =  'I )(can has a string'      
-    PDF::Inspector.parse(Prawn::PdfObject(s, true)).should == s
-  end               
-  
-  it "should handle ruby escaped parens when converting to PDF string" do
-    s = 'I can \\)( has string'
-    PDF::Inspector.parse(Prawn::PdfObject(s, true)).should == s  
-  end      
-  
-  it "should convert a Ruby symbol to PDF name" do
-    Prawn::PdfObject(:my_symbol).should == "/my_symbol"
-    Prawn::PdfObject(:"A;Name_With−Various***Characters?").should ==
-     "/A;Name_With−Various***Characters?"
-  end
- 
-  it "should not convert a whitespace containing Ruby symbol to a PDF name" do
-    lambda { Prawn::PdfObject(:"My Symbol With Spaces") }.
-      should.raise(Prawn::Errors::FailedObjectConversion)
-  end    
-  
-  it "should convert a Ruby array to PDF Array when inside a content stream" do
-    Prawn::PdfObject([1,2,3]).should == "[1 2 3]"
-    PDF::Inspector.parse(Prawn::PdfObject([[1,2],:foo,"Bar"], true)).should ==  
-      [[1,2],:foo, "Bar"]
-  end  
-
-  it "should convert a Ruby array to PDF Array when outside a content stream" do
-    bar = "\xFE\xFF" + "Bar".unpack("U*").pack("n*")
-    Prawn::PdfObject([1,2,3]).should == "[1 2 3]"
-    PDF::Inspector.parse(Prawn::PdfObject([[1,2],:foo,"Bar"], false)).should ==  
-      [[1,2],:foo, bar]
-  end  
- 
-  it "should convert a Ruby hash to a PDF Dictionary when inside a content stream" do
-    dict = Prawn::PdfObject( {:foo  => :bar, 
-                              "baz" => [1,2,3], 
-                              :bang => {:a => "what", :b => [:you, :say] }}, true )     
-
-    res = PDF::Inspector.parse(dict)           
-
-    res[:foo].should == :bar
-    res[:baz].should == [1,2,3]
-    res[:bang].should == { :a => "what", :b => [:you, :say] }
-
-  end      
-
-  it "should convert a Ruby hash to a PDF Dictionary when outside a content stream" do
-    what = "\xFE\xFF" + "what".unpack("U*").pack("n*")
-    dict = Prawn::PdfObject( {:foo  => :bar, 
-                              "baz" => [1,2,3], 
-                              :bang => {:a => "what", :b => [:you, :say] }}, false )
-
-    res = PDF::Inspector.parse(dict)           
-
-    res[:foo].should == :bar
-    res[:baz].should == [1,2,3]
-    res[:bang].should == { :a => what, :b => [:you, :say] }
-
-  end      
-  
-  it "should not allow keys other than strings or symbols for PDF dicts" do
-    lambda { Prawn::PdfObject(:foo => :bar, :baz => :bang, 1 => 4) }.
-      should.raise(Prawn::Errors::FailedObjectConversion) 
-  end  
-  
-  it "should convert a Prawn::Reference to a PDF indirect object reference" do
-    ref = Prawn::Reference(1,true)
-    Prawn::PdfObject(ref).should == ref.to_s
-  end
-
-  it "should convert a NameTree::Node to a PDF hash" do
-    node = Prawn::NameTree::Node.new(Prawn::Document.new, 10)
-    node.add "hello", 1.0
-    node.add "world", 2.0
-    data = Prawn::PdfObject(node)
-    res = PDF::Inspector.parse(data)
-    res.should == {:Names => ["hello", 1.0, "world", 2.0]}
-  end
-end

data/vendor/prawn-core/spec/png_spec.rb

@@ -1,236 +0,0 @@
-# encoding: ASCII-8BIT
-
-# Spec'ing the PNG class. Not complete yet - still needs to check the
-# contents of palette and transparency to ensure they're correct.
-# Need to find files that have these sections first.
-#
-# see http://www.w3.org/TR/PNG/ for a detailed description of the PNG spec,
-# particuarly Table 11.1 for the different color types
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "When reading a greyscale PNG file (color type 0)" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/web-links.png"
-    @data_filename = "#{Prawn::BASEDIR}/data/images/web-links.dat"
-    @img_data = File.binread(@filename)
-  end
-
-  it "should read the attributes from the header chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-
-    png.width.should == 21
-    png.height.should == 14
-    png.bits.should == 8
-    png.color_type.should == 0
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
-  end
-
-  it "should read the image data chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-    data = File.binread(@data_filename)
-    png.img_data.should == data
-  end
-end
-
-describe "When reading a greyscale PNG file with transparency (color type 0)" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/ruport_type0.png"
-    @img_data = File.binread(@filename)
-  end
-
-  # In a greyscale type 0 PNG image, the tRNS chunk should contain a single value
-  # that indicates the color that should be interpreted as transparent.
-  #
-  # http://www.w3.org/TR/PNG/#11tRNS
-  it "should read the tRNS chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-    png.transparency[:grayscale].should == 255
-  end
-end
-
-describe "When reading an RGB PNG file (color type 2)" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/ruport.png"
-    @data_filename = "#{Prawn::BASEDIR}/data/images/ruport_data.dat"
-    @img_data = File.binread(@filename)
-  end
-
-  it "should read the attributes from the header chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-
-    png.width.should == 258
-    png.height.should == 105
-    png.bits.should == 8
-    png.color_type.should == 2
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
-  end
-
-  it "should read the image data chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-    data = File.binread(@data_filename)
-    png.img_data.should == data
-  end
-end
-
-describe "When reading an RGB PNG file with transparency (color type 2)" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/arrow2.png"
-    @img_data = File.binread(@filename)
-  end
-
-  # In a RGB type 2 PNG image, the tRNS chunk should contain a single RGB value
-  # that indicates the color that should be interpreted as transparent. In this
-  # case it's green.
-  #
-  # http://www.w3.org/TR/PNG/#11tRNS
-  it "should read the tRNS chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-    png.transparency[:rgb].should == [0, 255, 0]
-  end
-end
-
-# TODO: describe "When reading an indexed color PNG file wiih transparency (color type 3)"
-
-describe "When reading an indexed color PNG file (color type 3)" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/rails.png"
-    @data_filename = "#{Prawn::BASEDIR}/data/images/rails.dat"
-    @img_data = File.binread(@filename)
-  end
-
-  it "should read the attributes from the header chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-
-    png.width.should == 50
-    png.height.should == 64
-    png.bits.should == 8
-    png.color_type.should == 3
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
-  end
-
-  it "should read the image data chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-    data = File.binread(@data_filename)
-    png.img_data.should == data
-  end
-end
-
-describe "When reading a greyscale+alpha PNG file (color type 4)" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/page_white_text.png"
-    @data_filename = "#{Prawn::BASEDIR}/data/images/page_white_text.dat"
-    @alpha_data_filename = "#{Prawn::BASEDIR}/data/images/page_white_text.alpha"
-    @img_data = File.binread(@filename)
-  end
-
-  it "should read the attributes from the header chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-
-    png.width.should == 16
-    png.height.should == 16
-    png.bits.should == 8
-    png.color_type.should == 4
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
-  end
-
-  it "should correctly return the raw image data (with no alpha channel) from the image data chunk" do
-    png = Prawn::Images::PNG.new(@img_data)
-    png.split_alpha_channel!
-    data = File.binread(@data_filename)
-    png.img_data.should == data
-  end
-
-  it "should correctly extract the alpha channel data from the image data chunk" do
-    png = Prawn::Images::PNG.new(@img_data)
-    png.split_alpha_channel!
-    data = File.binread(@alpha_data_filename)
-    png.alpha_channel.should == data
-  end
-end
-
-describe "When reading an RGB+alpha PNG file (color type 6)" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/dice.png"
-    @data_filename = "#{Prawn::BASEDIR}/data/images/dice.dat"
-    @alpha_data_filename = "#{Prawn::BASEDIR}/data/images/dice.alpha"
-    @img_data = File.binread(@filename)
-  end
-
-  it "should read the attributes from the header chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-
-    png.width.should == 320
-    png.height.should == 240
-    png.bits.should == 8
-    png.color_type.should == 6
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
-  end
-
-  it "should correctly return the raw image data (with no alpha channel) from the image data chunk" do
-    png = Prawn::Images::PNG.new(@img_data)
-    png.split_alpha_channel!
-    data = File.binread(@data_filename)
-    png.img_data.should == data
-  end
-
-  it "should correctly extract the alpha channel data from the image data chunk" do
-    png = Prawn::Images::PNG.new(@img_data)
-    png.split_alpha_channel!
-    data = File.binread(@alpha_data_filename)
-    png.alpha_channel.should == data
-  end
-end
-
-describe "When reading a 16bit RGB+alpha PNG file (color type 6)" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/16bit.png"
-    @data_filename = "#{Prawn::BASEDIR}/data/images/16bit.dat"
-    @alpha_data_filename = "#{Prawn::BASEDIR}/data/images/16bit.alpha"
-    @img_data = File.binread(@filename)
-  end
-
-  it "should read the attributes from the header chunk correctly" do
-    png = Prawn::Images::PNG.new(@img_data)
-
-    png.width.should == 32
-    png.height.should == 32
-    png.bits.should == 16
-    png.color_type.should == 6
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
-  end
-
-  it "should correctly return the raw image data (with no alpha channel) from the image data chunk" do
-    png = Prawn::Images::PNG.new(@img_data)
-    png.split_alpha_channel!
-    data = File.binread(@data_filename)
-    png.img_data.should == data
-  end
-
-  it "should correctly extract the alpha channel data from the image data chunk" do
-    png = Prawn::Images::PNG.new(@img_data)
-    png.split_alpha_channel!
-    data = File.binread(@alpha_data_filename)
-    png.alpha_channel.should == data
-  end
-end