hexapdf 0.46.0 → 1.6.0

data/test/hexapdf/font/cmap/test_writer.rb

@@ -5,7 +5,7 @@ require 'hexapdf/font/cmap/writer'
 
 describe HexaPDF::Font::CMap::Writer do
   before do
-    @cmap_data = <<~EOF
+    @to_unicode_cmap_data = +<<~EOF
       /CIDInit /ProcSet findresource begin
       12 dict begin
       begincmap
@@ -32,35 +32,92 @@ describe HexaPDF::Font::CMap::Writer do
       end
       end
     EOF
-    @mapping = []
-    0x00.upto(0x5e) {|i| @mapping << [i, 0x20 + i] }
-    @mapping << [0x60, 0x90]
-    0x1379.upto(0x137B) {|i| @mapping << [i, 0x90FE + i - 0x1379] }
-    @mapping << [0x3A51, 0x2003E]
+    @cid_cmap_data = +<<~EOF
+      %!PS-Adobe-3.0 Resource-CMap
+      %%DocumentNeededResources: ProcSet (CIDInit)
+      %%IncludeResource: ProcSet (CIDInit)
+      %%BeginResource: CMap (Custom)
+      %%Title: (Custom Adobe Identity 0)
+      %%Version: 1
+      /CIDInit /ProcSet findresource begin
+      12 dict begin
+      begincmap
+      /CIDSystemInfo 3 dict dup begin
+        /Registry (Adobe) def
+        /Ordering (Identity) def
+        /Supplement 0 def
+      end def
+      /CMapName /Custom def
+      /CMapType 1 def
+      /CMapVersion 1 def
+      /WMode 0 def
+      1 begincodespacerange
+      <0000> <FFFF>
+      endcodespacerange
+      1 begincidchar
+      <0060> 144
+      endcidchar
+      1 begincidrange
+      <0000><005E> 32
+      endcidrange
+      endcmap
+      CMapName currentdict /CMap defineresource pop
+      end
+      end
+      %%EndResource
+      %%EOF
+    EOF
+
+    @to_unicode_mapping = []
+    @cid_mapping = []
+    0x00.upto(0x5e) do |i|
+      @to_unicode_mapping << [i, 0x20 + i]
+      @cid_mapping << [i, 0x20 + i]
+    end
+    @to_unicode_mapping << [0x60, 0x90]
+    @cid_mapping << [0x60, 0x90]
+    0x1379.upto(0x137B) do |i|
+      @to_unicode_mapping << [i, 0x90FE + i - 0x1379]
+    end
+    @to_unicode_mapping << [0x3A51, 0x2003E]
   end
 
   describe "create_to_unicode_cmap" do
     it "creates a correct CMap file" do
-      assert_equal(@cmap_data, HexaPDF::Font::CMap.create_to_unicode_cmap(@mapping))
+      assert_equal(@to_unicode_cmap_data,
+                   HexaPDF::Font::CMap.create_to_unicode_cmap(@to_unicode_mapping))
     end
 
     it "works if the last item is a range" do
-      @mapping.pop
-      @cmap_data.sub!(/2 beginbfchar/, '1 beginbfchar')
-      @cmap_data.sub!(/<3A51><d840dc3e>\n/, '')
-      assert_equal(@cmap_data, HexaPDF::Font::CMap.create_to_unicode_cmap(@mapping))
+      @to_unicode_mapping.pop
+      @to_unicode_cmap_data.sub!(/2 beginbfchar/, '1 beginbfchar')
+      @to_unicode_cmap_data.sub!(/<3A51><d840dc3e>\n/, '')
+      assert_equal(@to_unicode_cmap_data,
+                   HexaPDF::Font::CMap.create_to_unicode_cmap(@to_unicode_mapping))
     end
 
     it "works with only ranges" do
-      @mapping.delete_at(-1)
-      @mapping.delete_at(0x5f)
-      @cmap_data.sub!(/\n2 beginbfchar.*endbfchar/m, '')
-      assert_equal(@cmap_data, HexaPDF::Font::CMap.create_to_unicode_cmap(@mapping))
+      @to_unicode_mapping.delete_at(-1)
+      @to_unicode_mapping.delete_at(0x5f)
+      @to_unicode_cmap_data.sub!(/\n2 beginbfchar.*endbfchar/m, '')
+      assert_equal(@to_unicode_cmap_data,
+                   HexaPDF::Font::CMap.create_to_unicode_cmap(@to_unicode_mapping))
     end
 
     it "returns an empty CMap if the mapping is empty" do
