hexapdf 0.23.0 → 0.24.0

data/test/hexapdf/layout/test_list_box.rb

@@ -0,0 +1,249 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../content/common'
+require 'hexapdf/document'
+require 'hexapdf/layout/list_box'
+
+describe HexaPDF::Layout::ListBox do
+  before do
+    @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
+    inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {}
+    @text_boxes = 5.times.map do
+      HexaPDF::Layout::TextBox.new(items: [inline_box] * 15, style: {position: :default})
+    end
+  end
+
+  def create_box(**kwargs)
+    HexaPDF::Layout::ListBox.new(content_indentation: 10, **kwargs)
+  end
+
+  def check_box(box, width, height, fit_pos = nil)
+    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box fit?")
+    assert_equal(width, box.width, "box width")
+    assert_equal(height, box.height, "box height")
+    if fit_pos
+      results = box.instance_variable_get(:@results)
+      results.each_with_index do |box_fitter, item_index|
+        box_fitter.fit_results.each_with_index do |fit_result, result_index|
+          x, y = fit_pos.shift
+          assert_equal(x, fit_result.x, "item #{item_index}, result #{result_index}, x")
+          assert_equal(y, fit_result.y, "item #{item_index}, result #{result_index}, y")
+        end
+      end
+      assert(fit_pos.empty?)
+    end
+  end
+
+  describe "initialize" do
+    it "creates a new instance with the given arguments" do
+      box = create_box(children: [:a], item_type: :circle, content_indentation: 15,
+                       start_number: 4, item_spacing: 20)
+      assert_equal([:a], box.children)
+      assert_equal(:circle, box.item_type)
+      assert_equal(15, box.content_indentation)
+      assert_equal(4, box.start_number)
+      assert_equal(20, box.item_spacing)
+      assert(box.supports_position_flow?)
+    end
+  end
+
+  describe "fit" do
+    [:default, :flow].each do |position|
+      it "respects the set initial width, position #{position}" do
+        box = create_box(children: @text_boxes[0, 2], width: 50, style: {position: position})
+        check_box(box, 50, 80)
+      end
+
+      it "respects the set initial height, position #{position}" do
+        box = create_box(children: @text_boxes[0, 2], height: 50, style: {position: position})
+        check_box(box, 100, 40)
+      end
+
+      it "respects the border and padding around all list items, position #{position}" do
+        box = create_box(children: @text_boxes[0, 2],
+                         style: {border: {width: [5, 4, 3, 2]}, padding: [5, 4, 3, 2], position: position})
+        check_box(box, 100, 76, [[14, 60], [14, 30]])
+      end
+    end
+
+    it "uses the frame's current cursor position and available width/height when position=:default" do
+      @frame.remove_area(Geom2D::Polygon([0, 0], [10, 0], [10, 90], [100, 90], [100, 100], [0, 100]))
+      box = create_box(children: @text_boxes[0, 2])
+      check_box(box, 90, 40, [[20, 70], [20, 50]])
+    end
+
+    it "respects the frame's shape when style position=:flow" do
+      @frame.remove_area(Geom2D::Polygon([0, 0], [0, 40], [40, 40], [40, 0]))
+      box = create_box(children: @text_boxes[0, 4], style: {position: :flow})
+      check_box(box, 100, 90, [[10, 80], [10, 60], [10, 40], [50, 10]])
+    end
+
+    it "respects the content indentation" do
+      box = create_box(children: @text_boxes[0, 1], content_indentation: 30)
+      check_box(box, 100, 30, [[30, 70]])
+    end
+
+    it "respects the spacing between list items" do
+      box = create_box(children: @text_boxes[0, 2], item_spacing: 30)
+      check_box(box, 100, 70, [[10, 80], [10, 30]])
+    end
+  end
+
+  describe "split" do
+    it "splits before a list item if no part of it will fit" do
+      box = create_box(children: @text_boxes[0, 2], height: 20)
+      box.fit(100, 100, @frame)
+      box_a, box_b = box.split(100, 100, @frame)
+      assert_same(box, box_a)
+      assert_equal(:show_first_marker, box_b.split_box?)
+      assert_equal(1, box_a.instance_variable_get(:@results)[0].fit_results.size)
+      assert_equal(1, box_b.children.size)
+      assert_equal(2, box_b.start_number)
+    end
+
+    it "splits a list item if some part of it will fit" do
+      box = create_box(children: @text_boxes[0, 2], height: 10)
+      box.fit(100, 100, @frame)
+      box_a, box_b = box.split(100, 100, @frame)
+      assert_same(box, box_a)
+      assert_equal(:hide_first_marker, box_b.split_box?)
+      assert_equal(1, box_a.instance_variable_get(:@results)[0].fit_results.size)
+      assert_equal(2, box_b.children.size)
+      assert_equal(1, box_b.start_number)
+    end
+  end
+
+  describe "draw" do
+    before do
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+      draw_block = lambda {|canvas, box| }
+      @fixed_size_boxes = 5.times.map { HexaPDF::Layout::Box.new(width: 20, height: 10, &draw_block) }
+    end
+
+    it "draws the result" do
+      box = create_box(children: @fixed_size_boxes[0, 2])
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 0)
+      operators = [
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 10]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 1.5, 93.17]],
+        [:show_text, ["\x95".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 90]],
+        [:restore_graphics_state],
+
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 10]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 1.5, 83.17]],
+        [:show_text, ["\x95".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 80]],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
+    end
+
+    it "draws a cicle as marker" do
+      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :circle)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 0)
+      operators = [
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 5]],
+        [:set_text_rise, [-5.555556]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 0.635, 100]],
+        [:show_text, ["m".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 90]],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
+    end
+
+    it "draws a square as marker" do
+      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :square)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 0)
+      operators = [
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 5]],
+        [:set_text_rise, [-5.555556]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 1.195, 100]],
+        [:show_text, ["n".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 90]],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
+    end
+
+    it "draws decimal numbers as marker" do
+      box = create_box(children: @fixed_size_boxes[0, 2], item_type: :decimal,
+                       content_indentation: 20)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 0)
+      operators = [
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 10]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 7.5, 93.17]],
+        [:show_text, ["1.".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 20, 90]],
+        [:restore_graphics_state],
+
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 10]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 7.5, 83.17]],
+        [:show_text, ["2.".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 20, 80]],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
+    end
+
+    it "allows drawing custom markers" do
+      marker = lambda do |doc, list_box, index|
+        HexaPDF::Layout::Box.create(width: 10, height: 10) {}
+      end
+      box = create_box(children: @fixed_size_boxes[0, 1], item_type: marker)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 0)
+      operators = [
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 0, 90]],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 90]],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
+    end
+
+    it "fails for unknown item types" do
+      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :unknown)
+      box.fit(100, 100, @frame)
+      assert_raises(HexaPDF::Error) { box.draw(@canvas, 0, 0) }
+    end
+  end
+end

