hexapdf 0.14.2 → 0.15.2

data/test/hexapdf/test_revision.rb

@@ -105,6 +105,27 @@ describe HexaPDF::Revision do
     end
   end
 
+  describe "update" do
+    before do
+      @rev.add(@obj)
+    end
+
+    it "updates the object if it has the same data instance" do
+      x = HexaPDF::Object.new(@obj.data)
+      y = @rev.update(x)
+      assert_same(x, y)
+      refute_same(x, @obj)
+      assert_same(x, @rev.object(@ref))
+    end
+
+    it "doesn't update the object if it refers to a different data instance" do
+      x = HexaPDF::Object.new(:value, oid: 5)
+      assert_nil(@rev.update(x))
+      x.data.oid = 1
+      assert_nil(@rev.update(x))
+    end
+  end
+
   describe "delete" do
     before do
       @rev.add(@obj)

data/test/hexapdf/test_serializer.rb

@@ -58,6 +58,9 @@ describe HexaPDF::Serializer do
     assert_serialized("0.000005", 0.000005)
     assert_serialized("-0.000005", -0.000005)
     assert_serialized("0.0", 0.0)
+    assert_raises(HexaPDF::Error) { @serializer.serialize(0.0 / 0) }
+    assert_raises(HexaPDF::Error) { @serializer.serialize(1.0 / 0) }
+    assert_raises(HexaPDF::Error) { @serializer.serialize(-1.0 / 0) }
   end
 
   it "serializes numerics" do
@@ -153,6 +156,13 @@ describe HexaPDF::Serializer do
       assert_equal("<</Key(value)/Length 6>>stream\nsome\nendstream", io.string)
     end
 
+    it "doesn't reset the internal recursion flag if the stream is serialized as part of another object" do
+      object = HexaPDF::Dictionary.new({}, oid: 5)
+      object[:Stream] = @stream
+      object[:Self] = object # needs to be the last entry so that :Stream gets serialized first!
+      assert_serialized("<</Stream 2 0 R/Self 5 0 R>>", object)
+    end
+
     it "fails if a stream without object identifier is serialized" do
       @stream.oid = 0
       assert_raises(HexaPDF::Error) { @serializer.serialize(@stream) }

data/test/hexapdf/test_tokenizer.rb

@@ -27,4 +27,54 @@ describe HexaPDF::Tokenizer do
       5.times {|i| assert_equal(i, @tokenizer.next_token) }
     end
   end
+
+  it "has a special token scanning method for use with xref reconstruction" do
+    create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
+        % Comment
+          true
+        123 50
+        obj
+        (ignored)
+        /Ignored
+        [/Ignored]
+        <</Ignored /Values>>
+    EOF
+
+    scan_to_newline = proc { @tokenizer.scan_until(/(\n|\r\n?)+|\z/) }
+
+    assert_nil(@tokenizer.next_integer_or_keyword)
+    scan_to_newline.call
+    assert_equal(true, @tokenizer.next_integer_or_keyword)
+    assert_equal(123, @tokenizer.next_integer_or_keyword)
+    assert_equal(50, @tokenizer.next_integer_or_keyword)
+    assert_equal('obj', @tokenizer.next_integer_or_keyword)
+    4.times do
+      assert_nil(@tokenizer.next_integer_or_keyword)
+      scan_to_newline.call
+    end
+    assert_equal(HexaPDF::Tokenizer::NO_MORE_TOKENS, @tokenizer.next_integer_or_keyword)
+  end
+
+  describe "can correct some problems" do
+    describe "invalid inf/-inf/nan/-nan tokens" do
+      it "turns them into zeros" do
+        count = 0
+        on_correctable_error = lambda do |msg, pos|
+          count += 1
+          assert_match(/Invalid object, got token/, msg)
+          assert_equal(8, pos) if count == 2
+          false
+        end
+        tokenizer = HexaPDF::Tokenizer.new(StringIO.new("inf -Inf NaN -nan"),
+                                           on_correctable_error: on_correctable_error)
+        assert_equal([0, 0, 0, 0], 4.times.map { tokenizer.next_object })
+        assert_equal(4, count)
+      end
+
+      it "raises an error if configured so" do
+        tokenizer = HexaPDF::Tokenizer.new(StringIO.new("inf"), on_correctable_error: proc { true })
+        assert_raises(HexaPDF::MalformedPDFError) { tokenizer.next_object }
+      end
+    end
+  end
 end

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.14.2)>>
+      <</Producer(HexaPDF version 0.15.2)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.14.2)>>
+      <</Producer(HexaPDF version 0.15.2)>>
       endobj
       2 0 obj
       <</Length 10>>stream