-      assert_equal(@cmap_data.sub(/\d+ beginbfchar.*endbfrange/m, ''),
+      assert_equal(@to_unicode_cmap_data.sub(/\d+ beginbfchar.*endbfrange/m, ''),
                    HexaPDF::Font::CMap.create_to_unicode_cmap([]))
     end
   end
+
+  describe "create_cid_cmap" do
+    it "creates a correct CMap file" do
+      assert_equal(@cid_cmap_data, HexaPDF::Font::CMap.create_cid_cmap(@cid_mapping))
+    end
+
+    it "returns an empty CMap if the mapping is empty" do
+      assert_equal(@cid_cmap_data.sub(/\d+ begincidchar.*endcidrange/m, ''),
+                   HexaPDF::Font::CMap.create_cid_cmap([]))
+    end
+  end
 end

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

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
+require 'hexapdf/font/encoding'
 require 'hexapdf/font/encoding/base'
 
 describe HexaPDF::Font::Encoding::Base do
@@ -42,4 +43,23 @@ describe HexaPDF::Font::Encoding::Base do
       assert_nil(@base.code(:Unknown))
     end
   end
+
+  describe "to_compact_array" do
+    before do
+      @base.code_to_name[66] = :B
+      @base.code_to_name[67] = :C
+      @base.code_to_name[20] = :space
+      @base.code_to_name[28] = :D
+      @base.code_to_name[29] = :E
+    end
+
+    it "returns the difference array" do
+      assert_equal([20, :space, 28, :D, :E, 65, :A, :B, :C], @base.to_compact_array)
+    end
+
+    it "ignores the codes that are the same in the base encoding" do
+      std_encoding = HexaPDF::Font::Encoding.for_name(:StandardEncoding)
+      assert_equal([20, :space, 28, :D, :E, ], @base.to_compact_array(base_encoding: std_encoding))
+    end
+  end
 end

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

@@ -32,7 +32,7 @@ describe HexaPDF::Font::Encoding::GlyphList do
 
     it "maps special uXXXX[XX] names to unicode values" do
       assert_equal("A", @list.name_to_unicode(:u0041))
-      assert_equal("" << "1F000".hex, @list.name_to_unicode(:u1F000))
+      assert_equal(+'' << "1F000".hex, @list.name_to_unicode(:u1F000))
     end
 
     it "maps Zapf Dingbats glyph names to their unicode" do

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -51,7 +51,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
       glyphs = @font_wrapper.decode_utf8("😁")
       assert_equal(1, glyphs.length)
       assert_kind_of(HexaPDF::Font::InvalidGlyph, glyphs.first)
-      assert_equal('' << 128_513, glyphs.first.str)
+      assert_equal(+'' << 128_513, glyphs.first.str)
     end
   end
 
@@ -71,11 +71,17 @@ describe HexaPDF::Font::TrueTypeWrapper do
                    glyph.inspect)
     end
 
+    it "caches glyphs based on the id and string" do
+      glyph = @font_wrapper.glyph(17)
+      assert_same(glyph, @font_wrapper.glyph(17))
+      refute_same(glyph, @font_wrapper.glyph(17, "1"))
+    end
+
     it "invokes font.on_missing_glyph for missing glyphs" do
       glyph = @font_wrapper.glyph(9999)
       assert_kind_of(HexaPDF::Font::InvalidGlyph, glyph)
       assert_equal(0, glyph.id)
-      assert_equal('' << 0xFFFD, glyph.str)
+      assert_equal(+'' << 0xFFFD, glyph.str)
     end
   end
 
@@ -99,14 +105,23 @@ describe HexaPDF::Font::TrueTypeWrapper do
       assert_equal([1].pack('n'), code)
       code = @font_wrapper.encode(@font_wrapper.glyph(10))
       assert_equal([2].pack('n'), code)