data/test/hexapdf/layout/test_text_box.rb

@@ -12,7 +12,7 @@ describe HexaPDF::Layout::TextBox do
   end
 
   def create_box(items, **kwargs)
-    HexaPDF::Layout::TextBox.new(items, **kwargs)
+    HexaPDF::Layout::TextBox.new(items: items, **kwargs)
   end
 
   describe "initialize" do
@@ -20,6 +20,10 @@ describe HexaPDF::Layout::TextBox do
       box = create_box([], width: 100)
       assert_equal(100, box.width)
     end
+
+    it "supports flowing text around other content" do
+      assert(create_box([]).supports_position_flow?)
+    end
   end
 
   describe "fit" do
@@ -104,11 +108,22 @@ describe HexaPDF::Layout::TextBox do
       assert_equal([nil, box], box.split(100, 100, @frame))
     end
 
-    it "splits the box if necessary" do
+    it "splits the box if necessary when using non-flowing text" do
       box = create_box([@inline_box] * 10)
       boxes = box.split(50, 10, @frame)
       assert_equal(2, boxes.length)
       assert_equal(box, boxes[0])
+      refute(boxes[0].split_box?)
+      assert(boxes[1].split_box?)
+      assert_equal(5, boxes[1].instance_variable_get(:@items).length)
+    end
+
+    it "splits the box if necessary when using flowing text that results in a wider box" do
+      @frame.remove_area(Geom2D::Polygon.new([[0, 100], [50, 100], [50, 10], [0, 10]]))
+      box = create_box([@inline_box] * 60, style: {position: :flow})
+      boxes = box.split(50, 100, @frame)
+      assert_equal(2, boxes.length)
+      assert_equal(box, boxes[0])
       assert_equal(5, boxes[1].instance_variable_get(:@items).length)
     end
   end

data/test/hexapdf/layout/test_text_fragment.rb

@@ -369,7 +369,7 @@ describe HexaPDF::Layout::TextFragment do
   end
 
   it "can be inspected" do
-    frag = setup_fragment(@font.decode_utf8("H"))
+    frag = setup_fragment(@font.decode_utf8("H") << 5)
     assert_match(/:H/, frag.inspect)
   end
 end