data/test/hexapdf/type/acro_form/test_appearance_generator.rb

@@ -407,10 +407,12 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       @generator.create_appearances
       form = @widget[:AP][:N]
       form[:key] = :value
+      form.delete(:Subtype)
+      @widget[:AP][:N] = @doc.wrap(form, type: HexaPDF::Dictionary)
 
       @field[:V] = 'test1'
       @generator.create_appearances
-      assert_same(form, @widget[:AP][:N])
+      assert_equal(form, @widget[:AP][:N])
       refute(form.key?(:key))
       assert_match(/test1/, form.contents)
     end
@@ -746,17 +748,36 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
 
     describe "font resolution in case the referenced font is not usable" do
       before do
-        @doc.config['acro_form.fallback_font'] = ['Times', {variant: :none}]
+        @doc.config['acro_form.fallback_font'] = ['Times', {variant: :italic}]
         @field[:V] = 'Test'
       end
 
       it "uses the fallback font if the font is not usable" do
         def (@form.default_resources.font(:F1)).font_wrapper; nil; end
         @generator.create_appearances
-        assert_equal(:'Times-Roman', @widget[:AP][:N][:Resources][:Font][:F2][:BaseFont])
+        assert_equal(:'Times-Italic', @widget[:AP][:N][:Resources][:Font][:F2][:BaseFont])
       end
 
       it "uses the fallback font if the font is not found" do
+        @form.default_resources[:Font].delete(:F1)
+        @generator.create_appearances
+        assert_equal(:'Times-Italic', @widget[:AP][:N][:Resources][:Font][:F1][:BaseFont])
+      end
+
+      it "respects a simple fallback font name" do
+        @doc.config['acro_form.fallback_font'] = 'Times'
+        @form.default_resources[:Font].delete(:F1)
+        @generator.create_appearances
+        assert_equal(:'Times-Roman', @widget[:AP][:N][:Resources][:Font][:F1][:BaseFont])
+      end
+
+      it "respects a fallback font callable object" do
+        field = @field
+        @doc.config['acro_form.fallback_font'] = proc do |field_arg, font_arg|
+          assert_same(field.data, field_arg.data)
+          assert_nil(font_arg)
+          'Times'
+        end
         @form.default_resources[:Font].delete(:F1)
         @generator.create_appearances
         assert_equal(:'Times-Roman', @widget[:AP][:N][:Resources][:Font][:F1][:BaseFont])

data/test/hexapdf/type/acro_form/test_button_field.rb

@@ -225,20 +225,26 @@ describe HexaPDF::Type::AcroForm::ButtonField do
     it "won't generate appearances if they already exist" do
       widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
       @field.create_appearances
-      yes = widget.appearance.normal_appearance[:Yes]
-      off = widget.appearance.normal_appearance[:Off]
-      widget.appearance.normal_appearance.delete(:Off)
+      yes = widget.appearance_dict.normal_appearance[:Yes]
+      off = widget.appearance_dict.normal_appearance[:Off]
       @field.create_appearances
-      assert_same(yes, widget.appearance.normal_appearance[:Yes])
-      refute_same(off, widget.appearance.normal_appearance[:Off])
+      assert_same(yes, widget.appearance_dict.normal_appearance[:Yes])
+      assert_same(off, widget.appearance_dict.normal_appearance[:Off])
+
+      @field.delete_widget(widget)
+      @field.flag(:push_button)
+      widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0], AP: {N: @doc.wrap({}, stream: '')})
+      appearance = widget.appearance_dict.normal_appearance
+      @field.create_appearances
+      assert_same(appearance, widget.appearance_dict.normal_appearance)
     end
 
     it "always generates appearances if force is true" do
       widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
       @field.create_appearances