+      code = @font_wrapper.encode(@font_wrapper.glyph(10, "o"))
+      assert_equal([3].pack('n'), code)
     end
 
     it "returns the encoded glyph ID for fonts that are not subset" do
       @font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font, subset: false)
       code = @font_wrapper.encode(@font_wrapper.glyph(3))
-      assert_equal([3].pack('n'), code)
+      assert_equal([1].pack('n'), code)
       code = @font_wrapper.encode(@font_wrapper.glyph(10))
-      assert_equal([10].pack('n'), code)
+      assert_equal([2].pack('n'), code)
+      code = @font_wrapper.encode(@font_wrapper.glyph(10, "o"))
+      assert_equal([3].pack('n'), code)
+    end
+
+    it "doesn't use char codes 13, 40, 41 and 92 because they would need to be escaped" do
+      codes = 1.upto(93).map {|i| @font_wrapper.encode(@font_wrapper.glyph(i)) }.join
+      assert_equal([1..12, 14..39, 42..91, 93..97].flat_map(&:to_a).pack('n*'), codes)
     end
 
     it "raises an error if an InvalidGlyph is encoded" do
@@ -180,16 +195,27 @@ describe HexaPDF::Font::TrueTypeWrapper do
     it "with fonts that are not subset (only differences to other case)" do
       @font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font, subset: false)
       @font_wrapper.encode(@font_wrapper.glyph(3))
+      @font_wrapper.encode(@font_wrapper.glyph(3, "-"))
       glyph = @font_wrapper.decode_utf8('H').first
       @font_wrapper.encode(glyph)
       @doc.dispatch_message(:complete_objects)
 
       dict = @font_wrapper.pdf_object
 