data/test/hexapdf/layout/test_text_layouter.rb

@@ -57,6 +57,24 @@ module TestTextLayouterHelpers
   end
 end
 
+describe HexaPDF::Layout::TextLayouter::Box do
+  it "can describe itself" do
+    assert_equal('Box["test"]', HexaPDF::Layout::TextLayouter::Box.new("test").inspect)
+  end
+end
+
+describe HexaPDF::Layout::TextLayouter::Glue do
+  it "can describe itself" do
+    assert_equal('Glue["test"]', HexaPDF::Layout::TextLayouter::Glue.new("test", 5, 5).inspect)
+  end
+end
+
+describe HexaPDF::Layout::TextLayouter::Penalty do
+  it "can describe itself" do
+    assert_equal('Penalty[100 10 nil]', HexaPDF::Layout::TextLayouter::Penalty.new(100, 10).inspect)
+  end
+end
+
 describe HexaPDF::Layout::TextLayouter::SimpleTextSegmentation do
   include TestTextLayouterHelpers
 
@@ -556,36 +574,43 @@ describe HexaPDF::Layout::TextLayouter do
       end
     end
 
-    describe "breaks a text fragment into parts if it is wider than the available width" do
+    describe "breaking into parts of a too wide text fragment" do
       before do
-        @str = " This is averylongstring"
+        @str = " Thisisaverylongstring"
         @frag = HexaPDF::Layout::TextFragment.create(@str, font: @font)
       end
 
-      it "works with fixed width" do
+      it "arranges the parts if single parts fit into the available space" do
         result = @layouter.fit([@frag], 20, 100)
         assert(result.remaining_items.empty?)
         assert_equal(:success, result.status)
-        assert_equal(@str.delete(" ").length, result.lines.sum {|l| l.items.sum {|i| i.items.count } })
-        assert_equal(54, result.height)
+        assert_equal(@str.strip.length, result.lines.sum {|l| l.items.sum {|i| i.items.count } })
+        assert_equal(45, result.height)
+      end
 
+      it "works even if a single part doesn't fit" do
         result = @layouter.fit([@frag], 1, 100)
-        assert_equal(8, result.remaining_items.count)
+        assert_equal(@str.strip.length, result.remaining_items.count)
         assert_equal(:box_too_wide, result.status)
       end
 
-      it "works with variable width" do
-        width_block = lambda do |height, line_height|
-          # 'averylongstring' would fit when only considering height but not height + line_height
-          if height + line_height < 15
-            63
-          else
-            10
-          end
-        end
-        result = @layouter.fit([@frag], width_block, 30)
+      it "works if the parts of the broken fragment are used in another .fit call" do
+        text = "This is a long string to test"
+        frag = HexaPDF::Layout::TextFragment.create(text, font: @font)
+        result = @layouter.fit([frag], lambda {|h, _| h > 17 ? 0 : 25 }, 20)
+        refute(result.remaining_items.empty?)
         assert_equal(:height, result.status)
-        assert_equal([26.95, 9.44, 7.77], result.lines.map {|l| l.width.round(3) })
+        assert_equal(["This", "is a"],
+                     result.lines.map {|l| l.items.map {|tf| tf.items.map(&:str).join }.join })
+
+        # Simulating a split text box where the second part is tried to fit into same remaining
+        # space
+        result = @layouter.fit(result.remaining_items, 25, 1)
+
+        # Now fit into next available space
+        result = @layouter.fit(result.remaining_items, 25, 100)
+        assert_equal(["long", "string", "to test"],
+                     result.lines.map {|l| l.items.map {|tf| tf.items.map(&:str).join }.join })
       end
     end
 

data/test/hexapdf/layout/test_width_from_polygon.rb

@@ -32,6 +32,13 @@ describe HexaPDF::Layout::WidthFromPolygon do
     assert_equal([2.5, 7.5], ws.call(5, 1))
   end
 
+  it "works for polygons in counterclockwise order with some segments crossing only top or bottom" do
+    ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([55.0, 65.0], [70, 65], [70.0, 50.0],
+                                                              [100.0, 50.0], [100.0, 63.0], [120, 63],
+                                                              [120, 70], [55, 70])))
+    assert_equal([70, 30], ws.call(0, 10))
+  end
+
   it "works if some segments only cross the top line" do
     ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [2, 11], [4, 9], [6, 11], [10, 10],
                                            [10, 0]))
@@ -60,6 +67,12 @@ describe HexaPDF::Layout::WidthFromPolygon do
     assert_equal([5, 5], ws.call(4, 2))
   end
 