-      yes = widget.appearance.normal_appearance[:Yes]
+      yes = widget.appearance_dict.normal_appearance[:Yes]
       @field.create_appearances(force: true)
-      refute_same(yes, widget.appearance.normal_appearance[:Yes])
+      refute_same(yes, widget.appearance_dict.normal_appearance[:Yes])
     end
 
     it "fails for unsupported button types" do

data/test/hexapdf/type/acro_form/test_field.rb

@@ -200,9 +200,14 @@ describe HexaPDF::Type::AcroForm::Field do
 
     it "deletes the widget if it is embedded" do
       widget = @field.create_widget(@page)
+      @doc.revisions.current.update(widget)
+      assert_same(widget, @doc.object(widget))
+      refute_same(@field, @doc.object(@field))
+
       @field.delete_widget(widget)
       refute(@field.key?(:Subtype))
       assert(@page[:Annots].empty?)
+      assert_same(@field, @doc.object(@field))
     end
 
     it "deletes the widget if it is not embedded" do

data/test/hexapdf/type/acro_form/test_form.rb

@@ -254,8 +254,8 @@ describe HexaPDF::Type::AcroForm::Form do
 
     it "creates the appearances of all field widgets if necessary" do
       @acro_form.create_appearances
-      assert(@tf.each_widget.all? {|w| w.appearance.normal_appearance.kind_of?(HexaPDF::Stream) })
-      assert(@cb.each_widget.all? {|w| w.appearance.normal_appearance[:Yes].kind_of?(HexaPDF::Stream) })
+      assert(@tf.each_widget.all? {|w| w.appearance_dict.normal_appearance.kind_of?(HexaPDF::Stream) })
+      assert(@cb.each_widget.all? {|w| w.appearance_dict.normal_appearance[:Yes].kind_of?(HexaPDF::Stream) })
     end
 
     it "force the creation of appearances if force is true" do
@@ -268,6 +268,50 @@ describe HexaPDF::Type::AcroForm::Form do
     end
   end
 
+  describe "flatten" do
+    before do
+      @acro_form.root_fields << @doc.wrap({T: 'test'})
+      @tf = @acro_form.create_text_field('textfields')
+      @tf.set_default_appearance_string
+      @tf[:V] = 'Test'
+      @tf.create_widget(@doc.pages.add)
+      @cb = @acro_form.create_check_box('test.checkbox')
+      @cb.create_widget(@doc.pages[0])
+      @cb.create_widget(@doc.pages.add)
+    end
+
+    it "creates the missing appearances if instructed to do so" do
+      assert_equal(3, @acro_form.flatten(create_appearances: false).size)
+      assert_equal(0, @acro_form.flatten(create_appearances: true).size)
+    end
+
+    it "flattens the whole interactive form" do
+      result = @acro_form.flatten
+      assert(result.empty?)
+      assert(@tf.null?)
+      assert(@cb.null?)
+      assert(@acro_form.null?)
+      refute(@doc.catalog.key?(:AcroForm))
+    end
+
+    it "flattens the given fields" do
+      result = @acro_form.flatten(fields: [@cb])
+      assert(result.empty?)
+      assert(@cb.null?)
+      refute(@tf.null?)
+      refute(@acro_form.null?)
+      assert(@doc.catalog.key?(:AcroForm))
+    end
+
+    it "doesn't delete the form object if not all fields were flattened" do
+      @acro_form.create_appearances
+      @tf.delete(:AP)
+      result = @acro_form.flatten(create_appearances: false)
+      assert_equal(1, result.size)
+      assert(@doc.catalog.key?(:AcroForm))
+    end
+  end
+
   describe "perform_validation" do
     it "checks whether the /DR field is available when /DA is set" do
       @acro_form[:DA] = 'test'