-      assert_equal(HexaPDF::Font::CMap.create_to_unicode_cmap([[3, ' '.ord], [glyph.id, 'H'.ord]]),
+      assert_equal(HexaPDF::Font::CMap.create_to_unicode_cmap([[1, ' '.ord], [2, '-'.ord],
+                                                               [3, 'H'.ord]]),
                    dict[:ToUnicode].stream)
+      assert_equal(HexaPDF::Font::CMap.create_cid_cmap([[1, 3], [2, 3], [3, glyph.id]]),
+                   dict[:Encoding].stream)
       assert_equal([glyph.id, [glyph.width]], dict[:DescendantFonts][0][:W].value)
     end
+
+    it "handles the case where the font is added but then not used and deleted" do
+      @doc.task(:optimize, compact: true)
+      assert(@font_wrapper.pdf_object.null?)
+      @doc.dispatch_message(:complete_objects)
+      assert(@font_wrapper.pdf_object.null?)
+    end
   end
 
   describe "font file embedding" do

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -56,7 +56,7 @@ describe HexaPDF::Font::Type1Wrapper do
       glyphs = @times_wrapper.decode_utf8("😁")
       assert_equal(1, glyphs.length)
       assert_kind_of(HexaPDF::Font::InvalidGlyph, glyphs.first)
-      assert_equal('' << 128_513, glyphs.first.str)
+      assert_equal(+'' << 128_513, glyphs.first.str)
     end
   end
 
@@ -140,5 +140,12 @@ describe HexaPDF::Font::Type1Wrapper do
     it "makes sure that the PDF dictionaries are indirect" do
       assert(@times_wrapper.pdf_object.indirect?)
     end
+
+    it "handles the case where the font is added but then not used and deleted" do
+      @doc.task(:optimize, compact: true)
+      assert(@times_wrapper.pdf_object.null?)
+      @doc.dispatch_message(:complete_objects)
+      assert(@times_wrapper.pdf_object.null?)
+    end
   end
 end

data/test/hexapdf/font/true_type/test_table.rb

@@ -13,6 +13,18 @@ describe HexaPDF::Font::TrueType::Table do
     @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('tagg', 0, 0, @file.io.string.length)
   end
 
+  describe "self.calculate_checksum" do
+    it "works for data with a length divisible by four" do
+      klass = HexaPDF::Font::TrueType::Table
+      assert_equal(256, klass.calculate_checksum("\x00\x00\x00\x01\x00\x00\x00\xFF"))
+    end
+
+    it "works for data with a length not divisible by four" do
+      klass = HexaPDF::Font::TrueType::Table
+      assert_equal(512, klass.calculate_checksum("\x00\x00\x00\x01\x00\x00\x00\xFF\x00\x00\x01"))
+    end
+  end
+
   describe "initialize" do
     it "reads the data from the associated file" do
       table = TrueTypeTestTable.new(@file, @entry)

data/test/hexapdf/layout/test_box.rb

@@ -5,6 +5,14 @@ require 'hexapdf/document'
 require 'hexapdf/layout/box'
 
 describe HexaPDF::Layout::Box::FitResult do
+  it "allows setting the status to failure" do
+    result = HexaPDF::Layout::Box::FitResult.new(nil)
+    result.overflow!
+    refute(result.failure?)
+    result.failure!
+    assert(result.failure?)
+  end
+
   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
@@ -270,8 +278,6 @@ describe HexaPDF::Layout::Box do
                                           [:restore_graphics_state],
                                           [:save_graphics_state],
                                           [:set_line_width, [5]],
-                                          [:append_rectangle, [5, 5, 150, 130]],
-                                          [:clip_path_non_zero], [:end_path],
                                           [:append_rectangle, [7.5, 7.5, 145, 125]],
                                           [:stroke_path],
                                           [:restore_graphics_state],

data/test/hexapdf/layout/test_container_box.rb

@@ -10,6 +10,10 @@ describe HexaPDF::Layout::ContainerBox do
     @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
   end
 
+  def child_box(height: 0, width: 0, **style_properties)
+    @doc.layout.box(height: height, width: width, style: style_properties)
+  end
+
   def create_box(children, **kwargs)
     HexaPDF::Layout::ContainerBox.new(children: Array(children), **kwargs)
   end
@@ -48,17 +52,41 @@ describe HexaPDF::Layout::ContainerBox do
 
   describe "fit_content" do
     it "fits the children according to their mask_mode, valign, and align style properties" do
-      box = create_box([@doc.layout.box(height: 20),
-                        @doc.layout.box(height: 20, style: {valign: :bottom, mask_mode: :fill_horizontal}),
-                        @doc.layout.box(width: 20, style: {align: :right, mask_mode: :fill_vertical})])
+      box = create_box([child_box(height: 20),
+                        child_box(height: 20, valign: :bottom, mask_mode: :fill_horizontal),
+                        child_box(width: 20, align: :right, mask_mode: :fill_vertical)])
       check_box(box, 100, 100, [[0, 80], [0, 0], [80, 20]])
     end
 
     it "respects the initially set width/height as well as border/padding" do
-      box = create_box(@doc.layout.box(height: 20), height: 50, width: 40,
+      box = create_box(child_box(height: 20), height: 50, width: 40,
                        style: {padding: 2, border: {width: 3}})
       check_box(box, 40, 50, [[5, 75]])
     end
+
+    it "fails if splitting is not allowed and the content is too big" do
+      box = create_box([child_box(height: 80), child_box(height: 30)])
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.fit_result.failure?)
+    end
+
+    it "splits the box if splitting is allowed and the content is too big" do
+      box = create_box([child_box(height: 80), child_box(height: 30)], splitable: true)
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.fit_result.overflow?)
+    end
+  end
+
+  describe "split_content" do
+    it "assigns the overflown boxes to the split box" do
+      box = create_box([child_box(height: 80), child_box(height: 30)], splitable: true)
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.fit_result.overflow?)
+      box_a, box_b = box.split
+      assert_same(box, box_a)
+      assert(box_b.split_box?)
+      assert_equal(1, box_b.children.size)
+    end
   end
 
   describe "draw_content" do
@@ -67,10 +95,10 @@ describe HexaPDF::Layout::ContainerBox do
     end
 
     it "draws the result onto the canvas" do
-      child_box = @doc.layout.box(height: 20) do |canvas, b|
+      cbox = @doc.layout.box(height: 20) do |canvas, b|
         canvas.line(0, 0, b.content_width, b.content_height).end_path
       end
