hexapdf 0.21.1 → 0.24.0

data/test/hexapdf/document/test_destinations.rb

@@ -0,0 +1,338 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+
+describe HexaPDF::Document::Destinations::Destination do
+  def destination(dest)
+    HexaPDF::Document::Destinations::Destination.new(dest)
+  end
+
+  it "can be asked whether the referenced page is in a remote document" do
+    assert(destination([5, :Fit]).remote?)
+    refute(destination([HexaPDF::Dictionary.new({}), :Fit]).remote?)
+  end
+
+  it "returns the page object" do
+    assert_equal(:page, destination([:page, :Fit]).page)
+  end
+
+  describe "type :xyz" do
+    before do
+      @dest = destination([:page, :XYZ, :left, :top, :zoom])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:xyz, @dest.type)
+    end
+
+    it "returns the argument left" do
+      assert_equal(:left, @dest.left)
+    end
+
+    it "returns the argument top" do
+      assert_equal(:top, @dest.top)
+    end
+
+    it "returns the argument zoom" do
+      assert_equal(:zoom, @dest.zoom)
+    end
+
+    it "raises an error if the bottom and right properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+    end
+  end
+
+  describe "type :fit_page" do
+    before do
+      @dest = destination([:page, :Fit])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_page, @dest.type)
+    end
+
+    it "raises an error if the top, left, bottom, right, zoom properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.top }
+      assert_raises(HexaPDF::Error) { @dest.left }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_page_horizontal" do
+    before do
+      @dest = destination([:page, :FitH, :top])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_page_horizontal, @dest.type)
+    end
+
+    it "returns the argument top" do
+      assert_equal(:top, @dest.top)
+    end
+
+    it "raises an error if the left, bottom, right, zoom properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.left }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_page_vertical" do
+    before do
+      @dest = destination([:page, :FitV, :left])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_page_vertical, @dest.type)
+    end
+
+    it "returns the argument left" do
+      assert_equal(:left, @dest.left)
+    end
+
+    it "raises an error if the top, bottom, right, zoom properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.top }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_rectangle" do
+    before do
+      @dest = destination([:page, :FitR, :left, :bottom, :right, :top])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_rectangle, @dest.type)
+    end
+
+    it "returns the argument left" do
+      assert_equal(:left, @dest.left)
+    end
+
+    it "returns the argument top" do
+      assert_equal(:top, @dest.top)
+    end
+
+    it "returns the argument right" do
+      assert_equal(:right, @dest.right)
+    end
+
+    it "returns the argument bottom" do
+      assert_equal(:bottom, @dest.bottom)
+    end
+
+    it "raises an error if the zoom property is accessed" do
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_bounding_box" do
+    before do
+      @dest = destination([:page, :FitB])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_bounding_box, @dest.type)
+    end
+
+    it "raises an error if the bottom and right properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.left }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.top }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_bounding_box_horizontal" do
+    before do
+      @dest = destination([:page, :FitBH, :top])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_bounding_box_horizontal, @dest.type)
+    end
+
+    it "returns the argument top" do
+      assert_equal(:top, @dest.top)
+    end
+
+    it "raises an error if the left, bottom, right, zoom properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.left }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_bounding_box_vertical::" do
+    before do
+      @dest = destination([:page, :FitBV, :left])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_bounding_box_vertical, @dest.type)
+    end
+
+    it "returns the argument left" do
+      assert_equal(:left, @dest.left)
+    end
+
+    it "raises an error if the left, bottom, right, zoom properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.top }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+end
+
+describe HexaPDF::Document::Destinations do
+  before do
+    @doc = HexaPDF::Document.new
+    @page = @doc.pages.add
+  end
+
+  describe "create_xyz" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_xyz(@page, left: 1, top: 2, zoom: 3)
+      assert_equal([@page, :XYZ, 1, 2, 3], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_xyz(@page, name: 'xyz')
+      assert_equal([@page, :XYZ, nil, nil, nil], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_page" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_page(@page)
+      assert_equal([@page, :Fit], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_page(@page, name: 'xyz')
+      assert_equal([@page, :Fit], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_page_horizontal" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_page_horizontal(@page, top: 2)
+      assert_equal([@page, :FitH, 2], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_page_horizontal(@page, name: 'xyz')
+      assert_equal([@page, :FitH, nil], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_page_vertical" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_page_vertical(@page, left: 2)
+      assert_equal([@page, :FitV, 2], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_page_vertical(@page, name: 'xyz')
+      assert_equal([@page, :FitV, nil], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_rectangle" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_rectangle(@page, left: 1, bottom: 2, right: 3, top: 4)
+      assert_equal([@page, :FitR, 1, 2, 3, 4], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_rectangle(@page, name: 'xyz', left: 1, bottom: 2, right: 3, top: 4)
+      assert_equal([@page, :FitR, 1, 2, 3, 4], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_bounding_box" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_bounding_box(@page)
+      assert_equal([@page, :FitB], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_bounding_box(@page, name: 'xyz')
+      assert_equal([@page, :FitB], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_bounding_box_horizontal" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_bounding_box_horizontal(@page, top: 2)
+      assert_equal([@page, :FitBH, 2], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_bounding_box_horizontal(@page, name: 'xyz')
+      assert_equal([@page, :FitBH, nil], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_bounding_box_vertical" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_bounding_box_vertical(@page, left: 2)
+      assert_equal([@page, :FitBV, 2], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_bounding_box_vertical(@page, name: 'xyz')
+      assert_equal([@page, :FitBV, nil], @doc.destinations[dest])
+    end
+  end
+
+  it "adds a destination array to the destinations name tree and allows to retrieve it" do
+    @doc.destinations.add('abc', [:page, :Fit])
+    assert_equal([:page, :Fit], @doc.destinations['abc'])
+  end
+
+  it "deletes a named destination" do
+    @doc.destinations.add('abc', [:page, :Fit])
+    assert(@doc.destinations['abc'])
+    @doc.destinations.delete('abc')
+    refute(@doc.destinations['abc'])
+  end
+
+  describe "each" do
+    before do
+      3.times {|i| @doc.destinations.add("abc#{i}", [:page, :Fit]) }
+    end
+
+    it "returns an enumerator if no block is given" do
+      enum = @doc.destinations.each
+      assert_equal('abc0', enum.next.first)
+      assert_equal('abc1', enum.next.first)
+      assert_equal('abc2', enum.next.first)
+      assert_raises(StopIteration) { enum.next }
+    end
+
+    it "iterates over all name-destination pairs in order" do
+      result = [
+        ['abc0', :fit_page],
+        ['abc1', :fit_page],
+        ['abc2', :fit_page],
+      ]
+      @doc.destinations.each do |name, dest|
+        exp_name, exp_type = result.shift
+        assert_equal(exp_name, name)
+        assert_equal(exp_type, dest.type)
+      end
+    end
+  end
+end

data/test/hexapdf/document/test_images.rb

@@ -31,7 +31,7 @@ describe HexaPDF::Document::Images do
       it "adds an image using an IO" do
         File.open(__FILE__, 'rb') do |file|
           image = @doc.images.add(file)
-          assert_equal(File.read(__FILE__), image.stream)
+          assert_equal(File.binread(__FILE__), image.stream)
           assert_equal(File.absolute_path(__FILE__), image.source_path)
         end
       end

data/test/hexapdf/document/test_layout.rb

@@ -0,0 +1,264 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+
+describe HexaPDF::Document::Layout::ChildrenCollector do
+  before do
+    @doc = HexaPDF::Document.new
+    @collector = HexaPDF::Document::Layout::ChildrenCollector.new(@doc.layout)
+  end
+
+  it "provides a convenient ::collect method which just returns the collected children" do
+    children = HexaPDF::Document::Layout::ChildrenCollector.collect(@doc.layout) do |collector|
+      collector.lorem_ipsum_box
+      collector.lorem_ipsum_box
+    end
+    assert_equal(2, children.size)
+    assert_kind_of(HexaPDF::Layout::TextBox, children[0])
+    assert_kind_of(HexaPDF::Layout::TextBox, children[1])
+  end
+
+  it "allows appending existing boxes" do
+    box = @doc.layout.lorem_ipsum_box
+    @collector << box
+    assert_equal([box], @collector.children)
+  end
+
+  it "allows appending an array of boxes created through another children collector" do
+    @collector.multiple do |collector|
+      collector.lorem_ipsum_box
+      collector.lorem_ipsum_box
+    end
+    assert_equal(1, @collector.children.size)
+    assert_equal(2, @collector.children[0].size)
+  end
+
+  it "allows appending boxes through method names of the Layout class" do
+    @collector.lorem_ipsum_box
+    assert_equal(1, @collector.children.size)
+    assert_kind_of(HexaPDF::Layout::TextBox, @collector.children[0])
+  end
+
+  it "allows appending boxes through method names without the _box suffix of the Layout class" do
+    @collector.lorem_ipsum
+    assert_equal(1, @collector.children.size)
+    assert_kind_of(HexaPDF::Layout::TextBox, @collector.children[0])
+  end
+
+  it "allows appending boxes through their registered names" do
+    @collector.column
+    assert_equal(1, @collector.children.size)
+    assert_kind_of(HexaPDF::Layout::ColumnBox, @collector.children[0])
+  end
+
+  it "can be asked which methods it supports" do
+    assert(@collector.respond_to?(:text_box))
+    assert(@collector.respond_to?(:text))
+    assert(@collector.respond_to?(:column))
+    refute(@collector.respond_to?(:unknown))
+  end
+
+  it "raises an error on an unknown method name" do
+    assert_raises(NameError) { @collector.unknown_box }
+  end
+end
+
+describe HexaPDF::Document::Layout do
+  before do
+    @doc = HexaPDF::Document.new
+    @layout = @doc.layout
+  end
+
+  describe "style" do
+    it "creates a new style if it does not exist based on the base argument" do
+      @layout.style(:base, font_size: 20)
+      assert_equal(20, @layout.style(:newstyle, subscript: true).font_size)
+      refute(@layout.style(:base).subscript)
+      assert_equal(10, @layout.style(:another_new, base: nil).font_size)
+      assert(@layout.style(:yet_another_new, base: :newstyle).subscript)
+    end
+
+    it "returns the named style" do
+      assert_kind_of(HexaPDF::Layout::Style, @layout.style(:base))
+    end
+
+    it "updates the style with the given properties" do
+      assert_equal(20, @layout.style(:base, font_size: 20).font_size)
+    end
+  end
+
+  describe "box" do
+    it "creates the request box" do
+      box = @layout.box(:column, columns: 3, gaps: 20, width: 15, height: 30, style: {font_size: 10})
+      assert_equal(15, box.width)
+      assert_equal(30, box.height)
+      assert_equal([-1, -1, -1], box.columns)
+      assert_equal([20], box.gaps)
+      assert_equal(10, box.style.font_size)
+    end
+
+    it "allows specifying the box's children via a provided block" do
+      box = @layout.box(:column) do |column|
+        column.lorem_ipsum
+        column.lorem_ipsum
+      end
+      assert_equal(2, box.children.size)
+    end
+
+    it "fails if the name is not registered" do
+      assert_raises(HexaPDF::Error) { @layout.box(:unknown) }
+    end
+  end
+
+  describe "text_box" do
+    it "creates a text box" do
+      box = @layout.text_box("Test", width: 10, height: 15)
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+      assert_same(@doc.fonts.add("Times"), box.style.font)
+      items = box.instance_variable_get(:@items)
+      assert_equal(1, items.length)
+      assert_same(box.style, items.first.style)
+    end
+
+    it "allows setting of a custom style" do
+      style = HexaPDF::Layout::Style.new(font_size: 20, font: ['Times', {variant: :bold}])
+      box = @layout.text_box("Test", style: style)
+      assert_same(box.style, style)
+      assert_same(@doc.fonts.add("Times", variant: :bold), box.style.font)
+      assert_equal(20, box.style.font_size)
+
+      box = @layout.text_box("Test", style: {font_size: 20})
+      assert_equal(20, box.style.font_size)
+
+      @layout.style(:named, font_size: 20)
+      box = @layout.text_box("Test", style: :named)
+      assert_equal(20, box.style.font_size)
+    end
+
+    it "updates the used style with the provided options" do
+      box = @layout.text_box("Test", style: {subscript: true}, font_size: 20)
+      assert_equal(20, box.style.font_size)
+    end
+
+    it "allows using a box style different from the text style" do
+      style = HexaPDF::Layout::Style.new(font_size: 20)
+      box = @layout.text_box("Test", box_style: style)
+      refute_same(box.instance_variable_get(:@items).first.style, style)
+      assert_same(box.style, style)
+
+      @layout.style(:named, font_size: 20)
+      box = @layout.text_box("Test", box_style: :named)
+      assert_equal(20, box.style.font_size)
+    end
+  end
+
+  describe "formatted_text" do
+    it "creates a text box with the given text" do
+      box = @layout.formatted_text_box(["Test"], width: 10, height: 15)
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+      assert_equal(1, box.instance_variable_get(:@items).length)
+    end
+
+    it "allows using a hash with :text key instead of a simple string" do
+      box = @layout.formatted_text_box([{text: "Test"}])
+      items = box.instance_variable_get(:@items)
+      assert_equal(4, items[0].items.length)
+    end
+
+    it "uses an empty string if the :text key for a hash is not specified" do
+      box = @layout.formatted_text_box([{font_size: "Test"}])
+      items = box.instance_variable_get(:@items)
+      assert_equal(0, items[0].items.length)
+    end
+
+    it "allows setting a custom base style for all parts" do
+      box = @layout.formatted_text_box(["Test", "other"], font_size: 20)
+      items = box.instance_variable_get(:@items)
+      assert_equal(20, box.style.font_size)
+      assert_equal(20, items[0].style.font_size)
+      assert_equal(20, items[1].style.font_size)
+    end
+
+    it "allows using custom style properties for a single part" do
+      box = @layout.formatted_text_box([{text: "Test", font_size: 20}, "test"], align: :center)
+      items = box.instance_variable_get(:@items)
+      assert_equal(10, box.style.font_size)
+
+      assert_equal(20, items[0].style.font_size)
+      assert_equal(:center, items[0].style.align)
+
+      assert_equal(10, items[1].style.font_size)
+      assert_equal(:center, items[1].style.align)
+    end
+
+    it "allows using a custom style as basis for a single part" do
+      box = @layout.formatted_text_box([{text: "Test", style: {font_size: 20}, subscript: true},
+                                        "test"], align: :center)
+      items = box.instance_variable_get(:@items)
+      assert_equal(10, box.style.font_size)
+
+      assert_equal(20, items[0].style.font_size)
+      assert_equal(:left, items[0].style.align)
+      assert(items[0].style.subscript)
+
+      assert_equal(10, items[1].style.font_size)
+      assert_equal(:center, items[1].style.align)
+      refute(items[1].style.subscript)
+    end
+
+    it "allows specifying a link to an URL via the :link key" do
+      box = @layout.formatted_text_box([{text: "Test", link: "URI"}, {link: "URI"}, "test"])
+      items = box.instance_variable_get(:@items)
+      assert_equal(3, items.length)
+      assert_equal(4, items[0].items.length, "text should be Test")
+      assert_equal(3, items[1].items.length, "text should be URI")
+      assert_equal([:link, {uri: 'URI'}], items[0].style.overlays.instance_variable_get(:@layers)[0])
+      refute(items[2].style.overlays?)
+    end
+  end
+
+  describe "image_box" do
+    it "creates an image box" do
+      image_path = File.join(TEST_DATA_DIR, 'images', 'gray.jpg')
+
+      box = @layout.image_box(image_path, width: 10, height: 15, style: {font_size: 20}, subscript: true)
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+      assert_equal(20, box.style.font_size)
+      assert(box.style.subscript)
+      assert_same(@doc.images.add(image_path), box.image)
+    end
+
+    it "allows using a form XObject" do
+      form = @doc.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, 10, 10]})
+      box = @layout.image_box(form, width: 10)
+      assert_equal(10, box.width)
+      assert_same(form, box.image)
+    end
+  end
+
+  describe "lorem_ipsum_box" do
+    it "creates a standard lorem ipsum box" do
+      box = @layout.lorem_ipsum_box(width: 10, height: 15, font_size: 15)
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+      items = box.instance_variable_get(:@items)
+      assert_equal(HexaPDF::Document::Layout::LOREM_IPSUM.join(" ").size, items[0].items.length)
+    end
+
+    it "can use just some sentences from the lorem ipsum text" do
+      box = @layout.lorem_ipsum_box(sentences: 1)
+      items = box.instance_variable_get(:@items)
+      assert_equal(HexaPDF::Document::Layout::LOREM_IPSUM[0].size, items[0].items.length)
+    end
+
+    it "can use multiple of the selected sentences" do
+      box = @layout.lorem_ipsum_box(sentences: 2, count: 2)
+      items = box.instance_variable_get(:@items)
+      assert_equal(HexaPDF::Document::Layout::LOREM_IPSUM[0, 2].join(" ").size * 2 + 2, items[0].items.length)
+    end
+  end
+end

data/test/hexapdf/document/test_pages.rb

@@ -72,6 +72,15 @@ describe HexaPDF::Document::Pages do
     end
   end
 
+  describe "move" do
+    it "moves the page to the given index" do
+      first = @doc.pages.add
+      second = @doc.pages.add
+      @doc.pages.move(first, -1)
+      assert_equal([second, first], @doc.pages.each.to_a)
+    end
+  end
+
   describe "delete" do
     it "deletes a given page" do
       page1 = @doc.pages.add

data/test/hexapdf/document/test_signatures.rb

@@ -138,7 +138,7 @@ describe HexaPDF::Document::Signatures do
   describe "add" do
     before do
       @doc = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
-      @io = StringIO.new
+      @io = StringIO.new(''.b)
     end
 
     it "uses the provided signature dictionary" do
@@ -164,7 +164,7 @@ describe HexaPDF::Document::Signatures do
       sig = @doc.signatures.first
       assert_equal(:'Adobe.PPKLite', sig[:Filter])
       assert_equal(:'adbe.pkcs7.detached', sig[:SubFilter])
-      assert_equal([0, 968, 3590, 2425], sig[:ByteRange].value)
+      assert_equal([0, 968, 3590, 2517], sig[:ByteRange].value)
       assert_equal(:sig, sig[:key])
       assert_equal(:sig_field, @doc.acro_form.each_field.first[:key])
       assert(sig.key?(:Contents))
@@ -205,7 +205,14 @@ describe HexaPDF::Document::Signatures do
     it "handles different xref section types correctly when determing the offsets" do
       @doc.delete(7)
       sig = @doc.signatures.add(@io, @handler, write_options: {update_fields: false})
-      assert_equal([0, 968, 3590, 2412], sig[:ByteRange].value)
+      assert_equal([0, 968, 3590, 2491], sig[:ByteRange].value)
+    end
+
+    it "works if the signature object is the last object of the xref section" do
+      field = @doc.acro_form(create: true).create_signature_field('Signature2')
+      field.create_widget(@doc.pages[0], Rect: [0, 0, 0, 0])
+      sig = @doc.signatures.add(@io, @handler, signature: field, write_options: {update_fields: false})
+      assert_equal([0, 3063, 5685, 400], sig[:ByteRange].value)
     end
 
     it "allows writing to a file in addition to writing to an IO" do

data/test/hexapdf/encryption/test_security_handler.rb

@@ -302,9 +302,9 @@ describe HexaPDF::Encryption::SecurityHandler do
       @handler = TestHandler.new(@document)
 
       assert_equal("Something",
-                   @handler.decrypt(@document.revisions[0].trailer[:Encrypt])[:Key])
+                   @handler.decrypt(@document.revisions.all[0].trailer[:Encrypt])[:Key])
       assert_equal("Otherthing",
-                   @handler.decrypt(@document.revisions[1].trailer[:Encrypt])[:Key])
+                   @handler.decrypt(@document.revisions.all[1].trailer[:Encrypt])[:Key])
     end
 
     it "defers handling encryption to a Crypt filter is specified" do
@@ -378,7 +378,7 @@ describe HexaPDF::Encryption::SecurityHandler do
 
   it "works correctly with different decryption and encryption handlers" do
     test_file = File.join(TEST_DATA_DIR, 'standard-security-handler', 'nopwd-arc4-40bit-V1.pdf')
-    doc = HexaPDF::Document.new(io: StringIO.new(File.read(test_file)))
+    doc = HexaPDF::Document.new(io: StringIO.new(File.binread(test_file)))
     doc.encrypt(algorithm: :aes, password: 'test')
     out = StringIO.new(''.b)
     doc.write(out, update_fields: false)

data/test/hexapdf/font/encoding/test_glyph_list.rb

@@ -21,6 +21,10 @@ describe HexaPDF::Font::Encoding::GlyphList do
       assert_equal("\u05da\u05b8", @list.name_to_unicode(:finalkafqamats))
     end
 
+    it "parses the whole file" do
+      assert_equal("ズ", @list.name_to_unicode(:zukatakana))
+    end
+
     it "maps special uniXXXX names to unicode values" do
       assert_equal("A", @list.name_to_unicode(:uni0041))
       assert_equal("\u1234", @list.name_to_unicode(:uni1234))