hexapdf 0.46.0 → 1.6.0

data/test/hexapdf/type/annotations/test_border_styling.rb

@@ -0,0 +1,114 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/border_styling'
+
+describe HexaPDF::Type::Annotations::BorderStyling do
+  class TestAnnot < HexaPDF::Type::Annotation
+    define_field :BS, type: :Border
+    define_field :MK, type: :XXAppearanceCharacteristics
+    include HexaPDF::Type::Annotations::BorderStyling
+  end
+
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.wrap({Type: :Annot}, type: TestAnnot)
+    @color = HexaPDF::Content::ColorSpace.prenormalized_device_color([1, 0, 1])
+  end
+
+  describe "border_style" do
+    describe "getter" do
+      it "no /Border, /BS or /C|/MK set" do
+        @annot.delete(:MK)
+        assert_equal([1, nil, :solid, 0, 0], @annot.border_style.to_a)
+      end
+
+      it "no /Border, /BS but with /MK empty" do
+        @annot[:Subtype] = :Widget
+        @annot[:MK] = {}
+        assert_equal([1, nil, :solid, 0, 0], @annot.border_style.to_a)
+      end
+
+      it "uses the color from /C" do
+        @annot[:C] = [1, 0, 1]
+        assert_equal([1, @color, :solid, 0, 0], @annot.border_style.to_a)
+        @annot[:C] = []
+        assert_equal([1, nil, :solid, 0, 0], @annot.border_style.to_a)
+      end
+
+      it "uses the color from /MK" do
+        @annot[:Subtype] = :Widget
+        @annot[:MK] = {BC: [1, 0, 1]}
+        assert_equal([1, @color, :solid, 0, 0], @annot.border_style.to_a)
+        @annot[:MK][:BC] = []
+        assert_equal([1, nil, :solid, 0, 0], @annot.border_style.to_a)
+      end
+
+      it "uses the data from /Border" do
+        @annot[:Border] = [1, 2, 3, [1, 2]]
+        assert_equal([3, nil, [1, 2], 1, 2], @annot.border_style.to_a)
+      end
+
+      it "uses the data from /BS, overriding /Border values" do
+        @annot[:Border] = [1, 2, 3, [1, 2]]
+        @annot[:BS] = {W: 5, S: :D, D: [5, 6]}
+        assert_equal([5, nil, [5, 6], 0, 0], @annot.border_style.to_a)
+
+        [[:S, :solid], [:D, [5, 6]], [:B, :beveled], [:I, :inset],
+         [:U, :underlined], [:Unknown, :solid]].each do |val, result|
+          @annot[:BS] = {S: val, D: [5, 6]}
+          assert_equal([1, nil, result, 0, 0], @annot.border_style.to_a)
+        end
+      end
+    end
+
+    describe "setter" do
+      it "returns self" do
+        assert_equal(@annot, @annot.border_style(width: 1))
+      end
+
+      it "sets the color" do
+        @annot.border_style(color: [1.0, 51, 1.0])
+        assert_equal([1, 0.2, 1], @annot[:C])
+
+        @annot.border_style(color: :transparent)
+        assert_equal([], @annot[:C])
+      end
+
+      it "sets the color on a widget using /MK" do
+        @annot[:Subtype] = :Widget
+        @annot.border_style(color: [1.0, 51, 1.0])
+        assert_equal([1, 0.2, 1], @annot[:MK][:BC])
+
+        @annot.border_style(color: :transparent)
+        assert_equal([], @annot[:MK][:BC])
+      end
+
+      it "sets the width" do
+        @annot.border_style(width: 2)
+        assert_equal(2, @annot[:BS][:W])
+      end
+
+      it "sets the style" do
+        [[:solid, :S], [[5, 6], :D], [:beveled, :B], [:inset, :I], [:underlined, :U]].each do |val, r|
+          @annot.border_style(style: val)
+          assert_equal(r, @annot[:BS][:S])
+          assert_equal(val, @annot[:BS][:D]) if r == :D
+        end
+      end
+
+      it "overrides all priorly set values" do
+        @annot.border_style(width: 3, style: :inset, color: [1])
+        @annot.border_style(width: 5)
+        border_style = @annot.border_style
+        assert_equal(:solid, border_style.style)
+        assert_equal([0], border_style.color.components)
+      end
+
+      it "raises an error for an unknown style" do
+        assert_raises(ArgumentError) { @annot.border_style(style: :unknown) }
+      end
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_interior_color.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/interior_color'
+
+describe HexaPDF::Type::Annotations::InteriorColor do
+  class TestAnnot < HexaPDF::Type::Annotation
+    define_field :IC, type: HexaPDF::PDFArray
+    include HexaPDF::Type::Annotations::InteriorColor
+  end
+
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.wrap({Type: :Annot}, type: TestAnnot)
+  end
+
+  describe "interior_color" do
+    it "returns the interior color" do
+      assert_nil(@annot.interior_color)
+      @annot[:IC] = []
+      assert_nil(@annot.interior_color)
+      @annot[:IC] = [0.5]
+      assert_equal(HexaPDF::Content::ColorSpace.device_color_from_specification(0.5),
+                   @annot.interior_color)
+    end
+
+    it "sets the interior color" do
+      @annot.interior_color(255)
+      assert_equal([1.0], @annot[:IC])
+      @annot.interior_color(255, 255, 0)
+      assert_equal([1.0, 1.0, 0], @annot[:IC])
+      @annot.interior_color(:transparent)
+      assert_equal([], @annot[:IC])
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_line.rb

