hexapdf 0.32.2 → 0.34.0

data/test/hexapdf/document/test_pages.rb

@@ -196,15 +196,15 @@ describe HexaPDF::Document::Pages do
     end
 
     it "works for multiple page label entries" do
-      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 2, {S: :d}, 7, {S: :A}]}
+      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 2, {S: :D}, 7, {S: :A}]}
       result = @doc.pages.each_labelling_range.to_a
-      assert_equal([[0, 2, {S: :r}], [2, 5, {S: :d}], [7, 3, {S: :A}]],
+      assert_equal([[0, 2, {S: :r}], [2, 5, {S: :D}], [7, 3, {S: :A}]],
                    result.map {|s, c, l| [s, c, l.value] })
     end
 
     it "returns a zero or negative count for the last range if there aren't enough pages" do
       assert_equal(10, @doc.pages.count)
-      @doc.catalog[:PageLabels] = {Nums: [0, {S: :d}, 10, {S: :r}]}
+      @doc.catalog[:PageLabels] = {Nums: [0, {S: :D}, 10, {S: :r}]}
       assert_equal(0, @doc.pages.each_labelling_range.to_a[-1][1])
       @doc.catalog[:PageLabels][:Nums][2] = 11
       assert_equal(-1, @doc.pages.each_labelling_range.to_a[-1][1])
@@ -221,19 +221,19 @@ describe HexaPDF::Document::Pages do
 
     it "adds an entry for the range starting at 0 if it doesn't exist" do
       label = @doc.pages.add_labelling_range(5)
-      assert_equal([{S: :d}, label],
+      assert_equal([{S: :D}, label],
                    @doc.catalog.page_labels[:Nums].value.values_at(1, 3))
     end
   end
 
   describe "delete_labelling_range" do
     before do
-      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 5, {S: :d}]}
+      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 5, {S: :D}]}
     end
 
     it "deletes the labelling range for a given start index" do
       label = @doc.pages.delete_labelling_range(5)
-      assert_equal({S: :d}, label)
+      assert_equal({S: :D}, label)
     end
 
     it "deletes the labelling range for 0 if it is the last, together with the number tree" do

data/test/hexapdf/encryption/test_security_handler.rb

@@ -17,13 +17,6 @@ describe HexaPDF::Encryption::EncryptionDictionary do
     assert(@dict.must_be_indirect?)
   end
 
-  it "validates the /V value" do
-    @dict[:V] = 1
-    assert(@dict.validate)
-    @dict[:V] = 3
-    refute(@dict.validate)
-  end
-
   it "validates the /Length field when /V=2" do
     @dict[:V] = 2
     refute(@dict.validate)
@@ -240,6 +233,7 @@ describe HexaPDF::Encryption::SecurityHandler do
         [:identity, 128, {V: 4, StrF: :Mine, CF: {Mine: {CFM: :None}}}],
         [:identity, 128, {V: 4, CF: {Mine: {CFM: :AESV2}}}],
       ].each do |alg, length, dict|
+        dict[:Filter] = :Test
         @enc.strf = alg
         @enc.set_up_encryption(key_length: length, algorithm: (alg == :identity ? :aes : alg))
         @obj[:X] = @enc.encrypt_string('data', @obj)
@@ -249,7 +243,7 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
 
     it "selects the correct algorithm for string, stream and embedded file decryption" do
