eideticpdf 0.9.9

data/test/test_epdfo.rb

@@ -0,0 +1,762 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brent Rowland on 2007-07-14.
+#  Copyright (c) 2007, Eidetic Software. All rights reserved.
+
+$: << File.dirname(__FILE__) + '/../lib'
+require 'test/unit'
+require 'epdfo'
+
+include EideticPDF::PdfObjects
+
+class HeaderTestCases < Test::Unit::TestCase
+  def setup
+    @header = Header.new
+    @header11 = Header.new(1.1)
+  end
+
+  def test_to_s
+    assert_equal("%PDF-1.3\n", @header.to_s)
+    assert_equal("%PDF-1.1\n", @header11.to_s)
+  end
+end
+
+class IndirectObjectRefTestCases < Test::Unit::TestCase
+  def test_to_s
+    io = IndirectObject.new(1,0)
+    ior = IndirectObjectRef.new(io)
+    assert_equal("1 0 R ", ior.to_s)
+  end
+end
+
+class IndirectObjectTestCases < Test::Unit::TestCase
+  def setup
+    @io = IndirectObject.new(1,0)
+  end
+
+  def test_header
+    assert_equal("1 0 obj\n", @io.header)
+  end
+
+  def test_body
+    assert_equal('', @io.body)
+  end
+
+  def test_footer
+    assert_equal("endobj\n", @io.footer)
+  end
+
+  def test_to_s
+    assert_equal("1 0 obj\n" + "endobj\n", @io.to_s)
+  end
+end
+
+class PdfBooleanTestCases < Test::Unit::TestCase
+  def setup
+    @t = PdfBoolean.new(true)
+    @f = PdfBoolean.new(false)
+  end
+
+  def test_to_s
+    assert_equal('true ', @t.to_s)
+    assert_equal('false ', @f.to_s)
+  end
+end
+
+class PdfIntegerTestCases < Test::Unit::TestCase
+  def test_to_s
+    seven = PdfInteger.new(7)
+    assert_equal('7 ', seven.to_s)
+  end
+
+  def test_ary1
+    a = PdfInteger.ary([1, 2, 3])
+    assert_equal("[1 2 3 ] ", a.to_s)
+  end
+
+  def test_ary2
+    a = PdfInteger.ary([1, 2, [3, 4]])
+    assert_equal("[1 2 [3 4 ] ] ", a.to_s)
+  end
+end
+
+class PdfRealTestCases < Test::Unit::TestCase
+  def test_to_s
+    five_five = PdfReal.new(5.5)
+    assert_equal('5.5 ', five_five.to_s)
+  end
+end
+
+class PdfStringTestCases < Test::Unit::TestCase
+  def test_to_s
+    string = PdfString.new('a\b(cd)')
+    assert_equal(%q/(a\\\\b\(cd\)) /, string.to_s)
+  end
+
+  def test_escape
+    assert_equal('a\\\\b\(cd\)', PdfString.escape('a\\b(cd)'))
+  end
+end
+
+class PdfNameTestCases < Test::Unit::TestCase
+  def test_to_s
+    name = PdfName.new('name')
+    assert_equal('/name ', name.to_s)
+  end
+end
+
+class PdfArrayTestCases < Test::Unit::TestCase
+  def setup
+    @ary1 = PdfArray.new([1, 2, 3, 4, 5])
+    @ary2 = PdfArray.new([1, 2, 3, 4, 5], 3)
+  end
+
+  def test_to_s
+    assert_equal("[12345] ", @ary1.to_s)
+    assert_equal("[123\n45] ", @ary2.to_s)
+  end
+end
+
+class PdfDictionaryTestCases < Test::Unit::TestCase
+  def test_to_s
+    h = {
+      PdfName.new('foo') => PdfString.new('bar'),
+      PdfName.new('baz') => PdfInteger.new(7)
+    }
+    d = PdfDictionary.new(h)
+    assert_equal("<<\n/baz 7 \n/foo (bar) \n>>\n", d.to_s)
+  end
+end
+
+class PdfDictionaryObjectTestCases < Test::Unit::TestCase
+  def test_body
+    h = {
+      'foo' => PdfString.new('bar'),
+      'baz' => PdfInteger.new(7)
+    }
+    pdo = PdfDictionaryObject.new(1,0,h)
+    assert_equal("<<\n/baz 7 \n/foo (bar) \n>>\n", pdo.body)
+  end
+end
+
+class PdfStreamTestCases < Test::Unit::TestCase
+  def setup
+    @ps = PdfStream.new(1,0,'test')
+#    @ps.length = 4
+    @ps.filter = 'bogus'
+  end
+
+  def test_length
+    assert_equal(PdfInteger.new(4), @ps.dictionary['Length'])
+  end
+
+  def test_filter
+    assert_equal(PdfName.new('bogus'), @ps.dictionary['Filter'])
+  end
+
+  def test_body
+    assert_equal("<<\n/Filter /bogus \n/Length 4 \n>>\nstream\ntestendstream\n", @ps.body)
+  end
+
+  def test_to_s
+    assert_equal("1 0 obj\n<<\n/Filter /bogus \n/Length 4 \n>>\nstream\ntestendstream\nendobj\n", @ps.to_s)
+  end
+end
+
+class PdfNullTestCases < Test::Unit::TestCase
+  def test_to_s
+    null = PdfNull.new
+    assert_equal("null ", null.to_s)
+  end
+end
+
+class InUseXRefEntryTestCases < Test::Unit::TestCase
+  def test_to_s
+    entry = InUseXRefEntry.new(500,0)
+    assert_equal("0000000500 00000 n\n", entry.to_s)
+  end
+end
+
+class FreeXRefEntryTestCases < Test::Unit::TestCase
+  def test_to_s
+    entry = FreeXRefEntry.new(1,0)
+    assert_equal("0000000001 00000 f\n", entry.to_s)
+  end
+end
+
+class XRefSubSectionTestCases < Test::Unit::TestCase
+  def setup
+    @sub_section = XRefSubSection.new
+    @sub_section << InUseXRefEntry.new(0,0)
+    @sub_section << InUseXRefEntry.new(100,1)
+  end
+
+  def test_to_s
+    assert_equal("0 3\n0000000000 65535 f\n0000000000 00000 n\n0000000100 00001 n\n", @sub_section.to_s)
+  end
+end
+
+class XRefTableTestCases < Test::Unit::TestCase
+  def setup
+    @table = XRefTable.new
+    @sub_section = XRefSubSection.new
+    @sub_section << InUseXRefEntry.new(0,0)
+    @sub_section << InUseXRefEntry.new(100,1)
+    @table << @sub_section
+  end
+
+  def test_to_s
+    assert_equal("xref\n0 3\n0000000000 65535 f\n0000000000 00000 n\n0000000100 00001 n\n", @table.to_s)
+  end
+end
+
+class BodyTestCases < Test::Unit::TestCase
+  def setup
+    @io_int = IndirectObject.new(1,0,PdfInteger.new(7))
+    @io_str = IndirectObject.new(2,0,PdfString.new("Hello"))
+    @body = Body.new
+  end
+
+  def test_write_and_xref
+    @body << @io_int << @io_str
+    s = ''
+    sub_section = XRefSubSection.new
+    @body.write_and_xref(s, sub_section)
+    assert_equal(@io_int.to_s + @io_str.to_s, s)
+    assert_equal("0 3\n0000000000 65535 f\n0000000000 00000 n\n0000000018 00000 n\n", sub_section.to_s)
+  end
+end
+
+class PdfCatalogTestCases < Test::Unit::TestCase
+  def setup
+    @pages = PdfPages.new(1, 0)
+    @outlines = PdfOutlines.new(2, 0)
+    @cat = PdfCatalog.new(3, 0, :use_none, @pages, @outlines)
+  end
+
+  def test_to_s
+    assert_equal("3 0 obj\n<<\n/Outlines 2 0 R \n/PageMode /UseNone \n/Pages 1 0 R \n/Type /Catalog \n>>\nendobj\n", @cat.to_s)
+  end
+end
+
+class TrailerTestCases < Test::Unit::TestCase
+  def setup
+    @trailer = Trailer.new
+    @trailer.xref_table_start = 0
+    @trailer.xref_table_size = 3
+  end
+
+  def test_xref_table_size
+    assert_equal(3, @trailer.xref_table_size)
+    assert_equal(3, @trailer['Size'].value)
+  end
+
+  def test_to_s
+    assert_equal("trailer\n<<\n/Size 3 \n>>\nstartxref\n0\n%%EOF\n", @trailer.to_s)
+  end
+end
+
+class RectangleTestCases < Test::Unit::TestCase
+  def setup
+    @rect = Rectangle.new(1,2,3,4)
+  end
+
+  def test_attributes
+    assert_equal(1, @rect.x1)
+    assert_equal(2, @rect.y1)
+    assert_equal(3, @rect.x2)
+    assert_equal(4, @rect.y2)
+  end
+
+  def test_to_s
+    assert_equal("[1 2 3 4 ] ", @rect.to_s)
+  end
+end
+
+module FontFactory
+  def make_font_descriptor
+    PdfFontDescriptor.new(100, 0,
+      'ArialMT', 32, [-665, -325, 2029, 1006], 0, 0, 0, 0,
+      723, 525,
+      905, -212, 33,
+      2000, 0)
+  end
+end
+
+class PdfFontTestCases < Test::Unit::TestCase
+  include FontFactory
+
+  def setup
+    @widths = PdfArray.new([1, 3, 5, 7])
+    @io_widths = IndirectObject.new(2, 0, @widths)
+    @font_descriptor = make_font_descriptor
+    @font = PdfFont.new(1, 0, 'TrueType', 'ArialMT', 32, 169, @io_widths, @font_descriptor)
+  end
+
+  def test_to_s
+    expected = "1 0 obj\n" <<
+      "<<\n" <<
+      "/BaseFont /ArialMT \n" <<
+      "/FirstChar 32 \n" <<
+      "/FontDescriptor 100 0 R \n" <<
+      "/LastChar 169 \n" <<
+      "/Subtype /TrueType \n" <<
+      "/Type /Font \n" <<
+      "/Widths 2 0 R \n" <<
+      ">>\n" <<
+      "endobj\n"
+    assert_equal(expected, @font.to_s)
+  end
+  
+  def test_encoding=
+    @font.encoding = 'WinAnsiEncoding'
+    assert_equal(PdfName.new('WinAnsiEncoding'), @font.dictionary['Encoding'])
+  end
+end
+
+class PdfFontDescriptorTestCases < Test::Unit::TestCase
+  include FontFactory
+
+  def setup
+    @font_descriptor = make_font_descriptor
+  end
+
+  def test_to_s
+    expected = "100 0 obj\n" <<
+      "<<\n" <<
+      "/Ascent 905 \n" <<
+      "/AvgWidth 0 \n" <<
+      "/CapHeight 723 \n" <<
+      "/Descent -212 \n" <<
+      "/Flags 32 \n" <<
+      "/FontBBox [-665 -325 2029 1006 ] \n" <<
+      "/FontName /ArialMT \n" <<
+      "/ItalicAngle 0.0 \n" <<
+      "/Leading 33 \n" <<
+      "/MaxWidth 2000 \n" <<
+      "/MissingWidth 0 \n" <<
+      "/StemH 0 \n" <<
+      "/StemV 0 \n" <<
+      "/Type /FontDescriptor \n" <<
+      "/XHeight 525 \n" <<
+      ">>\n" <<
+      "endobj\n"
+    assert_equal(expected, @font_descriptor.to_s)
+  end
+end
+
+class PdfFontEncodingTestCases < Test::Unit::TestCase
+  def setup
+    differences = PdfArray.new([PdfInteger.new(32), PdfName.new('space')])
+    @font_encoding = PdfFontEncoding.new(1, 0, "MacRomanEncoding", differences)
+  end
+
+  def test_to_s
+    expected = "1 0 obj\n" <<
+      "<<\n" <<
+      "/BaseEncoding /MacRomanEncoding \n" <<
+      "/Differences [32 /space ] \n" <<
+      "/Type /Encoding \n" <<
+      ">>\n" <<
+      "endobj\n"
+    assert_equal(expected, @font_encoding.to_s)
+  end
+end
+
+class PdfXObjectTestCases < Test::Unit::TestCase
+  def test_initialize
+    xobj = PdfXObject.new(1,0)
+    assert_equal(PdfName.new('XObject'), xobj.dictionary['Type'])
+  end
+end
+
+class PdfImageTestCases < Test::Unit::TestCase
+  def setup
+    @image = PdfImage.new(1,0,'test')
+  end
+
+  def test_initialize
+    assert_equal(PdfName.new('XObject'), @image.dictionary['Type'])
+    assert_equal(PdfName.new('Image'), @image.dictionary['Subtype'])
+  end
+
+  def test_body
+    assert_equal("<<\n/Length 4 \n/Subtype /Image \n/Type /XObject \n>>\nstream\ntestendstream\n", @image.body)
+    assert_equal(PdfInteger.new(4), @image.dictionary['Length'])
+  end
+
+  def test_filter=
+    @image.filter = 'ASCIIHexDecode'
+    assert_equal(PdfName.new('ASCIIHexDecode'), @image.dictionary['Filter'])
+  end
+
+  def test_filters=
+    filters = PdfArray.new ['ASCII85Decode', 'LZWDecode'].map { |s| PdfName.new(s) }
+    @image.filters = filters
+    assert_equal(filters, @image.dictionary['Filter'])
+  end
+
+  def test_width
+    @image.width = 320
+    assert_equal(320, @image.width)
+    assert_equal(PdfInteger.new(320), @image.dictionary['Width'])
+  end
+
+  def test_height
+    @image.height = 200
+    assert_equal(200, @image.height)
+    assert_equal(PdfInteger.new(200), @image.dictionary['Height'])
+  end
+
+  def test_bits_per_component=
+    @image.bits_per_component = 8
+    assert_equal(PdfInteger.new(8), @image.dictionary['BitsPerComponent'])
+  end
+
+  def test_color_space=
+    @image.color_space = 'DeviceCMYK'
+    assert_equal(PdfName.new('DeviceCMYK'), @image.dictionary['ColorSpace'])
+    # todo: test other types of values, such as indirect objects
+  end
+
+  def test_decode=
+    decode = PdfArray.new [1, 0].map { |i| PdfInteger.new(i )}
+    @image.decode = decode
+    assert_equal(decode, @image.dictionary['Decode'])
+  end
+
+  def test_interpolate=
+    @image.interpolate = true
+    assert_equal(PdfBoolean.new(true), @image.dictionary['Interpolate'])
+  end
+
+  def test_image_mask=
+    @image.image_mask = false
+    assert_equal(PdfBoolean.new(false), @image.dictionary['ImageMask'])
+  end
+
+  def test_intent=
+    @image.intent = 'AbsoluteColorimetric'
+    assert_equal(PdfName.new('AbsoluteColorimetric'), @image.dictionary['Intent'])
+  end
+end
+
+class PdfAnnotTestCases < Test::Unit::TestCase
+  def setup
+    @rect = Rectangle.new(1,2,3,4)
+    @annot = PdfAnnot.new(1, 0, 'Text', @rect)
+  end
+
+  def test_initialize
+    assert_equal(1, @annot.seq)
+    assert_equal(0, @annot.gen)
+    assert_equal(PdfName.new('Annot'), @annot.dictionary['Type'])
+    assert_equal(PdfName.new('Text'), @annot.dictionary['Subtype'])
+    assert_equal(@rect, @annot.dictionary['Rect'])
+  end
+
+  def test_border=
+    border = [0, 0, 1]
+    @annot.border = border
+    assert_equal(PdfInteger.ary(border), @annot.dictionary['Border'])
+  end
+
+  def test_color=
+    color = [0.2, 0.4, 0.6]
+    @annot.color = color
+    assert_equal(PdfReal.ary(color), @annot.dictionary['C'])
+  end
+
+  def test_title=
+    @annot.title = 'Joe'
+    assert_equal(PdfString.new('Joe'), @annot.dictionary['T'])
+  end
+
+  def test_mod_date=
+    t = Time.local(2007, 9, 8, 14, 30, 0, 0)
+    @annot.mod_date = t
+    assert_equal(PdfString.new('20070908143000'), @annot.dictionary['M'])
+  end
+
+  def test_flags=
+    @annot.flags = 0
+    assert_equal(PdfInteger.new(0), @annot.dictionary['F'])
+  end
+
+  def test_highlight=
+    @annot.highlight = :none
+    assert_equal(PdfName.new('N'), @annot.dictionary['H'])
+    @annot.highlight = :invert
+    assert_equal(PdfName.new('I'), @annot.dictionary['H'])
+    @annot.highlight = :outline
+    assert_equal(PdfName.new('O'), @annot.dictionary['H'])
+    @annot.highlight = :push
+    assert_equal(PdfName.new('P'), @annot.dictionary['H'])
+
+    @annot.highlight = 'N'
+    assert_equal(PdfName.new('N'), @annot.dictionary['H'])
+    @annot.highlight = 'I'
+    assert_equal(PdfName.new('I'), @annot.dictionary['H'])
+    @annot.highlight = 'O'
+    assert_equal(PdfName.new('O'), @annot.dictionary['H'])
+    @annot.highlight = 'P'
+    assert_equal(PdfName.new('P'), @annot.dictionary['H'])
+  end
+
+  def test_border_style=
+    border_style = {
+      'Type' => PdfName.new('Border'),
+      'W' => PdfInteger.new(1),
+      'S' => PdfName.new('D'),
+      'D' => PdfInteger.ary([3, 2])
+    }
+    @annot.border_style = border_style
+    assert_equal(PdfDictionary.new(border_style).to_s, @annot.dictionary['BS'].to_s)
+  end
+
+  def test_appearance_dictionary=
+    io = IndirectObject.new(1,0)
+    appearance = { 'N' => io.reference_object }
+    @annot.appearance_dictionary = appearance
+    assert_equal("<<\n/N 1 0 R \n>>\n", @annot.dictionary['AP'].to_s)
+  end
+
+  def test_appearance_state=
+    @annot.appearance_state = 'Yes'
+    assert_equal(PdfName.new('Yes'), @annot.dictionary['AS'])
+  end
+end
+
+class PdfTextAnnotTestCases < Test::Unit::TestCase
+  def setup
+    @rect = Rectangle.new(1,2,3,4)
+    @annot = PdfTextAnnot.new(1, 0, @rect, 'Hello')
+  end
+
+  def test_initialize
+    assert_equal(PdfName.new('Text'), @annot.dictionary['Subtype'])
+    assert_equal(PdfString.new('Hello'), @annot.dictionary['Contents'])
+  end
+
+  def test_open=
+    @annot.open = true
+    assert_equal(PdfBoolean.new(true), @annot.dictionary['Open'])
+    @annot.open = false
+    assert_equal(PdfBoolean.new(false), @annot.dictionary['Open'])
+  end
+end
+
+#class PdfLinkAnnotTestCases < Test::Unit::TestCase
+#end
+
+#class PdfMovieAnnotTestCases < Test::Unit::TestCase
+#end
+
+class PdfSoundAnnotTestCases < Test::Unit::TestCase
+  def test_initialize
+    rect = Rectangle.new(1,2,3,4)
+    stream = PdfStream.new(1, 0, 'test')
+    sound = PdfSoundAnnot.new(2, 0, rect, stream)
+    assert_equal(PdfName.new('Sound'), sound.dictionary['Subtype'])
+    assert_equal(stream, sound.dictionary['Sound'])
+  end
+end
+
+#class PdfURIActionTestCases < Test::Unit::TestCase
+#end
+
+#class PdfAnnotBorderTestCases < Test::Unit::TestCase
+#end
+
+class PdfResourcesTestCases < Test::Unit::TestCase
+  def setup
+    @res = PdfResources.new(1,0)
+  end
+
+  def test_proc_set=
+    a = PdfName.ary ['PDF','Text','ImageB','ImageC']
+    @res.proc_set = a
+    assert_equal(a, @res.dictionary['ProcSet'])
+  end
+
+  def test_fonts
+    io = IndirectObject.new(2,0)
+    @res.fonts['F1'] = io.reference_object
+    assert_equal("1 0 obj\n<<\n/Font <<\n/F1 2 0 R \n>>\n\n>>\nendobj\n", @res.to_s)
+  end
+
+  def test_x_objects
+    io = IndirectObject.new(2,0)
+    @res.x_objects['Im1'] = io.reference_object
+    assert_equal("1 0 obj\n<<\n/XObject <<\n/Im1 2 0 R \n>>\n\n>>\nendobj\n", @res.to_s)
+  end
+end
+
+class PdfPageBaseTestCases < Test::Unit::TestCase
+  def setup
+    @io = IndirectObject.new(1, 0)
+    @base = PdfPageBase.new(2, 0, @io)
+  end
+
+  def test_initialize
+    assert_equal('1 0 R ', @base.dictionary['Parent'].to_s)
+  end
+
+  def test_media_box=
+    r = Rectangle.new(1, 2, 3, 4)
+    @base.media_box = r
+    assert_equal('[1 2 3 4 ] ', @base.dictionary['MediaBox'].to_s)
+  end
+
+  def test_resources=
+    resources = PdfResources.new(3, 0)
+    @base.resources = resources
+    assert_equal('3 0 R ', @base.dictionary['Resources'].to_s)
+  end
+
+  def test_crop_box=
+    r = Rectangle.new(1, 2, 3, 4)
+    @base.crop_box = r
+    assert_equal('[1 2 3 4 ] ', @base.dictionary['CropBox'].to_s)
+  end
+
+  def test_rotate=
+    @base.rotate = 90
+    assert_equal(PdfInteger.new(90), @base.dictionary['Rotate'])
+  end
+
+  def test_duration=
+    @base.duration = 5
+    assert_equal('5 ', @base.dictionary['Dur'].to_s)
+    @base.duration = 6.5
+    assert_equal('6.5 ', @base.dictionary['Dur'].to_s)
+  end
+
+  def test_hidden=
+    @base.hidden = true
+    assert_equal('true ', @base.dictionary['Hid'].to_s)
+  end
+
+  def test_transition=
+    t = {
+      'Type' => PdfName.new('Trans'),
+      'D' => PdfReal.new(3.5),
+      'S' => PdfName.new('Split'),
+      'Dm' => PdfName.new('V'),
+      'M' => PdfName.new('O')
+    }
+    @base.transition = t
+    assert_equal("<<\n/D 3.5 \n/Dm /V \n/M /O \n/S /Split \n/Type /Trans \n>>\n", @base.dictionary['Trans'].to_s)
+  end
+
+  def test_additional_actions=
+    aa = { 'Foo' => PdfName.new('Bar') }
+    @base.additional_actions = aa
+    assert_equal("<<\n/Foo /Bar \n>>\n", @base.dictionary['AA'].to_s)
+  end
+end
+
+class PdfPageTestCases < Test::Unit::TestCase
+  def setup
+    pages = PdfPages.new(1, 0)
+    @page = PdfPage.new(2, 0, pages)
+    @stream = PdfStream.new(3, 0, 'test')
+    @page.contents << @stream
+  end
+
+  def test_initialize
+    assert_equal(PdfName.new('Page'), @page.dictionary['Type'])
+  end
+
+  def test_body
+    assert_equal("<<\n/Contents 3 0 R \n/Parent 1 0 R \n/Type /Page \n>>\n", @page.body)
+  end
+
+  def test_contents
+    @page.body # Cause dictionary to be updated.
+    assert_equal(@stream.reference_object, @page.dictionary['Contents'])
+
+    @page.contents << @stream
+    @page.body
+    assert_equal(PdfArray.new([@stream.reference_object, @stream.reference_object]), @page.dictionary['Contents'])    
+  end
+
+  # xxx these methods to be implemented if necessary
+  def test_thumb=
+    @page.thumb = @stream
+    assert_equal(@stream.reference_object, @page.dictionary['Thumb'])
+  end
+
+  def test_annots=
+    rect = Rectangle.new(1,2,3,4)
+    annot = PdfTextAnnot.new(4, 0, rect, 'Hello')
+    @page.annots = [annot]
+    annots = PdfArray.new([annot.reference_object])
+    assert_equal(annots, @page.dictionary['Annots'])
+  end
+
+  def test_beads=
+    b1 = IndirectObject.new(4, 0)
+    b2 = IndirectObject.new(5, 0)
+    @page.beads = [b1, b2]
+    assert_equal(PdfArray.new([b1.reference_object, b2.reference_object]), @page.dictionary['B'])
+  end
+end
+
+class PdfPagesTestCases < Test::Unit::TestCase
+  def setup
+    @pages = PdfPages.new(1, 0)
+    @page = PdfPage.new(2, 0, @pages)
+  end
+
+  def test_initialize
+    assert_equal(PdfName.new('Pages'), @pages.dictionary['Type'])
+    assert_equal([], @pages.kids)
+  end
+
+  def test_to_s
+    @pages.kids << @page
+    assert_equal("1 0 obj\n<<\n/Count 1 \n/Kids [2 0 R ] \n/Type /Pages \n>>\nendobj\n", @pages.to_s)
+  end
+end
+
+class PdfOutlinesTestCases < Test::Unit::TestCase
+  def setup
+    @outlines = PdfOutlines.new(1, 0)
+  end
+
+  def test_initialize
+    assert_equal(PdfName.new('Outlines'), @outlines.dictionary['Type'])
+  end
+
+  def test_to_s
+    assert_equal("1 0 obj\n<<\n/Count 0 \n/Type /Outlines \n>>\nendobj\n", @outlines.to_s)
+  end
+end
+
+class PdfFileTestCases < Test::Unit::TestCase
+  def setup
+    @file = PdfFile.new
+  end
+
+  def test_initialize
+    assert_not_nil(@file.body)
+    assert_not_nil(@file.trailer)
+  end
+
+  def test_header
+    assert_equal("%PDF-1.3\n", @file.header.to_s)
+  end
+
+  def test_body
+    assert_equal("", @file.body.to_s)
+  end
+
+  def test_trailer
+    assert_equal("trailer\n<<\n>>\nstartxref\n\n%%EOF\n", @file.trailer.to_s)
+  end
+
+  def test_to_s
+    assert_equal("%PDF-1.3\nxref\n0 1\n0000000000 65535 f\ntrailer\n<<\n/Size 1 \n>>\nstartxref\n9\n%%EOF\n", @file.to_s)
+  end
+end