@@ -0,0 +1,144 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/line'
+
+describe HexaPDF::Type::Annotations::Line do
+  before do
+    @doc = HexaPDF::Document.new
+    @line = @doc.add({Type: :Annot, Subtype: :Line, Rect: [0, 0, 0, 0], L: [0, 0, 1, 1]})
+  end
+
+  describe "line" do
+    it "returns the coordinates of the start and end points" do
+      @line[:L] = [10, 20, 30, 40]
+      assert_equal([10, 20, 30, 40], @line.line)
+    end
+
+    it "sets the line points" do
+      assert_equal(@line, @line.line(1, 2, 3, 4))
+      assert_equal([1, 2, 3, 4], @line[:L])
+    end
+
+    it "raises an ArgumentError if not all arguments are provided" do
+      assert_raises(ArgumentError) { @line.line(1, 2, 3) }
+    end
+  end
+
+  describe "leader_line_length" do
+    it "returns the leader line length" do
+      assert_equal(0, @line.leader_line_length)
+      @line[:LL] = 10
+      assert_equal(10, @line.leader_line_length)
+    end
+
+    it "sets the leader line length" do
+      assert_equal(@line, @line.leader_line_length(10))
+      assert_equal(10, @line[:LL])
+    end
+  end
+
+  describe "leader_line_extension_length" do
+    it "returns the leader line extension length" do
+      assert_equal(0, @line.leader_line_extension_length)
+      @line[:LLE] = 10
+      assert_equal(10, @line.leader_line_extension_length)
+    end
+
+    it "sets the leader line extension length" do
+      assert_equal(@line, @line.leader_line_extension_length(10))
+      assert_equal(10, @line[:LLE])
+    end
+
+    it "raises an error for negative numbers" do
+      assert_raises(ArgumentError) { @line.leader_line_extension_length(-10) }
+    end
+  end
+
+  describe "leader_line_offset" do
+    it "returns the leader line offset" do
+      assert_equal(0, @line.leader_line_offset)
+      @line[:LLO] = 10
+      assert_equal(10, @line.leader_line_offset)
+    end
+
+    it "sets the leader line offset" do
+      assert_equal(@line, @line.leader_line_offset(10))
+      assert_equal(10, @line[:LLO])
+    end
+  end
+
+  describe "captioned" do
+    it "returns whether a caption is shown" do
+      refute(@line.captioned)
+      @line[:Cap] = true
+      assert(@line.captioned)
+    end
+
+    it "sets whether a caption should be shown" do
+      assert_equal(@line, @line.captioned(true))
+      assert_equal(true, @line[:Cap])
+    end
+  end
+
+  describe "caption_position" do
+    it "returns the caption position" do
+      assert_equal(:inline, @line.caption_position)
+      @line[:CP] = :Top
+      assert_equal(:top, @line.caption_position)
+    end
+
+    it "sets the caption position" do
+      assert_equal(@line, @line.caption_position(:top))
+      assert_equal(:Top, @line[:CP])
+    end
+
+    it "raises an error on invalid caption positions" do
+      assert_raises(ArgumentError) { @line.caption_position(:unknown) }
+    end
+  end
+
+  describe "caption_offset" do
+    it "returns the caption offset" do
+      assert_equal([0, 0], @line.caption_offset)
+      @line[:CO] = [10, 5]
+      assert_equal([10, 5], @line.caption_offset)
+    end
+
+    it "sets the caption offset" do
+      assert_equal(@line, @line.caption_offset(5, 10))
+      assert_equal([5, 10], @line[:CO])
+      assert_equal(@line, @line.caption_offset(5))
+      assert_equal([5, 0], @line[:CO])
+      assert_equal(@line, @line.caption_offset(nil, 5))
+      assert_equal([0, 5], @line[:CO])
+    end
+  end
+
+  describe "perform_validation" do
+    it "validates that leader line length is set if extension length is set" do
+      @line[:LLE] = 10
+      m = nil
+      refute(@line.validate {|msg| m = msg })
+      assert_match(/\/LL required to be non-zero/, m)
+    end
+
+    it "ensures leader line extension length is non-negative" do
+      @line[:LL] = 10
+      @line[:LLE] = -10
+      m = nil
+      assert(@line.validate {|msg| m = msg })
+      assert_equal(10, @line[:LLE])
+      assert_match(/non-negative/, m)
+    end
+
+    it "ensures leader line offset is non-negative" do
+      @line[:LLO] = -10
+      m = nil
+      assert(@line.validate {|msg| m = msg })
+      assert_equal(10, @line[:LLO])
+      assert_match(/\/LLO must be a non-negative/, m)
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_line_ending_styling.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/line_ending_styling'
+
+describe HexaPDF::Type::Annotations::LineEndingStyling do
+  class TestAnnotLineEndingStyling < HexaPDF::Type::Annotation
+    define_field :LE, type: HexaPDF::PDFArray, default: [:None, :None]
+    include HexaPDF::Type::Annotations::LineEndingStyling
+  end
+
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.wrap({Type: :Annot}, type: TestAnnotLineEndingStyling)
+  end
+
+  describe "line_ending_style" do
+    it "returns the current style" do
+      assert_kind_of(HexaPDF::Type::Annotations::Line::LineEndingStyle, @annot.line_ending_style)
+      assert_equal([:none, :none], @annot.line_ending_style.to_a)
+      @annot[:LE] = [:Diamond, :OpenArrow]
+      assert_equal([:diamond, :open_arrow], @annot.line_ending_style.to_a)
+      @annot[:LE] = [:Diamond, :Unknown]
+      assert_equal([:diamond, :none], @annot.line_ending_style.to_a)
+    end
+
+    it "sets the style" do
+      assert_same(@annot, @annot.line_ending_style(start_style: :OpenArrow))
+      assert_equal([:OpenArrow, :None], @annot[:LE])
+      assert_same(@annot, @annot.line_ending_style(end_style: :open_arrow))
+      assert_equal([:OpenArrow, :OpenArrow], @annot[:LE])
+      assert_same(@annot, @annot.line_ending_style(start_style: :circle, end_style: :ClosedArrow))
+      assert_equal([:Circle, :ClosedArrow], @annot[:LE])
+    end
+
+    it "raises an error for unknown styles" do
+      assert_raises(ArgumentError) { @annot.line_ending_style(start_style: :unknown) }
+      assert_raises(ArgumentError) { @annot.line_ending_style(end_style: :unknown) }
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_polygon_polyline.rb

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/polygon_polyline'
+
+describe HexaPDF::Type::Annotations::PolygonPolyline do
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.add({Type: :Annot, Subtype: :Polyline, Rect: [0, 0, 0, 0]},
+                      type: HexaPDF::Type::Annotations::PolygonPolyline)
+  end
+
+  describe "vertices" do
+    it "returns the coordinates of the vertices" do
+      @annot[:Vertices] = [10, 20, 30, 40, 50, 60]
+      assert_equal([10, 20, 30, 40, 50, 60], @annot.vertices)
+    end
+
+    it "sets the vertices" do
+      assert_same(@annot, @annot.vertices(1, 2, 3, 4, 5, 6))
+      assert_equal([1, 2, 3, 4, 5, 6], @annot[:Vertices])
+    end
+
+    it "raises an ArgumentError if an uneven number of arguments is provided" do
+      assert_raises(ArgumentError) { @annot.vertices(1, 2, 3) }
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_widget.rb