-      @handler.set_up_decryption({V: 4, StrF: :Mine, StmF: :Mine, EFF: :Mine,
+      @handler.set_up_decryption({Filter: :Test, V: 4, StrF: :Mine, StmF: :Mine, EFF: :Mine,
                                   CF: {Mine: {CFM: :V2}}})
       assert_equal(HexaPDF::Encryption::FastARC4, @handler.send(:embedded_file_algorithm))
       assert_equal(HexaPDF::Encryption::FastARC4, @handler.send(:string_algorithm))
@@ -263,16 +257,23 @@ describe HexaPDF::Encryption::SecurityHandler do
                    @handler.encryption_details)
     end
 
+    it "fails if the encryption dictionary is not valid" do
+      exp = assert_raises(HexaPDF::Error) do
+        @handler.set_up_decryption({V: 5})
+      end
+      assert_match(/Validation error for encryption dictionary.*Required field Filter/i, exp.message)
+    end
+
     it "fails for unsupported /V values in the dict" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption({V: 3})
+        @handler.set_up_decryption({Filter: :Text, V: 3})
       end
       assert_match(/Unsupported encryption version/i, exp.message)
     end
 
     it "fails for unsupported crypt filter encryption methods" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption({V: 4, StrF: :Mine, CF: {Mine: {CFM: :Unknown}}})
+        @handler.set_up_decryption({Filter: :Test, V: 4, StrF: :Mine, CF: {Mine: {CFM: :Unknown}}})
       end
       assert_match(/Unsupported encryption method/i, exp.message)
     end
@@ -280,7 +281,7 @@ describe HexaPDF::Encryption::SecurityHandler do
 
   describe "decrypt" do
     before do
-      @handler.set_up_decryption({V: 1})
+      @handler.set_up_decryption({Filter: :Test, V: 1})
       @encrypted = @handler.encrypt_string('string', @obj)
       @obj.value = {Key: @encrypted.dup, Array: [@encrypted.dup], Hash: {Another: @encrypted.dup}}
     end

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -21,13 +21,6 @@ describe HexaPDF::Encryption::StandardEncryptionDictionary do
     @dict[:Perms] = 'test' * 8
   end
 
-  it "validates the /R value" do
-    @dict[:R] = 2
-    assert(@dict.validate)
-    @dict[:R] = 5
-    refute(@dict.validate)
-  end
-
   [:U, :O].each do |field|
     it "validates the length of /#{field} field for R <= 4" do
       @dict[field] = 'test'
@@ -35,19 +28,36 @@ describe HexaPDF::Encryption::StandardEncryptionDictionary do
     end
   end
 
-  [:U, :O, :UE, :OE, :Perms].each do |field|
-    it "validates the length of /#{field} field for R=6" do
+  describe "validation for R=6" do
+    before do
       @dict[:R] = 6
-      @dict[field] = 'test'
-      refute(@dict.validate)
+      @dict[:U] = 't' * 48
+      @dict[:O] = 't' * 48
+      @dict[:UE] = 't' * 32
+      @dict[:OE] = 't' * 32
+      @dict[:Perms] = 't' * 16
     end
-  end
 
-  [:UE, :OE, :Perms].each do |field|
-    it "validates the existence of the /#{field} field for R=6" do
-      @dict[:R] = 6
-      @dict.delete(field)
-      refute(@dict.validate)
+    [:U, :O, :UE, :OE, :Perms].each do |field|
+      it "validates the length of /#{field}" do
+        @dict[field] = 'test'
+        refute(@dict.validate)
+      end
+    end
+
+    [:U, :O].each do |field|
+      it "auto-corrects /#{field} if it is larger and only padded with 0 bytes" do
+        @dict[field] = 't' * 48 + "\x00" * 20
+        assert(@dict.validate)
+        assert_equal('t' * 48, @dict[field])
+      end
+    end
+
+    [:UE, :OE, :Perms].each do |field|
+      it "validates the existence of the /#{field} field" do
+        @dict.delete(field)
+        refute(@dict.validate)
+      end
     end
   end
 end
@@ -211,22 +221,24 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
   describe "prepare_decryption" do
     it "fails if the /Filter value is incorrect" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption({Filter: :NonStandard, V: 2})
+        @handler.set_up_decryption({Filter: :NonStandard, V: 2, R: 4, O: 't' * 32, U: 't' * 32, P: 0,
+                                   Length: 128})
       end
       assert_match(/Invalid \/Filter value NonStandard/i, exp.message)
     end
 
     it "fails if the /R value is incorrect" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 5})
+        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 5, O: 't' * 32, U: 't' * 32, P: 0,
+                                    Length: 128})
       end
       assert_match(/Invalid \/R value 5/i, exp.message)
     end
 
     it "fails if the supplied password is invalid" do
       exp = assert_raises(HexaPDF::EncryptionError) do
-        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 6, U: 'a' * 48, O: 'a' * 48,
-                                    UE: 'a' * 32, OE: 'a' * 32})
+        @handler.set_up_decryption({Filter: :Standard, V: 5, R: 6, U: 'a' * 48, O: 'a' * 48,
+                                    UE: 'a' * 32, OE: 'a' * 32, P: 0, Perms: 'a' * 16})
       end
       assert_match(/Invalid password/i, exp.message)
     end
@@ -234,7 +246,7 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     it "assigns empty strings to the trailer's ID field if it is missing" do
       refute(@document.trailer.key?(:ID))
       exp = assert_raises(HexaPDF::EncryptionError) do