data/test/hexapdf/type/acro_form/test_signature_field.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/signature_field'
+
+describe HexaPDF::Type::AcroForm::SignatureField::LockDictionary do
+  it "validates the presence of the /Fields key" do
+    doc = HexaPDF::Document.new
+    obj = HexaPDF::Type::AcroForm::SignatureField::LockDictionary.new({Action: :All}, document: doc)
+    assert(obj.validate)
+    obj[:Action] = :Include
+    refute(obj.validate)
+  end
+end
+
+describe HexaPDF::Type::AcroForm::SignatureField do
+  before do
+    @doc = HexaPDF::Document.new
+    @field = @doc.wrap({}, type: :XXAcroFormField, subtype: :Sig)
+  end
+
+  it "sets the field value" do
+    @field.field_value = {Empty: :True}
+    assert_equal({Empty: :True}, @field[:V].value)
+  end
+
+  it "gets the field value" do
+    @field[:V] = {Empty: :True}
+    assert_equal({Empty: :True}, @field.field_value.value)
+  end
+
+  it "validates the value of the /FT field" do
+    refute(@field.validate(auto_correct: false))
+    assert(@field.validate)
+    assert_equal(:Sig, @field.field_type)
+  end
+end

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

@@ -56,6 +56,8 @@ describe HexaPDF::Type::Annotations::Widget do
 
   describe "background_color" do
     it "returns the current background color" do
+      assert_nil(@widget.background_color)
+      @widget[:MK] = {BG: []}
       assert_nil(@widget.background_color)
       @widget[:MK] = {BG: [1]}
       assert_equal([1], @widget.background_color.components)

data/test/hexapdf/type/test_annotation.rb

@@ -40,19 +40,29 @@ describe HexaPDF::Type::Annotation do
 
   it "returns the appearance dictionary" do
     @annot[:AP] = :yes
-    assert_equal(:yes, @annot.appearance)
+    assert_equal(:yes, @annot.appearance_dict)
   end
 
-  it "checks whether an appearance exists" do
-    refute(@annot.appearance?)
+  it "returns the appearance stream of the given type" do
+    assert_nil(@annot.appearance)
+
     @annot[:AP] = {N: {}}
-    refute(@annot.appearance?)
-    @annot[:AP][:N] = @doc.wrap({}, stream: '')
-    assert(@annot.appearance?)
-    @annot[:AP][:N] = {okay: @doc.wrap({}, stream: '')}
-    assert(@annot.appearance?)
-    @annot[:AP][:N][:Off] = :other
-    refute(@annot.appearance?)
+    assert_nil(@annot.appearance)
+
+    stream = @doc.wrap({}, stream: '')
+    @annot[:AP][:N] = stream
+    appearance = @annot.appearance
+    assert_same(stream.data, appearance.data)
+    assert_equal(:Form, appearance[:Subtype])
+
+    @annot[:AP][:N] = {X: stream}
+    assert_nil(@annot.appearance)
+
+    @annot[:AS] = :X
+    assert_same(stream.data, @annot.appearance.data)
+
+    @annot[:AP][:D] = {X: stream}
+    assert_same(stream.data, @annot.appearance(:down).data)
   end
 
   describe "flags" do

data/test/hexapdf/type/test_font_descriptor.rb

@@ -44,6 +44,13 @@ describe HexaPDF::Type::FontDescriptor do
       refute(@font_desc.validate)
     end
 
+    it "deletes the /FontWeight value if it doesn't contain a valid value" do
+      @font_desc[:FontWeight] = 350
+      refute(@font_desc.validate(auto_correct: false))
+      assert(@font_desc.validate)
+      refute(@font_desc.key?(:FontWeight))
+    end
+
     it "updates the /Descent value if it is not a negative number" do
       @font_desc[:Descent] = 5
       refute(@font_desc.validate(auto_correct: false))

data/test/hexapdf/type/test_page.rb

@@ -26,7 +26,7 @@ describe HexaPDF::Type::Page do
   end
 
   # Asserts that the page's contents contains the operators.
-  def assert_operators(page, operators)
+  def assert_page_operators(page, operators)
     processor = TestHelper::OperatorRecorder.new
     page.process_contents(processor)
     assert_equal(operators, processor.recorded_ops)
@@ -293,8 +293,8 @@ describe HexaPDF::Type::Page do
     it "parses the contents and processes it" do
       page = @doc.pages.add
       page[:Contents] = @doc.wrap({}, stream: 'q 10 w Q')
