prawn 0.13.0 → 2.4.0

data/spec/line_wrap_spec.rb

@@ -1,333 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "Core::Text::Formatted::LineWrap#wrap_line" do
-  before(:each) do
-    create_pdf
-    @arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
-    @line_wrap = Prawn::Text::Formatted::LineWrap.new
-    @one_word_width = 50
-  end
-  it "should strip leading 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 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_error 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_error(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 zero-width space" do
-    @pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
-    array = [{ :text => "hello#{Prawn::Text::ZWSP}world" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-    string.should == "hello"
-  end
-
-  it "should not display zero-width space" do
-    @pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
-    array = [{ :text => "hello#{Prawn::Text::ZWSP}world" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => 300,
-                                  :document => @pdf)
-    string.should == "helloworld"
-  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
-
-  it "should not break after a hyphen that follows white space and" +
-     "precedes a word" do
-    array = [{ :text => "hello -" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-    string.should == "hello -"
-
-    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 a soft hyphen" do
-    string = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}world")
-    array = [{ :text => string }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-    expected = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}")
-    expected.force_encoding("utf-8") if "".respond_to?(:force_encoding)
-    string.should == expected
-
-    @pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
-    @line_wrap = Prawn::Text::Formatted::LineWrap.new
-
-    string = "hello#{Prawn::Text::SHY}world"
-    array = [{ :text => string }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-    string.should == "hello#{Prawn::Text::SHY}"
-  end
-
-  it "should not display soft hyphens except at the end of a line" do
-    string = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}world")
-    array = [{ :text => string }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => 300,
-                                  :document => @pdf)
-    string.should == "helloworld"
-
-    @pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
-    @line_wrap = Prawn::Text::Formatted::LineWrap.new
-
-    string = "hello#{Prawn::Text::SHY}world"
-    array = [{ :text => string }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :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
-
-    array = [{ :text => "hello world" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => enough_width_for_hello_world,
-                                  :document => @pdf)
-    string.should == "hello world"
-
-    array = [{ :text => "hello world-" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => enough_width_for_hello_world,
-                                  :document => @pdf)
-    string.should == "hello"
-
-    @pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
-    @line_wrap = Prawn::Text::Formatted::LineWrap.new
-    enough_width_for_hello_world = 68
-
-    array = [{ :text => "hello world" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => enough_width_for_hello_world,
-                                  :document => @pdf)
-    string.should == "hello world"
-
-    array = [{ :text => "hello world-" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => enough_width_for_hello_world,
-                                  :document => @pdf)
-    string.should == "hello"
-  end
-
-  it "should not break after a hard hyphen that follows a soft hyphen and" +
-    "precedes a word" do
-    string = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}-")
-    array = [{ :text => string }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-    string.should == "hello-"
-
-    string = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}-world")
-    array = [{ :text => string }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-    expected = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}")
-    expected.force_encoding("utf-8") if "".respond_to?(:force_encoding)
-    string.should == expected
-
-    @pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
-    @line_wrap = Prawn::Text::Formatted::LineWrap.new
-
-    string = "hello#{Prawn::Text::SHY}-"
-    array = [{ :text => string }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-    string.should == "hello-"
-
-    string = "hello#{Prawn::Text::SHY}-world"
-    array = [{ :text => string }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-    string.should == "hello#{Prawn::Text::SHY}"
-  end
-end
-
-describe "Core::Text::Formatted::LineWrap#space_count" do
-  before(:each) do
-    create_pdf
-    @arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
-    @line_wrap = Prawn::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::LineWrap" do
-  before(:each) do
-    create_pdf
-    @arranger = Prawn::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::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
-
-describe "Core::Text::Formatted::LineWrap#paragraph_finished?" do
-  before(:each) do
-    create_pdf
-    @arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
-    @line_wrap = Prawn::Text::Formatted::LineWrap.new
-    @one_word_width = 50
-  end
-  it "should be_false when the last printed line is not the end of the paragraph" do
-    array = [{ :text => "hello world" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-
-    @line_wrap.paragraph_finished?.should == false
-  end
-  it "should be_true when the last printed line is the last fragment to print" do
-    array = [{ :text => "hello world" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-
-    @line_wrap.paragraph_finished?.should == true
-  end
-  it "should be_true when a newline exists on the current line" do
-    array = [{ :text => "hello\n world" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-
-    @line_wrap.paragraph_finished?.should == true
-  end
-  it "should be_true when a newline exists in the next fragment" do
-    array = [{ :text => "hello " },
-             { :text => " \n" },
-             { :text => "world" }]
-    @arranger.format_array = array
-    string = @line_wrap.wrap_line(:arranger => @arranger,
-                                  :width => @one_word_width,
-                                  :document => @pdf)
-
-    @line_wrap.paragraph_finished?.should == true
-  end
-end

data/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_within(0.000000001).of(2.834645669)
-    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

@@ -1,112 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-def tree_dump(tree)
-  if tree.is_a?(PDF::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)
-  PDF::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 = PDF::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 = PDF::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 = PDF::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 = PDF::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    @pdf.object_store.length.should == ref_count+2
-  end
-
-  it "should create a one new reference when subtree is split" do
-    node = PDF::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 == ref_count+1
-  end
-
-  it "should keep tree balanced when subtree split cascades to root" do
-    node = PDF::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 = PDF::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 = PDF::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3])
-    node.to_hash.should ==(
-      { :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 = PDF::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    node.to_hash.should ==({ :Kids => node.children.map { |child| child.ref } })
-  end
-
-  it "should emit :Limits and :Names keys with to_hash for leaf node" do
-    node = PDF::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    node.children.first.to_hash.should ==(
-      { :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 = PDF::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 ==(
-      { :Limits => %w(eight one),
-        :Kids => node.children.first.children.map { |child| child.ref } }
-    )
-  end
-end

data/spec/object_store_spec.rb

@@ -1,170 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "Prawn::ObjectStore" do
-  before(:each) do
-    @store = PDF::Core::ObjectStore.new
-  end
-
-  it "should create required roots by default, including info passed to new" do
-    store = PDF::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}/spec/data/curves.pdf"
-    store = PDF::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}/spec/data/curves.pdf"
-    store = PDF::Core::ObjectStore.new(:template => filename)
-    store.info.class.should == PDF::Core::Reference
-    store.root.class.should == PDF::Core::Reference
-  end
-
-  it "should initialize with pages when importing objects from an existing PDF" do
-    filename = "#{Prawn::BASEDIR}/spec/data/curves.pdf"
-    store = PDF::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::DATADIR}/pdfs/indirect_reference.pdf"
-    store = PDF::Core::ObjectStore.new(:template => filename)
-    store.size.should == 8
-  end
-
-  it "should raise_error ArgumentError when given a file that doesn exist as a template" do
-    filename = "not_really_there.pdf"
-
-    lambda { PDF::Core::ObjectStore.new(:template => filename) }.should raise_error(ArgumentError)
-  end
-
-  it "should raise_error PDF::Core::Errors::TemplateError when given a non PDF as a template" do
-    filename = "#{Prawn::DATADIR}/images/dice.png"
-
-    lambda { PDF::Core::ObjectStore.new(:template => filename) }.should raise_error(PDF::Core::Errors::TemplateError)
-  end
-
-  it "should raise_error PDF::Core::Errors::TemplateError when given an encrypted PDF as a template" do
-    filename = "#{Prawn::DATADIR}/pdfs/encrypted.pdf"
-
-    lambda { PDF::Core::ObjectStore.new(:template => filename) }.should raise_error(PDF::Core::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 = PDF::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 = PDF::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 = PDF::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 = PDF::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::DATADIR}/pdfs/hexagon.pdf"
-    store = PDF::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::DATADIR}/pdfs/two_hexagons.pdf"
-    store = PDF::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::DATADIR}/pdfs/two_hexagons.pdf"
-    store = PDF::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::DATADIR}/pdfs/nested_pages.pdf"
-    store = PDF::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::DATADIR}/pdfs/nested_pages.pdf"
-    store = PDF::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::DATADIR}/pdfs/hexagon.pdf"
-    store = PDF::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 = PDF::Core::ObjectStore.new
-    store.object_id_for_page(10).should == nil
-  end
-
-  it "should accept a stream instead of a filename" do
-    example = Prawn::Document.new()
-    example.text "An example doc, created in memory"
-    example.start_new_page
-    StringIO.open(example.render) do |stream|
-      @pdf = PDF::Core::ObjectStore.new(:template => stream)
-    end
-    @pdf.page_count.should == 2
-  end
-end