-        @handler.set_up_decryption({Filter: :Standard, V: 1, R: 2, U: 'a' * 48, O: 'a' * 48, P: 15})
+        @handler.set_up_decryption({Filter: :Standard, V: 1, R: 2, U: 'a' * 32, O: 'a' * 32, P: 15})
       end
       assert_match(/Invalid password/i, exp.message)
       assert_equal(['', ''], @document.trailer[:ID].value)
@@ -286,7 +298,7 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
   it "returns an array of permission symbols" do
     perms = @handler.class::Permissions::MODIFY_CONTENT | @handler.class::Permissions::COPY_CONTENT
     @handler.set_up_encryption(permissions: perms)
-    assert_equal([:copy_content, :modify_content], @handler.permissions.sort)
+    assert_equal([:copy_content, :extract_content, :modify_content], @handler.permissions.sort)
   end
 
   describe "handling of metadata streams" do

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -66,6 +66,20 @@ describe HexaPDF::Font::TrueTypeWrapper do
     end
   end
 
+  describe "custom_glyph" do
+    it "returns the specified glyph object" do
+      glyph = @font_wrapper.custom_glyph(0, "str")
+      assert_equal(0, glyph.id)
+      assert_equal("str", glyph.str)
+    end
+
+    it "fails if an invalid glyph id is specified" do
+      exp = assert_raises(HexaPDF::Error) { @font_wrapper.custom_glyph(-5, 'c') }
+      assert_match(/Glyph ID -5 is invalid for font 'Ubuntu-Title'/, exp.message)
+      assert_raises(HexaPDF::Error) { @font_wrapper.custom_glyph(9999, 'c') }
+    end
+  end
+
   describe "encode" do
     it "returns the encoded glyph ID for fonts that are subset" do
       code = @font_wrapper.encode(@font_wrapper.glyph(3))
@@ -83,7 +97,10 @@ describe HexaPDF::Font::TrueTypeWrapper do
     end
 
     it "raises an error if an InvalidGlyph is encoded" do
-      assert_raises(HexaPDF::Error) { @font_wrapper.encode(@font_wrapper.glyph(9999)) }
+      exp = assert_raises(HexaPDF::MissingGlyphError) do
+        @font_wrapper.encode(@font_wrapper.decode_utf8("ö").first)
+      end
+      assert_match(/No glyph for "ö" in font 'Ubuntu-Title'/, exp.message)
     end
   end
 

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -65,6 +65,19 @@ describe HexaPDF::Font::Type1Wrapper do
     end
   end
 
+  describe "custom_glyph" do
+    it "returns the specified glyph object" do
+      glyph = @times_wrapper.custom_glyph(:question, "str")
+      assert_equal(:question, glyph.name)
+      assert_equal("str", glyph.str)
+    end
+
+    it "fails if the provided glyph name is not available for the font" do
+      exp = assert_raises(HexaPDF::Error) { @times_wrapper.custom_glyph(:handicap, 'c') }
+      assert_match(/Glyph named :handicap not found in font 'Times Roman'/, exp.message)
+    end
+  end
+
   describe "encode" do
     describe "uses WinAnsiEncoding as initial encoding for non-symbolic fonts" do
       it "returns the PDF font dictionary using WinAnsiEncoding and encoded glyph" do
@@ -75,7 +88,8 @@ describe HexaPDF::Font::Type1Wrapper do
       end
 
       it "fails if an InvalidGlyph is encoded" do
-        assert_raises(HexaPDF::Error) { @times_wrapper.encode(@times_wrapper.glyph(:ffi)) }
+        exp = assert_raises(HexaPDF::MissingGlyphError) { @times_wrapper.encode(@times_wrapper.glyph(:ffi)) }
+        assert_match(/No glyph for "ffi" in font 'Times Roman'/, exp.message)
       end
 
       it "fails if the encoding does not support the given glyph" do

data/test/hexapdf/layout/test_box.rb

@@ -56,8 +56,8 @@ describe HexaPDF::Layout::Box do
     end
 
     it "allows setting custom properties" do
-      box = create_box(properties: {'key' => :value})
-      assert_equal({'key' => :value}, box.properties)
+      assert_equal({}, create_box(properties: nil).properties)
+      assert_equal({'key' => :value}, create_box(properties: {'key' => :value}).properties)
     end
   end
 
@@ -150,6 +150,10 @@ describe HexaPDF::Layout::Box do
   end
 
   describe "draw" do