@@ -52,6 +52,14 @@ describe HexaPDF::Type::Annotations::Widget do
       assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
       refute_same(@widget.data, result.data)
     end
+
+    it "works when the type of the field is defined higher up in the field hierarchy" do
+      @widget[:Parent] = {T: 'parent', Kids: [@widget]}
+      @widget[:Parent][:Parent] = {FT: :Tx, Kids: [@widget[:Parent]]}
+      result = @widget.form_field
+      assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
+      refute_same(@widget.data, result.data)
+    end
   end
 
   describe "background_color" do
@@ -69,87 +77,6 @@ describe HexaPDF::Type::Annotations::Widget do
     end
   end
 
-  describe "border_style" do
-    before do
-      @widget[:MK] = {BC: [1, 0, 1]}
-      @color = HexaPDF::Content::ColorSpace.prenormalized_device_color([1, 0, 1])
-    end
-
-    describe "getter" do
-      it "no /Border, /BS or /MK set" do
-        @widget.delete(:MK)
-        assert_equal([1, nil, :solid, 0, 0], @widget.border_style.to_a)
-      end
-
-      it "no /Border, /BS but with /MK empty" do
-        @widget[:MK].delete(:BC)
-        assert_equal([1, nil, :solid, 0, 0], @widget.border_style.to_a)
-      end
-
-      it "uses the color from /MK" do
-        assert_equal([1, @color, :solid, 0, 0], @widget.border_style.to_a)
-        @widget[:MK][:BC] = []
-        assert_equal([1, nil, :solid, 0, 0], @widget.border_style.to_a)
-      end
-
-      it "uses the data from /Border" do
-        @widget[:Border] = [1, 2, 3, [1, 2]]
-        assert_equal([3, @color, [1, 2], 1, 2], @widget.border_style.to_a)
-      end
-
-      it "uses the data from /BS, overriding /Border values" do
-        @widget[:Border] = [1, 2, 3, [1, 2]]
-        @widget[:BS] = {W: 5, S: :D, D: [5, 6]}
-        assert_equal([5, @color, [5, 6], 0, 0], @widget.border_style.to_a)
-
-        [[:S, :solid], [:D, [5, 6]], [:B, :beveled], [:I, :inset],
-         [:U, :underlined], [:Unknown, :solid]].each do |val, result|
-          @widget[:BS] = {S: val, D: [5, 6]}
-          assert_equal([1, @color, result, 0, 0], @widget.border_style.to_a)
-        end
-      end
-    end
-
-    describe "setter" do
-      it "returns self" do
-        assert_equal(@widget, @widget.border_style(width: 1))
-      end
-
-      it "sets the color" do
-        @widget.border_style(color: [1.0, 51, 1.0])
-        assert_equal([1, 0.2, 1], @widget[:MK][:BC].value)
-
-        @widget.border_style(color: :transparent)
-        assert_equal([], @widget[:MK][:BC].value)
-      end
-
-      it "sets the width" do
-        @widget.border_style(width: 2)
-        assert_equal(2, @widget[:BS][:W])
-      end
-
-      it "sets the style" do
-        [[:solid, :S], [[5, 6], :D], [:beveled, :B], [:inset, :I], [:underlined, :U]].each do |val, r|
-          @widget.border_style(style: val)
-          assert_equal(r, @widget[:BS][:S])
-          assert_equal(val, @widget[:BS][:D].value) if r == :D
-        end
-      end
-
-      it "overrides all priorly set values" do
-        @widget.border_style(width: 3, style: :inset, color: [1])
-        @widget.border_style(width: 5)
-        border_style = @widget.border_style
-        assert_equal(:solid, border_style.style)
-        assert_equal([0], border_style.color.components)
-      end
-
-      it "raises an error for an unknown style" do
-        assert_raises(ArgumentError) { @widget.border_style(style: :unknown) }
-      end
-    end
-  end
-
   describe "marker_style" do
     before do
       @chars = %w[4 l 8 u n H S]