-      assert_operators(page, [[:save_graphics_state], [:set_line_width, [10]],
-                              [:restore_graphics_state]])
+      assert_page_operators(page, [[:save_graphics_state], [:set_line_width, [10]],
+                                   [:restore_graphics_state]])
     end
   end
 
@@ -333,60 +333,60 @@ describe HexaPDF::Type::Page do
 
     it "works correctly if invoked on an empty page, using type :page in first invocation" do
       @page.canvas.line_width = 10
-      assert_operators(@page, [[:set_line_width, [10]]])
+      assert_page_operators(@page, [[:set_line_width, [10]]])
 
       @page.canvas(type: :overlay).line_width = 5
-      assert_operators(@page, [[:save_graphics_state], [:restore_graphics_state],
-                               [:save_graphics_state], [:set_line_width, [10]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [5]], [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:restore_graphics_state],
+                                    [:save_graphics_state], [:set_line_width, [10]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [5]], [:restore_graphics_state]])
 
       @page.canvas(type: :underlay).line_width = 2
-      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [10]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [5]], [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [10]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [5]], [:restore_graphics_state]])
     end
 
     it "works correctly if invoked on an empty page, using type :underlay in first invocation" do
       @page.canvas(type: :underlay).line_width = 2
-      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:restore_graphics_state]])
 
       @page.canvas.line_width = 10
-      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [10]], [:restore_graphics_state],
-                               [:save_graphics_state], [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [10]], [:restore_graphics_state],
+                                    [:save_graphics_state], [:restore_graphics_state]])
 
       @page.canvas(type: :overlay).line_width = 5
-      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [10]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [5]], [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [10]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [5]], [:restore_graphics_state]])
     end
 
     it "works correctly if invoked on a page with existing contents" do
       @page.contents = "10 w"
 
       @page.canvas(type: :overlay).line_width = 5
-      assert_operators(@page, [[:save_graphics_state], [:restore_graphics_state],
-                               [:save_graphics_state], [:set_line_width, [10]],
-                               [:restore_graphics_state],
-                               [:save_graphics_state], [:set_line_width, [5]],
-                               [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:restore_graphics_state],
+                                    [:save_graphics_state], [:set_line_width, [10]],
+                                    [:restore_graphics_state],
+                                    [:save_graphics_state], [:set_line_width, [5]],
+                                    [:restore_graphics_state]])
 
       @page.canvas(type: :underlay).line_width = 2
-      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [10]],
-                               [:restore_graphics_state],
-                               [:save_graphics_state], [:set_line_width, [5]],
-                               [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [10]],
+                                    [:restore_graphics_state],
+                                    [:save_graphics_state], [:set_line_width, [5]],
+                                    [:restore_graphics_state]])
     end
 
     it "works correctly if the page has its origin not at (0,0)" do
@@ -395,20 +395,20 @@ describe HexaPDF::Type::Page do
       @page.canvas(type: :page).line_width = 2
       @page.canvas(type: :overlay).line_width = 2
 