+    before do
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+    end
+
     it "draws the box onto the canvas" do
       box = create_box(width: 150, height: 130) do |canvas, _|
         canvas.line_width(15)
@@ -161,7 +165,6 @@ describe HexaPDF::Layout::Box do
       box.style.underlays.add {|canvas, _| canvas.line_width(10) }
       box.style.overlays.add {|canvas, _| canvas.line_width(20) }
 
-      @canvas = HexaPDF::Document.new.pages.add.canvas
       box.draw(@canvas, 5, 5)
       assert_operators(@canvas.contents, [[:save_graphics_state],
                                           [:set_graphics_state_parameters, [:GS1]],
@@ -195,7 +198,6 @@ describe HexaPDF::Layout::Box do
     end
 
     it "draws nothing onto the canvas if the box is empty" do
-      @canvas = HexaPDF::Document.new.pages.add.canvas
       box = create_box
       box.draw(@canvas, 5, 5)
       assert_operators(@canvas.contents, [])
@@ -204,10 +206,17 @@ describe HexaPDF::Layout::Box do
       refute(box.style.border?)
       refute(box.style.overlays?)
     end
+
+    it "wraps the box in optional content markers if the optional_content property is set" do
+      box = create_box(properties: {'optional_content' => 'Text'})
+      box.draw(@canvas, 0, 0)
+      assert_operators(@canvas.contents, [[:begin_marked_content_with_property_list, [:OC, :P1]],
+                                          [:end_marked_content]])
+    end
   end
 
   describe "empty?" do
-    it "is only empty when no drawing operation is specified" do
+    it "is empty when no drawing operation is specified" do
       assert(create_box.empty?)
       refute(create_box {}.empty?)
       refute(create_box(style: {background_color: [5]}).empty?)

data/test/hexapdf/layout/test_column_box.rb

@@ -22,7 +22,7 @@ describe HexaPDF::Layout::ColumnBox do
   end
 
   def check_box(box, width, height, fit_pos = nil)
-    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box fit?")
+    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box didn't fit")
     assert_equal(width, box.width, "box width")
     assert_equal(height, box.height, "box height")
     if fit_pos
@@ -46,6 +46,24 @@ describe HexaPDF::Layout::ColumnBox do
     end
   end
 
+  describe "empty?" do
+    it "is empty if nothing is fit yet" do
+      assert(create_box.empty?)
+    end
+
+    it "is empty if no box fits" do
+      box = create_box(children: [@fixed_size_boxes[0]], columns: [10])
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.empty?)
+    end
+
+    it "is not empty if at least one box fits" do
+      box = create_box(children: [@fixed_size_boxes[0]], columns: [30])
+      check_box(box, 30, 10)
+      refute(box.empty?)
+    end
+  end
+
   describe "fit" do
     [:default, :flow].each do |position|
       it "respects the set initial width, position #{position}" do
@@ -132,27 +150,53 @@ describe HexaPDF::Layout::ColumnBox do
     assert_equal(5, box_b.children.size)
   end
 
-  it "draws the result onto the canvas" do
-    box = create_box(children: @fixed_size_boxes)
-    box.fit(100, 100, @frame)
+  describe "draw_content" do
+    before do
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+    end
+
+    it "draws the result onto the canvas" do
+      box = create_box(children: @fixed_size_boxes)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 100 - box.height)
+      operators = 90.step(to: 20, by: -10).map do |y|
+        [[:save_graphics_state],
+         [:concatenate_matrix, [1, 0, 0, 1, 0, y]],
+         [:move_to, [0, 0]],
+         [:end_path],
+         [:restore_graphics_state]]
+      end
+      operators.concat(90.step(to: 30, by: -10).map do |y|
+          [[:save_graphics_state],
+           [:concatenate_matrix, [1, 0, 0, 1, 55, y]],
+           [:move_to, [0, 0]],
+           [:end_path],
+           [:restore_graphics_state]]
+      end)
+      operators.flatten!(1)
+      assert_operators(@canvas.contents, operators)
+    end
 
-    @canvas = HexaPDF::Document.new.pages.add.canvas
-    box.draw(@canvas, 0, 0)
-    operators = 90.step(to: 20, by: -10).map do |y|
-      [[:save_graphics_state],
-       [:concatenate_matrix, [1, 0, 0, 1, 0, y]],
-       [:move_to, [0, 0]],
-       [:end_path],
-       [:restore_graphics_state]]
+    it "takes a different final location into account" do
+      box = create_box(children: @fixed_size_boxes[0, 2])
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 20, 10)
+      operators = [
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 20, -80]],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 0, 90]],
+        [:move_to, [0, 0]],
+        [:end_path],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 55, 90]],
+        [:move_to, [0, 0]],
+        [:end_path],
+        [:restore_graphics_state],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
     end
