hexapdf 0.34.1 → 0.35.1

data/lib/hexapdf/type/page.rb

@@ -62,41 +62,41 @@ module HexaPDF
       # * ISO sizes: A0x4, A0x2, A0-A10, B0-B10, C0-C10
       # * Letter, Legal, Ledger, Tabloid, Executive
       PAPER_SIZE = {
-        A0x4: [0, 0, 4768, 6741].freeze,
-        A0x2: [0, 0, 3370, 4768].freeze,
-        A0: [0, 0, 2384, 3370].freeze,
-        A1: [0, 0, 1684, 2384].freeze,
-        A2: [0, 0, 1191, 1684].freeze,
-        A3: [0, 0, 842, 1191].freeze,
-        A4: [0, 0, 595, 842].freeze,
-        A5: [0, 0, 420, 595].freeze,
-        A6: [0, 0, 298, 420].freeze,
-        A7: [0, 0, 210, 298].freeze,
-        A8: [0, 0, 147, 210].freeze,
-        A9: [0, 0, 105, 147].freeze,
-        A10: [0, 0, 74, 105].freeze,
-        B0: [0, 0, 2835, 4008].freeze,
-        B1: [0, 0, 2004, 2835].freeze,
-        B2: [0, 0, 1417, 2004].freeze,
-        B3: [0, 0, 1001, 1417].freeze,
-        B4: [0, 0, 709, 1001].freeze,
-        B5: [0, 0, 499, 709].freeze,
-        B6: [0, 0, 354, 499].freeze,
-        B7: [0, 0, 249, 354].freeze,
-        B8: [0, 0, 176, 249].freeze,
-        B9: [0, 0, 125, 176].freeze,
-        B10: [0, 0, 88, 125].freeze,
-        C0: [0, 0, 2599, 3677].freeze,
-        C1: [0, 0, 1837, 2599].freeze,
-        C2: [0, 0, 1298, 1837].freeze,
-        C3: [0, 0, 918, 1298].freeze,
-        C4: [0, 0, 649, 918].freeze,
-        C5: [0, 0, 459, 649].freeze,
-        C6: [0, 0, 323, 459].freeze,
-        C7: [0, 0, 230, 323].freeze,
-        C8: [0, 0, 162, 230].freeze,
-        C9: [0, 0, 113, 162].freeze,
-        C10: [0, 0, 79, 113].freeze,
+        A0x4: [0, 0, 4767.874016, 6740.787402].freeze,
+        A0x2: [0, 0, 3370.393701, 4767.874016].freeze,
+        A0: [0, 0, 2383.937008, 3370.393701].freeze,
+        A1: [0, 0, 1683.779528, 2383.937008].freeze,
+        A2: [0, 0, 1190.551181, 1683.779528].freeze,
+        A3: [0, 0, 841.889764, 1190.551181].freeze,
+        A4: [0, 0, 595.275591, 841.889764].freeze,
+        A5: [0, 0, 419.527559, 595.275591].freeze,
+        A6: [0, 0, 297.637795, 419.527559].freeze,
+        A7: [0, 0, 209.76378, 297.637795].freeze,
+        A8: [0, 0, 147.401575, 209.76378].freeze,
+        A9: [0, 0, 104.88189, 147.401575].freeze,
+        A10: [0, 0, 73.700787, 104.88189].freeze,
+        B0: [0, 0, 2834.645669, 4008.188976].freeze,
+        B1: [0, 0, 2004.094488, 2834.645669].freeze,
+        B2: [0, 0, 1417.322835, 2004.094488].freeze,
+        B3: [0, 0, 1000.629921, 1417.322835].freeze,
+        B4: [0, 0, 708.661417, 1000.629921].freeze,
+        B5: [0, 0, 498.897638, 708.661417].freeze,
+        B6: [0, 0, 354.330709, 498.897638].freeze,
+        B7: [0, 0, 249.448819, 354.330709].freeze,
+        B8: [0, 0, 175.748031, 249.448819].freeze,
+        B9: [0, 0, 124.724409, 175.748031].freeze,
+        B10: [0, 0, 87.874016, 124.724409].freeze,
+        C0: [0, 0, 2599.370079, 3676.535433].freeze,
+        C1: [0, 0, 1836.850394, 2599.370079].freeze,
+        C2: [0, 0, 1298.267717, 1836.850394].freeze,
+        C3: [0, 0, 918.425197, 1298.267717].freeze,
+        C4: [0, 0, 649.133858, 918.425197].freeze,
+        C5: [0, 0, 459.212598, 649.133858].freeze,
+        C6: [0, 0, 323.149606, 459.212598].freeze,
+        C7: [0, 0, 229.606299, 323.149606].freeze,
+        C8: [0, 0, 161.574803, 229.606299].freeze,
+        C9: [0, 0, 113.385827, 161.574803].freeze,
+        C10: [0, 0, 79.370079, 113.385827].freeze,
         Letter: [0, 0, 612, 792].freeze,
         Legal: [0, 0, 612, 1008].freeze,
         Ledger: [0, 0, 792, 1224].freeze,

data/lib/hexapdf/utils/sorted_tree_node.rb

@@ -307,16 +307,6 @@ module HexaPDF
         super
         container_name = leaf_node_container_name
 
-        # All kids entries must be indirect objects
-        if key?(:Kids)
-          self[:Kids].each_with_index do |kid, index|
-            unless kid.kind_of?(HexaPDF::Object) && kid.indirect?
-              yield("Child entries of sorted tree nodes must be indirect objects", true)
-              value[:Kids][index] = document.add(kid)
-            end
-          end
-        end
-
         # All keys of the container must be lexically ordered strings and the container must be
         # correctly formatted
         if key?(container_name)

data/lib/hexapdf/utils.rb

@@ -0,0 +1,66 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2023 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'geom2d/utils'
+
+module HexaPDF
+  module Utils
+
+    # The precision with which to compare floating point numbers.
+    #
+    # This is chosen with respect to precision that is used for serializing floating point numbers.
+    EPSILON = 1e-6
+
+    # Best effort of setting Geom2D's precision to the one used by HexaPDF.
+    ::Geom2D::Utils.precision = EPSILON
+
+    module_function
+
+    private
+
+    # Compares two floats whether they are equal using the FLOAT_EPSILON precision.
+    def float_equal(a, b)
+      (a - b).abs < EPSILON
+    end
+
+    # Compares two floats like the <=> operator but using the FLOAT_EPSILON precision for detecting
+    # whether they are equal.
+    def float_compare(a, b)
+      (a - b).abs < EPSILON ? 0 : a <=> b
+    end
+
+  end
+end

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.34.1'
+  VERSION = '0.35.1'
 
 end

data/test/hexapdf/content/test_canvas.rb

@@ -756,6 +756,28 @@ describe HexaPDF::Content::Canvas do
     end
   end
 
+  describe "form" do
+    it "uses the context dimensions if none are given" do
+      form = @canvas.form
+      assert_equal(@canvas.context.box.value, form.box.value)
+    end
+
+    it "uses the provided dimensions" do
+      form = @canvas.form(300, 200)
+      assert_equal([0, 0, 300, 200], form.box.value)
+    end
+
+    it "yields the canvas for defining the form's content" do
+      yielded_canvas = nil
+      form = @canvas.form {|canvas| yielded_canvas = canvas }
+      assert_equal(form.canvas, yielded_canvas)
+    end
+
+    it "raises an ArgumentError if only one of width/height is provided" do
+      assert_raises(ArgumentError) { @canvas.form(20) }
+    end
+  end
+
   describe "graphic_object" do
     it "returns a new graphic object given a name" do
       arc = @canvas.graphic_object(:arc)
@@ -1329,6 +1351,21 @@ describe HexaPDF::Content::Canvas do
     end
   end
 
+  describe "composer" do
+    it "creates a CanvasComposer, yields it and returns it" do
+      comp1 = nil
+      comp2 = @canvas.composer {|composer| comp1 = composer }
+      assert_kind_of(HexaPDF::Content::CanvasComposer, comp1)
+      assert_same(comp1, comp2)
+      assert_same(@canvas, comp1.canvas)
+    end
+
+    it "passes on the margin argument" do
+      comp = @canvas.composer(margin: 20)
+      assert_equal(20, comp.frame.x)
+    end
+  end
+
   describe "color_from_specification "do
     it "accepts a color string" do
       assert_equal([1, 0, 0], @canvas.color_from_specification("red").components)

data/test/hexapdf/content/test_canvas_composer.rb

@@ -0,0 +1,112 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/canvas_composer'
+require 'hexapdf/document'
+
+describe HexaPDF::Content::CanvasComposer do
+  before do
+    @doc = HexaPDF::Document.new
+    @page = @doc.pages.add
+    @canvas = @page.canvas
+    @composer = @canvas.composer
+  end
+
+  describe "initialize" do
+    it "creates the necessary objects like frame for doing the work" do
+      assert_equal(@page.box.width, @composer.frame.width)
+      assert_equal(@page.box.height, @composer.frame.height)
+    end
+
+    it 'allows specifying a value for the margin' do
+      composer = @canvas.composer(margin: [10, 30])
+      assert_equal(@page.box.width - 60, composer.frame.width)
+      assert_equal(@page.box.height - 20, composer.frame.height)
+    end
+  end
+
+  it "provides easy access to the global styles" do
+    assert_same(@doc.layout.style(:base), @composer.style(:base))
+  end
+
+  describe "draw_box" do
+    def create_box(**kwargs)
+      HexaPDF::Layout::Box.new(**kwargs) {}
+    end
+
+    it "draws the box if it completely fits" do
+      @composer.draw_box(create_box(height: 100))
+      @composer.draw_box(create_box)
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 741.889764]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
+                        [:restore_graphics_state]])
+    end
+
+    it "splits the box if possible" do
+      @composer.draw_box(create_box(width: 400, style: {position: :float}))
+      box = create_box(width: 400, height: 100)
+      box.define_singleton_method(:split) do |*|
+        [box, HexaPDF::Layout::Box.new(height: 100) {}]
+      end
+      @composer.draw_box(box)
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 400, 741.889764]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 400, 641.889764]],
+                        [:restore_graphics_state]])
+    end
+
+    it "finds a new region if splitting doesn't work" do
+      @composer.draw_box(create_box(width: 400, height: 100, style: {position: :float}))
+      @composer.draw_box(create_box(width: 400, height: 100))
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 741.889764]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 641.889764]],
+                        [:restore_graphics_state]])
+    end
+
+    it "returns the last drawn box" do
+      box = create_box(height: 400)
+      assert_same(box, @composer.draw_box(box))
+    end
+
+    it "raises an error if the frame is full" do
+      @composer.draw_box(create_box)
+      exception = assert_raises(HexaPDF::Error) { @composer.draw_box(create_box(height: 10)) }
+      assert_match(/Frame.*full/, exception.message)
+    end
+
+    it "raises an error if a new region cannot be found after splitting" do
+      @composer.draw_box(create_box(height: 400))
+      exception = assert_raises(HexaPDF::Error) { @composer.draw_box(create_box(height: 500)) }
+      assert_match(/Frame.*full/, exception.message)
+    end
+  end
+
+  describe "method_missing" do
+    it "delegates box methods to @document.layout" do
+      box = @composer.column(width: 100)
+      assert_equal(100, box.width)
+    end
+
+    it "fails for missing methods that can't be delegated to @document.layout" do
+      assert_raises(NameError) { @composer.unknown_box }
+    end
+  end
+
+  it "can be asked whether a missing method is supported" do
+    assert(@composer.respond_to?(:column))
+  end
+end