+  it "works in case of small floating point differences" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [10, 0], [10, 5.99999999999994], [8, 6], [8, 10],
+                                           [6, 10], [6, 5], [0, 5]))
+    assert_equal([6, 4], ws.call(4.0, 3.0))
+  end
+
   describe "multiple polygons" do
     it "rectangle in rectangle" do
       ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),

data/test/hexapdf/test_composer.rb

@@ -249,6 +249,17 @@ describe HexaPDF::Composer do
     end
   end
 
+  describe "box" do
+    it "creates the named box and draws it on the canvas" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+      image = @composer.document.images.add(File.join(TEST_DATA_DIR, 'images', 'gray.jpg'))
+      @composer.box(:list, width: 20) {|list| list.image(image) }
+      assert_equal(20, box.width)
+      assert_same(image, box.children[0].image)
+    end
+  end
+
   describe "draw_box" do
     def create_box(**kwargs)
       HexaPDF::Layout::Box.new(**kwargs) {}

data/test/hexapdf/test_dictionary_fields.rb

@@ -37,7 +37,7 @@ describe HexaPDF::DictionaryFields do
     describe "convert" do
       it "returns the converted object, using the first usable converter" do
         doc = Minitest::Mock.new
-        doc.expect(:wrap, :data, [Hash, Hash])
+        doc.expect(:wrap, :data, [Hash], type: Integer)
         @field.convert({}, doc)
         doc.verify
 
@@ -67,20 +67,20 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion from a hash" do
-      @doc.expect(:wrap, :data, [Hash, Hash])
+      @doc.expect(:wrap, :data, [Hash], type: Class)
       @field.convert({Test: :value}, @doc)
       @doc.verify
     end
 
     it "allows conversion from a Dictionary" do
-      @doc.expect(:wrap, :data, [HexaPDF::Dictionary, Hash])
+      @doc.expect(:wrap, :data, [HexaPDF::Dictionary], type: Class)
       @field.convert(HexaPDF::Dictionary.new({Test: :value}), @doc)
       @doc.verify
     end
 
     it "allows conversion from an HexaPDF::Dictionary to a Stream if stream data is set" do
       @field = self.class::Field.new(HexaPDF::Stream)
-      @doc.expect(:wrap, :data, [HexaPDF::Dictionary, Hash])
+      @doc.expect(:wrap, :data, [HexaPDF::Dictionary], type: Class)
       data = HexaPDF::PDFData.new({}, 0, 0, "")
       @field.convert(HexaPDF::Dictionary.new(data), @doc)
       @doc.verify
@@ -108,7 +108,7 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion from an array" do
-      @doc.expect(:wrap, :data, [[1, 2], {type: HexaPDF::PDFArray}])
+      @doc.expect(:wrap, :data, [[1, 2]], type: HexaPDF::PDFArray)
       @field.convert([1, 2], @doc)
       @doc.verify
     end
@@ -208,14 +208,14 @@ describe HexaPDF::DictionaryFields do
 
     it "allows conversion from a string" do
       @doc = Minitest::Mock.new
-      @doc.expect(:wrap, :data, [{F: 'test'}, {type: HexaPDF::Type::FileSpecification}])
+      @doc.expect(:wrap, :data, [{F: 'test'}], type: HexaPDF::Type::FileSpecification)
       @field.convert('test', @doc)
       @doc.verify
     end
 
     it "allows conversion from a hash/dictionary" do
       @doc = Minitest::Mock.new
-      @doc.expect(:wrap, :data, [{F: 'test'}, {type: HexaPDF::Type::FileSpecification}])
+      @doc.expect(:wrap, :data, [{F: 'test'}], type: HexaPDF::Type::FileSpecification)
       @field.convert({F: 'test'}, @doc)
       @doc.verify
     end
@@ -232,7 +232,7 @@ describe HexaPDF::DictionaryFields do
 
     it "allows conversion to a Rectangle from an Array" do
       doc = Minitest::Mock.new
-      doc.expect(:wrap, :data, [[0, 1, 2, 3], {type: HexaPDF::Rectangle}])
+      doc.expect(:wrap, :data, [[0, 1, 2, 3]], type: HexaPDF::Rectangle)
       @field.convert([0, 1, 2, 3], doc)
       doc.verify
     end
@@ -240,7 +240,7 @@ describe HexaPDF::DictionaryFields do
     it "allows conversion to a Rectangle from a HexaPDF::PDFArray" do
       data = HexaPDF::PDFArray.new([0, 1, 2, 3])
       doc = Minitest::Mock.new