-    operators.concat(90.step(to: 30, by: -10).map do |y|
-                       [[:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 55, y]],
-                        [:move_to, [0, 0]],
-                        [:end_path],
-                        [:restore_graphics_state]]
-                     end)
-    operators.flatten!(1)
-    assert_operators(@canvas.contents, operators)
   end
 end

data/test/hexapdf/layout/test_frame.rb

@@ -5,31 +5,31 @@ require 'hexapdf/layout/frame'
 require 'hexapdf/layout/box'
 require 'hexapdf/document'
 
-describe HexaPDF::Layout::Frame do
+describe HexaPDF::Layout::Frame::FitResult do
   it "shows the box's mask area on #draw when using debug output" do
     doc = HexaPDF::Document.new(config: {'debug' => true})
     canvas = doc.pages.add.canvas
     box = HexaPDF::Layout::Box.create(width: 20, height: 20) {}
     result = HexaPDF::Layout::Frame::FitResult.new(box)
-    result.mask = Geom2D::Polygon([0, 0], [0, 20], [20, 20], [20, 0])
+    result.mask = Geom2D::Rectangle(0, 0, 20, 20)
     result.x = result.y = 0
     result.draw(canvas)
     assert_equal(<<~CONTENTS, canvas.contents)
+      /OC /P1 BDC
       q
       0.0 0.501961 0.0 rg
       0.0 0.392157 0.0 RG
       /GS1 gs
-      0 0 m
-      0 20 l
-      20 20 l
-      20 0 l
-      h
+      0 0 20 20 re
       B
       Q
+      EMC
       q
       1 0 0 1 0 0 cm
       Q
     CONTENTS
+    ocg = doc.optional_content.ocgs.first
+    assert_equal([['Debug', ocg]], doc.optional_content.default_configuration[:Order])
   end
 end
 
@@ -38,6 +38,14 @@ describe HexaPDF::Layout::Frame do
     @frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150)
   end
 
+  it "allows accessing the context's document" do
+    assert_nil(@frame.document)
+    context = Minitest::Mock.new
+    context.expect(:document, :document)
+    assert_equal(:document, HexaPDF::Layout::Frame.new(0, 0, 10, 10, context: context).document)
+    context.verify
+  end
+
   it "allows access to the bounding box attributes" do
     assert_equal(5, @frame.left)
     assert_equal(10, @frame.bottom)
@@ -90,7 +98,11 @@ describe HexaPDF::Layout::Frame do
       refute_nil(fit_result)
       @frame.draw(@canvas, fit_result)
       assert_equal(mask, fit_result.mask.bbox.to_a)
-      assert_equal(points, @frame.shape.polygons.map(&:to_a))
+      if @frame.shape.respond_to?(:polygons)
+        assert_equal(points, @frame.shape.polygons.map(&:to_a))
+      else
+        assert_equal(points, [@frame.shape.to_a])
+      end
       @canvas.verify
     end
 
@@ -99,9 +111,9 @@ describe HexaPDF::Layout::Frame do
       areas.each do |area|
         @frame.remove_area(
           case area
-          when :left then Geom2D::Polygon([10, 10], [10, 110], [20, 110], [20, 10])
-          when :right then Geom2D::Polygon([100, 10], [100, 110], [110, 110], [110, 10])
-          when :top then Geom2D::Polygon([10, 110], [110, 110], [110, 100], [10, 100])
+          when :left then Geom2D::Rectangle(10, 10, 10, 100)
+          when :right then Geom2D::Rectangle(100, 10, 10, 100)
+          when :top then Geom2D::Rectangle(10, 100, 100, 10)
           end
         )
       end
@@ -323,7 +335,7 @@ describe HexaPDF::Layout::Frame do
     end
 
     it "can't fit the box if there is no available space" do
-      @frame.remove_area(Geom2D::Polygon([0, 0], [110, 0], [110, 110], [0, 110]))
+      @frame.remove_area(Geom2D::Rectangle(0, 0, 110, 110))
       box = HexaPDF::Layout::Box.create
       refute(@frame.fit(box).success?)
     end