data/test/hexapdf/document/test_layout.rb

@@ -110,6 +110,9 @@ end
 describe HexaPDF::Document::Layout do
   before do
     @doc = HexaPDF::Document.new
+    @doc.config['font.on_invalid_glyph'] = lambda do |codepoint, invalid_glyph|
+      [@doc.fonts.add('ZapfDingbats').decode_codepoint(codepoint)]
+    end
     @layout = @doc.layout
   end
 
@@ -177,14 +180,37 @@ describe HexaPDF::Document::Layout do
     end
   end
 
+  describe "text_fragments" do
+    it "creates an array of text fragments with fallback glyph support" do
+      result = @layout.text_fragments("Tom✂")
+      assert_equal(2, result.size)
+      assert_equal(@doc.fonts.add('ZapfDingbats'), result[1].style.font)
+
+      @doc.config['font.on_invalid_glyph'] = nil
+      assert_equal(1, @layout.text_fragments("Tom✂").size)
+    end
+
+    it "uses the standard rules for creating the style object" do
+      @layout.style(:named, font_size: 20)
+      result = @layout.text_fragments("Test", style: :named)
+      assert_equal(20, result[0].style.font_size)
+    end
+
+    it "optionally assigns the properties to all fragments" do
+      result = @layout.text_fragments("Tom✂", properties: {key: :value})
+      assert_equal(:value, result[0].properties[:key])
+      assert_equal(:value, result[1].properties[:key])
+    end
+  end
+
   describe "text_box" do
     it "creates a text box" do