-      box = create_box(child_box)
+      box = create_box(cbox)
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 50)
       assert_operators(@canvas.contents, [[:save_graphics_state],

data/test/hexapdf/layout/test_list_box.rb

@@ -185,7 +185,7 @@ describe HexaPDF::Layout::ListBox do
         [:set_font_and_size, [:F1, 11]],
         [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 1.15, 92.487]],
+        [:move_text, [1.15, 92.487]],
         [:show_text, ["\x95".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -197,7 +197,7 @@ describe HexaPDF::Layout::ListBox do
         [:set_font_and_size, [:F1, 11]],
         [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 1.15, 82.487]],
+        [:move_text, [1.15, 82.487]],
         [:show_text, ["\x95".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -219,7 +219,7 @@ describe HexaPDF::Layout::ListBox do
         [:set_text_rise, [-6.111111]],
         [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 0.1985, 100]],
+        [:move_text, [0.1985, 100]],
         [:show_text, ["m".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -241,7 +241,7 @@ describe HexaPDF::Layout::ListBox do
         [:set_text_rise, [-6.111111]],
         [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 0.8145, 100]],
+        [:move_text, [0.8145, 100]],
         [:show_text, ["n".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -263,7 +263,7 @@ describe HexaPDF::Layout::ListBox do
         [:set_font_and_size, [:F1, 11]],
         [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 6.75, 92.487]],
+        [:move_text, [6.75, 92.487]],
         [:show_text, ["1.".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -275,7 +275,7 @@ describe HexaPDF::Layout::ListBox do
         [:set_font_and_size, [:F1, 11]],
         [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 6.75, 82.487]],
+        [:move_text, [6.75, 82.487]],
         [:show_text, ["2.".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -314,7 +314,7 @@ describe HexaPDF::Layout::ListBox do
         [:save_graphics_state],
         [:set_font_and_size, [:F1, 10]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 1.5, 93.17]],
+        [:move_text, [1.5, 93.17]],
         [:show_text, ["\x95".b]],
         [:end_text],
         [:restore_graphics_state],

data/test/hexapdf/layout/test_page_style.rb

@@ -49,7 +49,7 @@ describe HexaPDF::Layout::PageStyle do
       assert_equal("", page1.contents)
       assert_equal(523.275591, style.frame.width)
 
-      page2 = style.create_page(@doc)
+      style.create_page(@doc)
       refute_same(frame1, style.frame)
     end
 

data/test/hexapdf/layout/test_style.rb

@@ -136,6 +136,19 @@ describe HexaPDF::Layout::Style::Quad do
       assert_equal(new_quad.bottom, quad.bottom)
       assert_equal(new_quad.left, quad.left)
     end
+
+    it "works with a Hash as value" do
+      quad = create_quad(top: 5, left: 10)
+      assert_equal(5, quad.top)
+      assert_equal(0, quad.bottom)
+      assert_equal(10, quad.left)
+      assert_equal(0, quad.right)
+      quad.set(right: 7)
+      assert_equal(5, quad.top)
+      assert_equal(0, quad.bottom)
+      assert_equal(10, quad.left)
+      assert_equal(7, quad.right)
+    end
   end
 
   it "can be asked if it contains only a single value" do
@@ -199,8 +212,6 @@ describe HexaPDF::Layout::Style::Border do
         assert_operators(@canvas.contents, [[:save_graphics_state],
                                             [:set_device_gray_stroking_color, [0.5]],
                                             [:set_line_width, [10]],
-                                            [:append_rectangle, [0, 0, 100, 100]],
-                                            [:clip_path_non_zero], [:end_path],
                                             [:append_rectangle, [5, 5, 90, 90]],
                                             [:stroke_path],
                                             [:restore_graphics_state]])
@@ -213,8 +224,6 @@ describe HexaPDF::Layout::Style::Border do
                [:set_device_gray_stroking_color, [0.5]],
                [:set_line_width, [10]],
                [:set_line_cap_style, [2]],
-               [:append_rectangle, [0, 0, 200, 300]],
-               [:clip_path_non_zero], [:end_path],
                [:set_line_dash_pattern, [[10, 20], 25]],
                [:move_to, [0, 295]], [:line_to, [200, 295]],
                [:move_to, [200, 5]], [:line_to, [0, 5]],
@@ -234,8 +243,6 @@ describe HexaPDF::Layout::Style::Border do
                [:set_device_gray_stroking_color, [0.5]],
                [:set_line_width, [10]],
                [:set_line_cap_style, [1]],
-               [:append_rectangle, [0, 0, 200, 300]],
-               [:clip_path_non_zero], [:end_path],
                [:set_line_dash_pattern, [[10, 20], 25]],
                [:move_to, [0, 295]], [:line_to, [200, 295]],
                [:move_to, [200, 5]], [:line_to, [0, 5]],
@@ -255,8 +262,6 @@ describe HexaPDF::Layout::Style::Border do
                [:set_device_gray_stroking_color, [0.5]],
                [:set_line_width, [10]],
                [:set_line_cap_style, [1]],
-               [:append_rectangle, [0, 0, 100, 200]],
-               [:clip_path_non_zero], [:end_path],
                [:set_line_dash_pattern, [[0, 18], 13]],
                [:move_to, [0, 195]], [:line_to, [100, 195]],
                [:move_to, [100, 5]], [:line_to, [0, 5]],
@@ -275,8 +280,6 @@ describe HexaPDF::Layout::Style::Border do
         assert_operators(@canvas.contents, [[:save_graphics_state],
                                             [:set_device_gray_stroking_color, [0.5]],
                                             [:set_line_width, [10]],
-                                            [:append_rectangle, [-5, -5, 110, 110]],
-                                            [:clip_path_non_zero], [:end_path],
                                             [:append_rectangle, [0, 0, 100, 100]],
                                             [:stroke_path],
                                             [:restore_graphics_state]])
@@ -748,6 +751,30 @@ describe HexaPDF::Layout::Style do
     end
   end
 
+  describe "each_property" do
+    it "yields all set properties with their values" do
+      @style.font_size = 5
+      @style.line_spacing = 1.2
+      assert_equal(0.005, @style.scaled_font_size)
+      assert_equal([[:font, @style.font], [:font_size, 5], [:horizontal_scaling, 100],
+                    [:line_spacing, @style.line_spacing]],
+                   @style.each_property.to_a.sort)
+    end
+  end
+
+  describe "merge" do
+    it "merges all set properties" do
+      @style.font_size = 5
+      @style.line_spacing = 1.2
+      new_style = HexaPDF::Layout::Style.new
+      new_style.update(font_size: 3, line_spacing: {type: :fixed, value: 2.5})
+      new_style.merge(@style)
+      assert_equal(5, new_style.font_size)
+      assert_equal(:proportional, new_style.line_spacing.type)
+      assert_equal(1.2, new_style.line_spacing.value)
+    end
+  end
+
   it "has several simple and dynamically generated properties with default values" do
     @style = HexaPDF::Layout::Style.new
     assert_raises(HexaPDF::Error) { @style.font }
@@ -790,6 +817,7 @@ describe HexaPDF::Layout::Style do
     assert_equal(:left, @style.align)
     assert_equal(:top, @style.valign)
     assert_equal(:default, @style.mask_mode)
+    assert_equal({}, @style.box_options)
   end
 
   it "allows using a non-standard setter for generated properties" do
@@ -800,8 +828,8 @@ describe HexaPDF::Layout::Style do
     @style.stroke_dash_pattern(5, 2)
     assert_equal([[5], 2], @style.stroke_dash_pattern.to_operands)
 
-    @style.line_spacing(1.2)
-    assert_equal([:proportional, 1.2], [@style.line_spacing.type, @style.line_spacing.value])
+    @style.line_spacing(HexaPDF::Layout::Style::LineSpacing.new(type: :double))
+    assert_equal([:proportional, 2], [@style.line_spacing.type, @style.line_spacing.value])
   end
 
   it "allows checking for valid values" do
@@ -872,6 +900,9 @@ describe HexaPDF::Layout::Style do
     end
 
     it "handles subscript" do
+      @style.subscript = false
+      assert_equal(10, @style.calculated_font_size)
+      assert_equal(0, @style.calculated_text_rise)
       @style.subscript = true
       assert_in_delta(5.83, @style.calculated_font_size)
       assert_in_delta(0.00583, @style.scaled_font_size, 0.000001)
@@ -879,6 +910,9 @@ describe HexaPDF::Layout::Style do
     end
 
     it "handles superscript" do
+      @style.superscript = false
+      assert_equal(10, @style.calculated_font_size)
+      assert_equal(0, @style.calculated_text_rise)
       @style.superscript = true
       assert_in_delta(5.83, @style.calculated_font_size)
       assert_in_delta(3.30, @style.calculated_text_rise)