@@ -388,7 +400,7 @@ describe HexaPDF::Layout::Frame do
     # +--------+
     it "works for a region with a hole" do
       frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
-      frame.remove_area(Geom2D::Polygon([20, 20], [80, 20], [80, 80], [20, 80]))
+      frame.remove_area(Geom2D::Rectangle(20, 20, 60, 60))
       check_regions(frame, [[0, 100, 100, 20], [0, 100, 20, 100],
                             [0, 80, 20, 80], [0, 20, 100, 20]])
     end
@@ -400,7 +412,7 @@ describe HexaPDF::Layout::Frame do
     # +--------+
     it "works for a u-shaped frame" do
       frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
-      frame.remove_area(Geom2D::Polygon([30, 100], [70, 100], [70, 60], [30, 60]))
+      frame.remove_area(Geom2D::Rectangle(30, 60, 40, 40))
       check_regions(frame, [[0, 100, 30, 100], [0, 60, 100, 60]])
     end
 
@@ -415,7 +427,7 @@ describe HexaPDF::Layout::Frame do
     it "works for a complicated frame" do
       frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
       top_cut = Geom2D::Polygon([20, 100], [20, 80], [40, 80], [40, 90], [60, 90], [60, 100])
-      left_cut = Geom2D::Polygon([0, 20], [30, 20], [30, 40], [0, 40])
+      left_cut = Geom2D::Rectangle(0, 20, 30, 20)
       frame.remove_area(Geom2D::PolygonSet(top_cut, left_cut))
 
       check_regions(frame, [[0, 100, 20, 60], [0, 90, 20, 50], [0, 80, 100, 40],

data/test/hexapdf/layout/test_image_box.rb

@@ -56,6 +56,10 @@ describe HexaPDF::Layout::ImageBox do
     end
   end
 
+  it "always returns false for empty?" do
+    refute(create_box.empty?)
+  end
+
   describe "draw" do
     it "draws the image" do
       box = create_box(height: 40, style: {padding: [10, 4, 6, 2]})

data/test/hexapdf/layout/test_inline_box.rb

@@ -24,20 +24,28 @@ describe HexaPDF::Layout::InlineBox do
       assert_equal(:top, ibox.valign)
     end
 
+    it "fails if the wrapped box has not width set" do
+      box = HexaPDF::Document.new.layout.text("test is not going good")
+      assert_raises(HexaPDF::Error) { inline_box(box) }
+    end
+  end
+
+  describe "fit_wrapped_box" do
     it "automatically fits the provided box into a frame" do
       ibox = inline_box(HexaPDF::Document.new.layout.text("test is going good", width: 20))
+      ibox.fit_wrapped_box(nil)
       assert_equal(20, ibox.width)
       assert_equal(45, ibox.height)
     end
 
     it "fails if the wrapped box could not be fit" do
       box = HexaPDF::Document.new.layout.text("test is not going good", width: 1)
-      assert_raises(HexaPDF::Error) { inline_box(box) }
+      assert_raises(HexaPDF::Error) { inline_box(box).fit_wrapped_box(nil) }
     end
 
     it "fails if the height is not set explicitly and during fitting" do
       assert_raises(HexaPDF::Error) do
-        inline_box(HexaPDF::Layout::Box.create(width: 10))
+        inline_box(HexaPDF::Layout::Box.create(width: 10)).fit_wrapped_box(nil)
       end
     end
   end
@@ -45,7 +53,9 @@ describe HexaPDF::Layout::InlineBox do
   it "draws the wrapped box at the correct position" do
     doc = HexaPDF::Document.new
     canvas = doc.pages.add.canvas
-    inline_box(doc.layout.text("", width: 20, margin: [15, 10])).draw(canvas, 100, 200)
+    box = inline_box(doc.layout.text("", width: 20, margin: [15, 10]))
+    box.fit_wrapped_box(nil)
+    box.draw(canvas, 100, 200)
     assert_equal("q\n1 0 0 1 110 -99785 cm\nQ\n", canvas.contents)
   end
 
@@ -54,6 +64,10 @@ describe HexaPDF::Layout::InlineBox do
     refute(HexaPDF::Layout::InlineBox.create(width: 10, height: 15) {}.empty?)
   end
 
+  it "returns the style of the box" do
+    assert_same(@box.box.style, @box.style)
+  end
+
   describe "valign" do
     it "has a default value of :baseline" do
       assert_equal(:baseline, @box.valign)