-      box = @layout.text_box("Test", width: 10, height: 15, properties: {key: :value})
+      box = @layout.text_box("Test✂", width: 10, height: 15, properties: {key: :value})
       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_equal(2, items.length)
       assert_same(box.style, items.first.style)
       assert_equal({key: :value}, box.properties)
     end
@@ -227,20 +253,22 @@ describe HexaPDF::Document::Layout do
 
   describe "formatted_text" do
     it "creates a text box with the given text" do
-      box = @layout.formatted_text_box(["Test"], width: 10, height: 15)
+      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)
+      assert_equal(2, box.instance_variable_get(:@items).length)
     end
 
     it "allows setting custom properties on the whole box" do
-      box = @layout.formatted_text_box(["Test"], properties: {key: :value})
+      box = @layout.formatted_text_box([{text: "Test", properties: {key: :novalue}}],
+                                        properties: {key: :value})
       assert_equal({key: :value}, box.properties)
     end
 
     it "allows using a hash with :text key instead of a simple string" do
-      box = @layout.formatted_text_box([{text: "Test"}])
+      box = @layout.formatted_text_box([{text: "Test✂"}])
       items = box.instance_variable_get(:@items)
+      assert_equal(2, items.length)
       assert_equal(4, items[0].items.length)
     end
 