-      doc.expect(:wrap, :data, [data, {type: HexaPDF::Rectangle}])
+      doc.expect(:wrap, :data, [data], type: HexaPDF::Rectangle)
       @field.convert(data, doc)
       doc.verify
     end

data/test/hexapdf/test_document.rb

@@ -302,7 +302,7 @@ describe HexaPDF::Document do
 
   it "defers to @revisions for iterating over all objects" do
     revs = Minitest::Mock.new
-    revs.expect(:each_object, :retval, [{only_current: true, only_loaded: true}])
+    revs.expect(:each_object, :retval, only_current: true, only_loaded: true)
     doc = HexaPDF::Document.new
     doc.instance_variable_set(:@revisions, revs)
     doc.each(only_current: true, only_loaded: true)
@@ -328,7 +328,7 @@ describe HexaPDF::Document do
 
     it "doesn't decrypt the document if document.auto_encrypt=false" 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)),
                                   config: {'document.auto_decrypt' => false})
       assert_kind_of(String, doc.trailer[:Info][:ModDate])
       handler = HexaPDF::Encryption::SecurityHandler.set_up_decryption(doc)
@@ -510,8 +510,8 @@ describe HexaPDF::Document do
 
     it "allows to conveniently sign a document" do
       mock = Minitest::Mock.new
-      mock.expect(:handler, :handler, [{name: :handler, opt: :key}])
-      mock.expect(:add, :added, [:io, :handler, {signature: :sig, write_options: :write_options}])
+      mock.expect(:handler, :handler, name: :handler, opt: :key)
+      mock.expect(:add, :added, [:io, :handler], signature: :sig, write_options: :write_options)
       @doc.instance_variable_set(:@signatures, mock)
       result = @doc.sign(:io, handler: :handler, write_options: :write_options, signature: :sig, opt: :key)
       assert_equal(:added, result)

data/test/hexapdf/test_filter.rb

@@ -62,7 +62,7 @@ describe HexaPDF::Filter do
 
   describe "source_from_file" do
     before do
-      @file = Tempfile.new('hexapdf-filter')
+      @file = Tempfile.new('hexapdf-filter', binmode: true)
       @file.write(@str)
       @file.close
     end

data/test/hexapdf/test_parser.rb

@@ -543,14 +543,12 @@ describe HexaPDF::Parser do
       xref_section, trailer = @parser.load_revision(@parser.startxref_offset)
       assert_equal({Test: 'now'}, trailer)
       assert(xref_section[1].in_use?)
-      refute(@parser.contains_xref_streams?)
     end
 
     it "works for a cross-reference stream" do
       xref_section, trailer = @parser.load_revision(212)
       assert_equal({Size: 2, Type: :XRef}, trailer)
       assert(xref_section[1].in_use?)
-      assert(@parser.contains_xref_streams?)
     end
 
     it "fails if another object is found instead of a cross-reference stream" do

data/test/hexapdf/test_revisions.rb

@@ -185,8 +185,8 @@ describe HexaPDF::Revisions do
     end
 
     it "iterates over all objects" do
-      assert_equal([10, 400, 200, 20, @obj3, @obj3],
-                   @revisions.each_object(only_current: false).sort.map(&:value))
+      assert_equal([@obj3, 400, 200, @obj3, 10, 20],
+                   @revisions.each_object(only_current: false).map(&:value))
     end
 
     it "iterates over all loaded objects" do

data/test/hexapdf/test_serializer.rb

@@ -101,16 +101,12 @@ describe HexaPDF::Serializer do
   end
 
   it "serializes time like objects" do
-    tz = ENV['TZ']
-    ENV['TZ'] = 'Europe/Vienna'
     assert_serialized("(D:20150416094100)", Time.new(2015, 04, 16, 9, 41, 0, 0))
     assert_serialized("(D:20150416094100+01'00')", Time.new(2015, 04, 16, 9, 41, 0, 3600))
     assert_serialized("(D:20150416094100-01'20')", Time.new(2015, 04, 16, 9, 41, 0, -4800))
-    assert_serialized("(D:20150416000000+02'00')", Date.parse("2015-04-16 9:41:00 +02:00"))
+    assert_serialized("(D:20150416000000)", Date.parse("2015-04-16 9:41:00 +02:00"))
     assert_serialized("(D:20150416094100+02'00')",
                       Time.parse("2015-04-16 9:41:00 +02:00").to_datetime)
-  ensure
-    ENV['TZ'] = tz
   end
 
   it "serializes HexaPDF objects" do