@@ -179,6 +106,20 @@ describe HexaPDF::Type::Annotations::Widget do
         end
       end
 
+      it "uses the correct default style" do
+        @widget.form_field.initialize_as_check_box
+        @widget.marker_style(size: 10)
+        assert_equal('4', @widget[:MK][:CA])
+
+        @widget.form_field.initialize_as_radio_button
+        @widget.marker_style(size: 10)
+        assert_equal('l', @widget[:MK][:CA])
+
+        @widget.form_field.initialize_as_push_button
+        @widget.marker_style(size: 10)
+        assert_equal('', @widget[:MK][:CA])
+      end
+
       it "fails if an invalid argument is provided" do
         assert_raises(ArgumentError) { @widget.marker_style(style: 5) }
       end
@@ -194,6 +135,8 @@ describe HexaPDF::Type::Annotations::Widget do
 
       it "returns the default size if none is set" do
         assert_equal(0, @widget.marker_style.size)
+        @widget.form_field[:DA] = "0.0 g"
+        assert_equal(0, @widget.marker_style.size)
       end
 
       it "sets the given size" do
@@ -212,6 +155,8 @@ describe HexaPDF::Type::Annotations::Widget do
 
       it "returns the default color if none is set" do
         assert_equal([0], @widget.marker_style.color.components)