@@ -259,29 +287,29 @@ describe HexaPDF::Document::Layout do
     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)
+      box = @layout.formatted_text_box([{text: "Test", font_size: 20}, "test"], text_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(:center, items[0].style.text_align)
 
       assert_equal(10, items[1].style.font_size)
-      assert_equal(:center, items[1].style.align)
+      assert_equal(:center, items[1].style.text_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)
+                                        "test"], text_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_equal(:left, items[0].style.text_align)
       assert(items[0].style.subscript)
 
       assert_equal(10, items[1].style.font_size)
-      assert_equal(:center, items[1].style.align)
+      assert_equal(:center, items[1].style.text_align)
       refute(items[1].style.subscript)
     end
 

data/test/hexapdf/document/test_pages.rb

@@ -17,20 +17,20 @@ describe HexaPDF::Document::Pages do
   describe "create" do
     it "uses the defaults from the configuration for missing arguments" do
       page = @doc.pages.create
-      assert_equal([0, 0, 595, 842], page.box(:media).value)
+      assert_equal([0, 0, 595.275591, 841.889764], page.box(:media).value)
     end
 
     it "allows specifying a reference to a predefined page size" do
       page = @doc.pages.create(media_box: :A3)
-      assert_equal([0, 0, 842, 1191], page.box(:media).value)
+      assert_equal([0, 0, 841.889764, 1190.551181], page.box(:media).value)
     end
 
     it "allows specifying the orientation for a predefined page size" do
       page = @doc.pages.create(media_box: :A4, orientation: :landscape)
-      assert_equal([0, 0, 842, 595], page.box(:media).value)
+      assert_equal([0, 0, 841.889764, 595.275591], page.box(:media).value)
 
       page = @doc.pages.create(orientation: :landscape)
-      assert_equal([0, 0, 842, 595], page.box(:media).value)
+      assert_equal([0, 0, 841.889764, 595.275591], page.box(:media).value)
     end
 
     it "allows using a media box array" do