-      assert_operators(@page, [[:save_graphics_state],
-                               [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
-                               [:set_line_width, [2]],
-                               [:restore_graphics_state],
+      assert_page_operators(@page, [[:save_graphics_state],
+                                    [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
+                                    [:set_line_width, [2]],
+                                    [:restore_graphics_state],
 
-                               [:save_graphics_state],
-                               [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
-                               [:set_line_width, [2]],
-                               [:restore_graphics_state],
+                                    [:save_graphics_state],
+                                    [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
+                                    [:set_line_width, [2]],
+                                    [:restore_graphics_state],
 
-                               [:save_graphics_state],
-                               [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
-                               [:set_line_width, [2]],
-                               [:restore_graphics_state]])
+                                    [:save_graphics_state],
+                                    [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
+                                    [:set_line_width, [2]],
+                                    [:restore_graphics_state]])
     end
 
     it "fails if the page canvas is requested for a page with existing contents" do
@@ -446,4 +446,142 @@ describe HexaPDF::Type::Page do
       refute_same(form.raw_stream, page[:Contents].raw_stream)
     end
   end
+
+  describe "flatten_annotations" do
+    before do
+      @page = @doc.pages.add
+      @appearance = @doc.add({Type: :XObject, Subtype: :Form, BBox: [-10, -5, 50, 20]}, stream: "")
+      @annot1 = @doc.add({Type: :Annot, Subtype: :Text, Rect: [100, 100, 160, 125], AP: {N: @appearance}})
+      @annot2 = @doc.add({Rect: [10, 10, 70, 35], AP: {N: @appearance}})
+      @page[:Annots] = [@annot1, @annot2]
+      @canvas = @page.canvas(type: :overlay)
+    end
+
+    it "does nothing if the page doesn't have any annotations" do
+      @page.delete(:Annots)
+      result = @page.flatten_annotations
+      assert(result.empty?)
+      assert_operators(@canvas.contents, [])
+    end
+
+    it "flattens all annotations of the page by default" do
+      result = @page.flatten_annotations
+      assert(result.empty?)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1.0, 0, 0, 1.0, 110, 105]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1.0, 0, 0, 1.0, 20, 15]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state]])
+      assert(@annot1.null?)
+      assert(@annot2.null?)
+    end
+
+    it "only deletes the widget annotation of a form field even if it is embedded in the field object" do
+      form = @doc.acro_form(create: true)
+      field = form.create_text_field('test')
+      widget = field.create_widget(@page, Rect: [200, 200, 250, 215])
+      field.field_value = 'hello'
+
+      assert_same(widget.data, field.data)
+      result = @page.flatten_annotations([widget])
+      assert(result.empty?)
+      refute(field.null?)
+    end
+
+    it "does nothing if a given annotation is not part of the page" do
+      annots = [{Test: :Object}]
+      result = @page.flatten_annotations(annots)
+      assert_equal(annots, result)
+    end
+
+    it "deletes hidden annotations but doesn't include them in the content stream" do
+      @annot1.flag(:hidden)
+      result = @page.flatten_annotations
+      assert(result.empty?)
+      assert(@annot1.null?)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1.0, 0, 0, 1.0, 20, 15]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state]])
+    end
+
+    it "deletes invisible annotations but doesn't include them in the content stream" do
+      @annot1.flag(:invisible)
+      result = @page.flatten_annotations
+      assert(result.empty?)
+      assert(@annot1.null?)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1.0, 0, 0, 1.0, 20, 15]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state]])
+    end
+
+    it "ignores annotations without appearane stream" do
+      @annot1.delete(:AP)
+      result = @page.flatten_annotations
+      assert_equal([@annot1], result)
+      refute(@annot1.empty?)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1.0, 0, 0, 1.0, 20, 15]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state]])
+    end
+
+    it "adjusts the position to counter the translation in #canvas based on the page's media box" do
+      @page[:MediaBox] = [-15, -15, 100, 100]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 15, 15]], range: 1)
+    end
+
+    it "adjusts the position in case the form /Matrix has an offset" do
+      @appearance[:Matrix] = [1, 0, 0, 1, 15, 15]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 95, 90]], range: 2)
+    end
+
+    it "adjusts the position for an appearance with a 90 degree rotation" do
+      @appearance[:Matrix] = [0, 1, -1, 0, 0, 0]
+      @annot1[:Rect] = [100, 100, 125, 160]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 120, 110]], range: 2)
+    end
+
+    it "adjusts the position for an appearance with a -90 degree rotation" do
+      @appearance[:Matrix] = [0, -1, 1, 0, 0, 0]
+      @annot1[:Rect] = [100, 100, 125, 160]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 105, 150]], range: 2)
+    end
+
+    it "adjusts the position for an appearance with a 180 degree rotation" do
+      @appearance[:Matrix] = [-1, 0, 0, -1, 0, 0]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 150, 120]], range: 2)
+    end
+
+    it "ignores an appearance with a rotation that is not a mulitple of 90" do
+      @appearance[:Matrix] = [-1, 0.5, 0.5, -1, 0, 0]
+      result = @page.flatten_annotations
+      assert_equal([@annot1, @annot2], result)
+      assert_operators(@canvas.contents, [[:save_graphics_state], [:restore_graphics_state]])
+    end
+
+    it "scales the appearance to fit into the annotations's rectangle" do
+      @annot1[:Rect] = [100, 100, 130, 150]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [0.5, 0, 0, 2, 110, 105]], range: 2)
+    end
+
+  end
 end