+        @widget.form_field[:DA] = "/ZaDb 10 Tfg"
+        assert_equal([0], @widget.marker_style.color.components)
       end
 
       it "sets the given color" do
@@ -221,5 +166,26 @@ describe HexaPDF::Type::Annotations::Widget do
         assert_equal([1, 0.2, 1, 1], @widget.marker_style.color.components)
       end
     end
+
+    describe "font_name" do
+      it "returns the font_name" do
+        @widget.form_field[:DA] = "/F1 15 Tf"
+        assert_equal(:F1, @widget.marker_style.font_name)
+        @widget[:DA] = "/F2 10 Tf"
+        assert_equal(:F2, @widget.marker_style.font_name)
+      end
+
+      it "returns nil if none is set" do
+        assert_nil(@widget.marker_style.font_name)
+        @widget.form_field[:DA] = "0.0 g"
+        assert_nil(@widget.marker_style.font_name)
+      end
+
+      it "sets the given font_name" do
+        @widget.form_field.initialize_as_push_button
+        @widget.marker_style(font_name: 'Helvetica', size: 10)
+        assert_equal('/F1 10 Tf 0.0 g', @widget[:DA])
+      end
+    end
   end
 end

data/test/hexapdf/type/test_annotation.rb

@@ -67,6 +67,9 @@ describe HexaPDF::Type::Annotation do
   it "returns the appearance stream of the given type" do
     assert_nil(@annot.appearance)
 
+    @annot[:AP] = 'some invalid type'
+    assert_nil(@annot.appearance)
+
     @annot[:AP] = {N: {}}
     assert_nil(@annot.appearance)
 
@@ -113,6 +116,14 @@ describe HexaPDF::Type::Annotation do
     end
   end
 
+  describe "regenerate_appearance" do
+    it "regenerates the appearance using the data from the annotation object" do
+      @annot[:Subtype] = :Unknown
+      error = assert_raises(HexaPDF::Error) { @annot.regenerate_appearance }
+      assert_match(/Unknown.*not.*supported/, error.message)
+    end
+  end
+
   describe "flags" do
     it "returns all flags" do
       assert_equal([:invisible, :hidden, :no_view], @annot.flags)
@@ -139,6 +150,53 @@ describe HexaPDF::Type::Annotation do
     end
   end
 