@@ -54,7 +54,7 @@ describe HexaPDF::Document::Pages do
     it "adds a new empty page with the given page format" do
       page = @doc.pages.add(:A4, orientation: :landscape)
       assert_same(page, @doc.pages[0])
-      assert_equal([0, 0, 842, 595], @doc.pages[0].box(:media).value)
+      assert_equal([0, 0, 841.889764, 595.275591], @doc.pages[0].box(:media).value)
     end
 
     it "adds the given page to the end" do

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -301,6 +301,49 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     assert_equal([:copy_content, :extract_content, :modify_content], @handler.permissions.sort)
   end
 
+  test_files = Dir[File.join(TEST_DATA_DIR, 'standard-security-handler', '*.pdf')].sort
+  user_password = 'uhexapdf'
+  owner_password = 'ohexapdf'
+
+  describe "decryption_password_type" do
+    it "doesn't need a password for encrypted files without a password" do
+      file = test_files.find {|name| name =~ /nopwd-aes-256bit-V5.pdf/}
+      HexaPDF::Document.open(file) do |doc|
+        assert_equal(:none, doc.security_handler.decryption_password_type)
+      end
+    end
+
+    it "doesn't need a password for owner encrypted files" do
+      file = test_files.find {|name| name =~ /ownerpwd-aes-256bit-V5.pdf/}
+      HexaPDF::Document.open(file) do |doc|
+        assert_equal(:none, doc.security_handler.decryption_password_type)
+      end
+    end
+
+    it "needs the user password for user encrypted files" do
+      file = test_files.find {|name| name =~ /userpwd-aes-256bit-V5.pdf/}
+      HexaPDF::Document.open(file, decryption_opts: {password: user_password}) do |doc|
+        assert_equal(:user, doc.security_handler.decryption_password_type)
+      end
+    end
+
+    it "can user either the user or owner password for user+owner encrypted files" do
+      file = test_files.find {|name| name =~ /bothpwd-aes-256bit-V5.pdf/}
+      HexaPDF::Document.open(file, decryption_opts: {password: user_password}) do |doc|
+        assert_equal(:user, doc.security_handler.decryption_password_type)
+      end
+      HexaPDF::Document.open(file, decryption_opts: {password: owner_password}) do |doc|
+        assert_equal(:owner, doc.security_handler.decryption_password_type)
+      end
+    end
+
+    it "returns :unknown for loaded or created and then encrypted PDF documents" do
+      doc = HexaPDF::Document.new
+      doc.encrypt
+      assert_equal(:unknown, doc.security_handler.decryption_password_type)
+    end
+  end
+
   describe "handling of metadata streams" do
     before do
       @doc = HexaPDF::Document.new

data/test/hexapdf/font/test_invalid_glyph.rb

@@ -8,7 +8,9 @@ describe HexaPDF::Font::InvalidGlyph do
     font = Object.new
     font.define_singleton_method(:missing_glyph_id) { 0 }
     font.define_singleton_method(:full_name) { "Test Roman" }
-    @glyph = HexaPDF::Font::InvalidGlyph.new(font, "str")
+    font_wrapper = Object.new
+    font_wrapper.define_singleton_method(:wrapped_font) { font }
+    @glyph = HexaPDF::Font::InvalidGlyph.new(font_wrapper, "str")
   end
 
   it "returns the missing glyph id for id/name" do
@@ -27,6 +29,16 @@ describe HexaPDF::Font::InvalidGlyph do
     refute(@glyph.apply_word_spacing?)
   end
 
+  it "returns false when asked whether it is valid" do
+    refute(@glyph.valid?)
+  end
+
+  it "returns true if the glyph represents a control character" do
+    refute(@glyph.control_char?)
+    assert(HexaPDF::Font::InvalidGlyph.new(nil, "\n"))
+    assert(HexaPDF::Font::InvalidGlyph.new(nil, "\u{8203}"))
+  end
+
   it "can represent itself for debug purposes" do
     assert_equal('#<HexaPDF::Font::InvalidGlyph font="Test Roman" id=0 "str">',
                  @glyph.inspect)

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -24,17 +24,29 @@ describe HexaPDF::Font::TrueTypeWrapper do
     end
   end
 
