piglop-prawn 0.10.2.1

data/spec/line_wrap_spec.rb

@@ -0,0 +1,341 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "Core::Text::LineWrap#wrap_line" do
+  before(:each) do
+    create_pdf
+    @line_wrap = Prawn::Core::Text::LineWrap.new
+  end
+  it "should strip preceding and trailing spaces" do
+    string = @line_wrap.wrap_line("    hello world    ",
+                                 :width => 300,
+                                 :document => @pdf)
+    string.should == "hello world"
+  end
+
+  it "should raise CannotFit if a too-small width is given" do
+    lambda do
+      @line_wrap.wrap_line("    hello world    ",
+                          :width => 1,
+                          :document => @pdf)
+    end.should.raise(Prawn::Errors::CannotFit)
+  end
+end
+
+describe "Core::Text::LineWrap#wrap_line" do
+  before(:each) do
+    create_pdf
+    @line_wrap = Prawn::Core::Text::LineWrap.new
+    @one_word_width = 50
+  end
+  it "should break on space" do
+    normalized_string = @pdf.font.normalize_encoding("hello world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => @one_word_width,
+                                 :document => @pdf)
+    string.should == "hello"
+  end
+
+  it "should break on tab" do
+    normalized_string = @pdf.font.normalize_encoding("hello\tworld")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => @one_word_width,
+                                 :document => @pdf)
+    string.should == "hello"
+  end
+
+  it "should break on hyphens" do
+    normalized_string = @pdf.font.normalize_encoding("hello-world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => @one_word_width,
+                                 :document => @pdf)
+    string.should == "hello-"
+  end
+
+  it "should not break after a hyphen that follows white space and" +
+     "precedes a word" do
+    normalized_string = @pdf.font.normalize_encoding("hello -")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => @one_word_width,
+                                 :document => @pdf)
+    string.should == "hello -"
+
+    normalized_string = @pdf.font.normalize_encoding("hello -world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => @one_word_width,
+                                 :document => @pdf)
+    string.should == "hello"
+  end
+
+  it "should break on a soft hyphen" do
+    normalized_string = @pdf.font.normalize_encoding("hello­world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => @one_word_width,
+                                 :document => @pdf)
+    string.should == @pdf.font.normalize_encoding("hello­")
+
+
+    @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
+    @line_wrap = Prawn::Core::Text::LineWrap.new
+
+    normalized_string = @pdf.font.normalize_encoding("hello­world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => @one_word_width,
+                                 :document => @pdf)
+    string.should == @pdf.font.normalize_encoding("hello­")
+  end
+
+  it "should not display soft hyphens except at the end of a line" do
+    normalized_string = @pdf.font.normalize_encoding("hello­world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => 300,
+                                 :document => @pdf)
+    string.should == "helloworld"
+
+
+    @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
+    @line_wrap = Prawn::Core::Text::LineWrap.new
+
+    normalized_string = @pdf.font.normalize_encoding("hello­world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => 300,
+                                 :document => @pdf)
+    string.should == "helloworld"
+  end
+
+  it "should not break before a hard hyphen that follows a word" do
+    enough_width_for_hello_world = 60
+    normalized_string = @pdf.font.normalize_encoding("hello world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => enough_width_for_hello_world,
+                                 :document => @pdf)
+    string.should == @pdf.font.normalize_encoding("hello world")
+
+    normalized_string = @pdf.font.normalize_encoding("hello world-")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => enough_width_for_hello_world,
+                                 :document => @pdf)
+    string.should == @pdf.font.normalize_encoding("hello")
+
+    @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
+    @line_wrap = Prawn::Core::Text::LineWrap.new
+    enough_width_for_hello_world = 68
+
+    normalized_string = @pdf.font.normalize_encoding("hello world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => enough_width_for_hello_world,
+                                 :document => @pdf)
+    string.should == @pdf.font.normalize_encoding("hello world")
+
+    normalized_string = @pdf.font.normalize_encoding("hello world-")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => enough_width_for_hello_world,
+                                 :document => @pdf)
+    string.should == @pdf.font.normalize_encoding("hello")
+  end
+
+  it "should not break after a hard hyphen that follows a soft hyphen and" +
+     "precedes a word" do
+    normalized_string = @pdf.font.normalize_encoding("hello­-")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => @one_word_width,
+                                 :document => @pdf)
+    string.should == @pdf.font.normalize_encoding("hello-")
+
+    normalized_string = @pdf.font.normalize_encoding("hello­-world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => @one_word_width,
+                                 :document => @pdf)
+    string.should == @pdf.font.normalize_encoding("hello­")
+
+    @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
+    @line_wrap = Prawn::Core::Text::LineWrap.new
+
+    normalized_string = @pdf.font.normalize_encoding("hello­-world")
+    string = @line_wrap.wrap_line(normalized_string,
+                                 :width => @one_word_width,
+                                 :document => @pdf)
+    string.should == @pdf.font.normalize_encoding("hello­")
+  end
+end
+
+describe "Core::Text::LineWrap#consumed_char_count" do
+  before(:each) do
+    create_pdf
+    @line_wrap = Prawn::Core::Text::LineWrap.new
+  end
+  it "should return the total number of characters incorporated into" +
+     " or deleted from the last line" do
+    string = @line_wrap.wrap_line("    hello world    ",
+                                 :width => 300,
+                                 :document => @pdf)
+    @line_wrap.consumed_char_count.should == 19
+  end
+end
+
+describe "Core::Text::LineWrap#width" do
+  before(:each) do
+    create_pdf
+    @line_wrap = Prawn::Core::Text::LineWrap.new
+  end
+  it "should return the width of the last wrapped line" do
+    @line_wrap.wrap_line("hello world" * 10,
+                        :width => 300,
+                        :document => @pdf)
+    @line_wrap.width.should.be > 0
+    @line_wrap.width.should.be <= 300
+  end
+end
+
+describe "Core::Text::LineWrap#space_count" do
+  before(:each) do
+    create_pdf
+    @line_wrap = Prawn::Core::Text::LineWrap.new
+  end
+  it "should return the number of spaces in the last wrapped line" do
+    @line_wrap.wrap_line("hello world, goobye",
+                        :width => 300,
+                        :document => @pdf)
+    @line_wrap.space_count.should == 2
+  end
+  it "should exclude trailing spaces from the count" do
+    @line_wrap.wrap_line("hello world, goobye  ",
+                        :width => 300,
+                        :document => @pdf)
+    @line_wrap.space_count.should == 2
+  end
+end
+
+describe "Core::Text::Formatted::Wrap#line_wrap" do
+  before(:each) do
+    create_pdf
+    @arranger = Prawn::Core::Text::Formatted::Arranger.new(@pdf)
+    @line_wrap = Prawn::Core::Text::Formatted::LineWrap.new
+    @one_word_width = 50
+  end
+  it "should strip preceding and trailing spaces" do
+    array = [{ :text => " hello world, " },
+             { :text => "goodbye  ", :style => [:bold] }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                 :width => 300,
+                                 :document => @pdf)
+    string.should == "hello world, goodbye"
+  end
+  it "should strip trailing spaces when we try but fail to push any of a" +
+     " fragment onto the end of a line that currently ends with a space" do
+    array = [{ :text => "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " },
+             { :text => "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb ", :style => [:bold] }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                 :width => 300,
+                                 :document => @pdf)
+    string.should == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+  end
+  it "should strip trailing spaces when a white-space-only fragment was" +
+     " successfully pushed onto the end of a line but no other non-white" +
+     " space fragment fits after it" do
+    array = [{ :text => "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " },
+             { :text => "  ", :style => [:bold] },
+             { :text => " bbbbbbbbbbbbbbbbbbbbbbbbbbbb" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                 :width => 300,
+                                 :document => @pdf)
+    string.should == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+  end
+  it "should raise CannotFit if a too-small width is given" do
+    array = [{ :text => " hello world, " },
+             { :text => "goodbye  ", :style => [:bold] }]
+    @arranger.format_array = array
+    lambda do
+      @line_wrap.wrap_line(:arranger => @arranger,
+                           :width => 1,
+                           :document => @pdf)
+    end.should.raise(Prawn::Errors::CannotFit)
+  end
+
+  it "should break on space" do
+    array = [{ :text => "hello world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+    string.should == "hello"
+  end
+
+  it "should break on tab" do
+    array = [{ :text => "hello\tworld" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+    string.should == "hello"
+  end
+
+  it "should break on hyphens" do
+    array = [{ :text => "hello-world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+    string.should == "hello-"
+  end
+end
+
+describe "Core::Text::Formatted::Wrap#space_count" do
+  before(:each) do
+    create_pdf
+    @arranger = Prawn::Core::Text::Formatted::Arranger.new(@pdf)
+    @line_wrap = Prawn::Core::Text::Formatted::LineWrap.new
+  end
+  it "should return the number of spaces in the last wrapped line" do
+    array = [{ :text => "hello world, " },
+             { :text => "goodbye", :style => [:bold] }]
+    @arranger.format_array = array
+    @line_wrap.wrap_line(:arranger => @arranger,
+                        :width => 300,
+                        :document => @pdf)
+    @line_wrap.space_count.should == 2
+  end
+  it "should exclude preceding and trailing spaces from the count" do
+    array = [{ :text => " hello world, " },
+             { :text => "goodbye  ", :style => [:bold] }]
+    @arranger.format_array = array
+    @line_wrap.wrap_line(:arranger => @arranger,
+                        :width => 300,
+                        :document => @pdf)
+    @line_wrap.space_count.should == 2
+  end
+end
+
+describe "Core::Text::Formatted::Wrap" do
+  before(:each) do
+    create_pdf
+    @arranger = Prawn::Core::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello\nworld\n\n\nhow are you?" },
+             { :text => "\n" },
+             { :text => "\n" },
+             { :text => "" },
+             { :text => "fine, thanks. " * 4 },
+             { :text => "" },
+             { :text => "\n" },
+             { :text => "" }]
+    @arranger.format_array = array
+    @line_wrap = Prawn::Core::Text::Formatted::LineWrap.new
+  end
+  it "should only return an empty string if nothing fit or there" +
+     "was nothing to wrap" do
+    8.times do
+      line = @line_wrap.wrap_line(:arranger => @arranger,
+                                 :width => 200,
+                                 :document => @pdf)
+      line.should.not.be.empty
+    end
+    line = @line_wrap.wrap_line(:arranger => @arranger,
+                               :width => 200,
+                               :document => @pdf)
+    line.should.be.empty
+  end
+end

data/spec/measurement_units_spec.rb

@@ -0,0 +1,23 @@
+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/spec/name_tree_spec.rb

@@ -0,0 +1,112 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+def tree_dump(tree)
+  if tree.is_a?(Prawn::Core::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::Core::NameTree::Value.new(name, value)
+end
+
+class RefExposingDocument < Prawn::Document
+  def object_store
+    state.store
+  end
+end
+
+describe "Name Tree" do     
+  before(:each) { create_pdf(RefExposingDocument) }
+
+  it "should have no children when first initialized" do
+    node = Prawn::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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/spec/object_store_spec.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "Prawn::ObjectStore" do
+  before(:each) do
+    @store = Prawn::Core::ObjectStore.new
+  end
+
+  it "should create required roots by default, including info passed to new" do
+    store = Prawn::Core::ObjectStore.new(:info => {: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 import objects from an existing PDF" do
+    filename = "#{Prawn::BASEDIR}/reference_pdfs/curves.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.size.should == 5
+  end
+
+  it "should point to existing roots when importing objects from an existing PDF" do
+    filename = "#{Prawn::BASEDIR}/reference_pdfs/curves.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.info.class.should == Prawn::Core::Reference
+    store.root.class.should == Prawn::Core::Reference
+  end
+
+  it "should initialize with pages when importing objects from an existing PDF" do
+    filename = "#{Prawn::BASEDIR}/reference_pdfs/curves.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.pages.data[:Count].should == 1
+  end
+
+  it "should import all objects from a PDF that has an indirect reference in a stream dict" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/indirect_reference.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.size.should == 8
+  end
+
+  it "should raise ArgumentError when given a file that doesn exist as a template" do
+    filename = "not_really_there.pdf"
+
+    lambda { Prawn::Core::ObjectStore.new(:template => filename) }.should.raise(ArgumentError)
+  end
+
+  it "should raise Prawn::Errors::TemplateError when given a non PDF as a template" do
+    filename = "#{Prawn::BASEDIR}/data/images/dice.png"
+
+    lambda { Prawn::Core::ObjectStore.new(:template => filename) }.should.raise(Prawn::Errors::TemplateError)
+  end
+
+  it "should raise Prawn::Errors::TemplateError when given an encrypted PDF as a template" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/encrypted.pdf"
+
+    lambda { Prawn::Core::ObjectStore.new(:template => filename) }.should.raise(Prawn::Errors::TemplateError)
+  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::Core::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
+
+describe "Prawn::ObjectStore#compact" do
+  it "should do nothing to an ObjectStore with all live refs" do
+    store = Prawn::Core::ObjectStore.new
+    store.info.data[:Blah] = store.ref(:some => "structure")
+    old_size = store.size
+    store.compact
+
+    store.size.should == old_size
+  end
+
+  it "should remove dead objects, renumbering live objects from 1" do
+    store = Prawn::Core::ObjectStore.new
+    store.ref(:some => "structure")
+    old_size = store.size
+    store.compact
+    
+    store.size.should.be < old_size
+    store.map{ |o| o.identifier }.should == (1..store.size).to_a
+  end
+
+  it "should detect and remove dead objects that were once live" do
+    store = Prawn::Core::ObjectStore.new
+    store.info.data[:Blah] = store.ref(:some => "structure")
+    store.info.data[:Blah] = :overwritten
+    old_size = store.size
+    store.compact
+    
+    store.size.should.be < old_size
+    store.map{ |o| o.identifier }.should == (1..store.size).to_a
+  end
+end
+
+describe "Prawn::ObjectStorie#object_id_for_page" do
+  it "should return the object ID of an imported template page" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/hexagon.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(0).should == 4
+  end
+
+  it "should return the object ID of the first imported template page" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/two_hexagons.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(1).should == 4
+  end
+
+  it "should return the object ID of the last imported template page" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/two_hexagons.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(-1).should == 6
+  end
+
+  it "should return the object ID of the first page of a template that uses nested Pages" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/nested_pages.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(1).should == 5
+  end
+
+  it "should return the object ID of the last page of a template that uses nested Pages" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/nested_pages.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(-1).should == 8
+  end
+
+  it "should return nil if given an invalid page number" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/hexagon.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(10).should == nil
+  end
+
+  it "should return nil if given an invalid page number" do
+    store = Prawn::Core::ObjectStore.new
+    store.object_id_for_page(10).should == nil
+  end
+end