+  describe "contents" do
+    it "returns the contents value" do
+      assert_nil(@annot.contents)
+      @annot[:Contents] = "test"
+      assert_equal("test", @annot.contents)
+    end
+
+    it "sets the contents value" do
+      assert_same(@annot, @annot.contents("Test"))
+      assert_equal("Test", @annot[:Contents])
+      @annot.contents(nil)
+      assert_nil(@annot[:Contents])
+    end
+  end
+
+  describe "opacity" do
+    it "returns the opacity values" do
+      opacity = @annot.opacity
+      assert_equal(1, opacity.fill_alpha)
+      assert_equal(1, opacity.stroke_alpha)
+
+      @annot[:CA] = 0.5
+      opacity = @annot.opacity
+      assert_equal(0.5, opacity.fill_alpha)
+      assert_equal(0.5, opacity.stroke_alpha)
+
+      @annot[:ca] = 0.3
+      opacity = @annot.opacity
+      assert_equal(0.3, opacity.fill_alpha)
+      assert_equal(0.5, opacity.stroke_alpha)
+    end
+
+    it "sets the opacity values" do
+      @annot.opacity(fill_alpha: 0.3)
+      refute(@annot.key?(:CA))
+      assert_equal(0.3, @annot[:ca])
+
+      @annot.opacity(stroke_alpha: 0.5)
+      assert_equal(0.3, @annot[:ca])
+      assert_equal(0.5, @annot[:CA])
+
+      @annot.opacity(stroke_alpha: 0.1, fill_alpha: 0.2)
+      assert_equal(0.1, @annot[:CA])
+      assert_equal(0.2, @annot[:ca])
+    end
+  end
+
   describe "validation" do
     it "makes sure that empty appearance stream dictionaries don't cause validation errors" do
       assert(@annot.validate)

data/test/hexapdf/type/test_font_type1.rb

@@ -31,7 +31,7 @@ describe HexaPDF::Type::FontType1::StandardFonts do
     end
 
     it "returns nil if the given name doesn't belong to a standard font" do
-      refute_nil(@obj.font(:TimesNewRoman))
+      assert_nil(@obj.font(:SomeOtherFont))
     end
   end
 end
@@ -138,5 +138,24 @@ describe HexaPDF::Type::FontType1 do
       @embedded_font.delete(:FontDescriptor)
       refute(@embedded_font.validate)
     end
+
+    it "ensures a correct Symbol value for the /Encoding key" do
+      @font[:Encoding] = :Other
+      refute(@font.validate)
+    end
+
+    it "works around certain invalid PDFs with a /SymbolEncoding value for /Encoding" do
+      @font[:Encoding] = :SymbolEncoding
+      @font[:BaseFont] = :Symbol
+      assert(@font.validate)
+      refute(@font.key?(:Encoding))
+    end
+
+    it "works around certain invalid PDFs with a /StandardEncoding value for /Encoding" do
+      @font[:Encoding] = :StandardEncoding
+      assert(@font.validate)
+      assert(:WinAnsiEncoding, @font[:Encoding][:BaseEncoding])
+      assert_equal([39, :quoteright, 96, :quoteleft], @font[:Encoding][:Differences][0, 4])
+    end
   end
 end

data/test/hexapdf/type/test_form.rb

@@ -57,7 +57,7 @@ describe HexaPDF::Type::Form do
     it "creates the resource dictionary if it is not found" do
       resources = @form.resources
       assert_equal(:XXResources, resources.type)
-      assert_equal({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]}, resources.value)
+      assert_equal({}, resources.value)
     end
 
     it "returns the already used resource dictionary" do
@@ -125,6 +125,12 @@ describe HexaPDF::Type::Form do
                                [:restore_graphics_state]])
     end
 
+    it "doesn't move the origin if translate is false" do
+      @form[:BBox] = [-10, -5, 100, 300]
+      @form.canvas(translate: false).line_width = 5
+      assert_operators(@form, [[:set_line_width, [5]]])
+    end
+
     it "fails if the form XObject already has data" do
       @form.stream = '10 w'
       assert_raises(HexaPDF::Error) { @form.canvas }

data/test/hexapdf/type/test_image.rb

@@ -171,7 +171,7 @@ describe HexaPDF::Type::Image do
 
     def assert_valid_png(filename, original = nil)
       if PNG_CHECK_AVAILABLE
-        result = `pngcheck -q #{filename}`
+        result = `pngcheck -q #{filename} 2>/dev/null`
         assert(result.empty?, "pngcheck error: #{result}")
       else
         skip("Skipping PNG output validity check because pngcheck executable is missing")