+  it "can be asked whether the font is a bold one" do
+    refute(@font_wrapper.bold?)
+  end
+
+  it "can be asked whether the font is an italic one" do
+    refute(@font_wrapper.italic?)
+  end
+
   it "can be asked whether font wil be subset" do
     assert(@font_wrapper.subset?)
     refute(HexaPDF::Font::TrueTypeWrapper.new(@doc, @font, subset: false).subset?)
   end
 
-  describe "decode_utf8" do
-    it "returns an array of glyph objects" do
+  describe "decode_*" do
+    it "decode_utf8 returns an array of glyph objects" do
       assert_equal("Test",
                    @font_wrapper.decode_utf8("Test").map {|g| @cmap.gid_to_code(g.id) }.pack('U*'))
     end
 
+    it "decode_codepoint returns a single glyph object" do
+      assert_equal("A", @font_wrapper.decode_codepoint(65).str)
+    end
+
     it "invokes font.on_missing_glyph for UTF-8 characters for which no glyph exists" do
       glyphs = @font_wrapper.decode_utf8("😁")
       assert_equal(1, glyphs.length)
@@ -54,6 +66,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
       assert_equal(584, glyph.x_max)
       assert_equal(696, glyph.y_max)
       refute(glyph.apply_word_spacing?)
+      assert(glyph.valid?)
       assert_equal('#<HexaPDF::Font::TrueTypeWrapper::Glyph font="Ubuntu-Title" id=17 "0">',
                    glyph.inspect)
     end

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -21,15 +21,33 @@ describe HexaPDF::Font::Type1Wrapper do
     assert_equal("A", wrapper.encode(wrapper.glyph(:B)))
   end
 
+  it "can be asked whether the font is a bold one" do
+    refute(@times_wrapper.bold?)
+    refute(@symbol_wrapper.bold?)
+    assert(@doc.fonts.add("Times", variant: :bold).bold?)
+    refute(@doc.fonts.add("Helvetica").bold?)
+  end
+
+  it "can be asked whether the font is an italic one" do
+    refute(@times_wrapper.italic?)
+    refute(@symbol_wrapper.italic?)
+    assert(@doc.fonts.add("Times", variant: :italic).italic?)
+    assert(@doc.fonts.add("Helvetica", variant: :bold_italic).italic?)
+  end
+
   it "returns 1 for the scaling factor" do
     assert_equal(1, @times_wrapper.scaling_factor)
   end
 
-  describe "decode_utf8" do
-    it "returns an array of glyph objects" do
+  describe "decode_*" do
+    it "decode_utf8 returns an array of glyph objects" do
       assert_equal([:T, :e, :s, :t], @times_wrapper.decode_utf8("Test").map(&:name))
     end
 
+    it "decode_codepoint returns a single glyph object" do
+      assert_equal(:A, @times_wrapper.decode_codepoint(65).name)
+    end
+
     it "falls back to the internal font encoding if the Unicode codepoint is not mapped" do
       assert_equal([:Delta, :Delta], @symbol_wrapper.decode_utf8("D∆").map(&:name))
     end
@@ -53,6 +71,7 @@ describe HexaPDF::Font::Type1Wrapper do
       assert_equal(706, glyph.x_max)
       assert_equal(674, glyph.y_max)
       refute(glyph.apply_word_spacing?)
+      assert(glyph.valid?)
       assert_equal('#<HexaPDF::Font::Type1Wrapper::Glyph font="Times Roman" id=:A "A">',
                    glyph.inspect)
     end

data/test/hexapdf/layout/test_box.rb

@@ -95,6 +95,13 @@ describe HexaPDF::Layout::Box do
       assert_equal(100, box.height)
     end
 
+    it "uses float comparison" do
+      box = create_box(width: 50.0000002, height: 49.9999996)
+      assert(box.fit(50, 50, @frame))
+      assert_equal(50.0000002, box.width)
+      assert_equal(49.9999996, box.height)
+    end
+
     it "returns false if the box doesn't fit" do
       box = create_box(width: 101)
       refute(box.fit(100, 100, @frame))