hexapdf 0.40.0 → 0.42.0

data/lib/hexapdf/type/acro_form/text_field.rb

@@ -36,6 +36,7 @@
 
 require 'hexapdf/error'
 require 'hexapdf/type/acro_form/variable_text_field'
+require 'hexapdf/type/acro_form/java_script_actions'
 
 module HexaPDF
   module Type
@@ -168,6 +169,8 @@ module HexaPDF
             raise HexaPDF::Error, "Storing a field value for a password field is not allowed"
           elsif comb_text_field? && !key?(:MaxLen)
             raise HexaPDF::Error, "A comb text field need a valid /MaxLen value"
+          elsif str && !str.kind_of?(String)
+            str = @document.config['acro_form.on_invalid_value'].call(self, str)
           end
           str = str.gsub(/[[:space:]]/, ' ') if str && concrete_field_type == :single_line_text_field
           if key?(:MaxLen) && str && str.length > self[:MaxLen]
@@ -241,6 +244,93 @@ module HexaPDF
           create_appearances(force: true)
         end
 
+        # Sets the specified JavaScript format action on the field's widgets.
+        #
+        # This action is executed when the field value needs to be formatted for rendering in the
+        # appearance streams of the associated widgets.
+        #
+        # The argument +type+ can be one of the following:
+        #
+        # :number::
+        #     Assumes that the field value is a number and formats it according to the given
+        #     arguments. See JavaScriptActions.af_number_format_action for details on the arguments.
+        #
+        # :percent::
+        #     Assumes that the field value is a number and formats it as percentage (where 1=100%
+        #     and 0=0%). See JavaScriptActions.af_percent_format_action for details on the
+        #     arguments.
+        #
+        # :time::
+        #     Assumes that the field value is a string with a time value and formats it according to
+        #     the given argument. See JavaScriptActions.af_time_format_action for details on the
+        #     arguments.
+        def set_format_action(type, **arguments)
+          action_string = case type
+                          when :number then JavaScriptActions.af_number_format_action(**arguments)
+                          when :percent then JavaScriptActions.af_percent_format_action(**arguments)
+                          when :time then JavaScriptActions.af_time_format_action(**arguments)
+                          else
+                            raise ArgumentError, "Invalid value for type argument: #{type.inspect}"
+                          end
+          self[:AA] ||= {}
+          self[:AA][:F] = {S: :JavaScript, JS: action_string}
+        end
+
+        # Sets the specified JavaScript calculate action on the field.
+        #
+        # This action is executed by a viewer when any field's value changes so as to recalculate
+        # the value of this field. Usually, the field is also flagged as read only to avoid a user
+        # changing the value manually.
+        #
+        # Note that HexaPDF *doesn't* automatically recalculate field values, use
+        # Form#recalculate_fields to manually kick off recalculation.
+        #
+        # The argument +type+ can be one of the following:
+        #
+        # :sum::
+        #     Sums the values of the given +fields+.
+        #
+        # :average::
+        #     Calculates the average value of the given +fields+.
+        #
+        # :product::
+        #     Multiplies the values of the given +fields+.
+        #
+        # :min::
+        #     Uses the minimum value of the given +fields+.
+        #
+        # :max::
+        #     Uses the maximum value of the given +fields+.
+        #
+        # :sfn::
+        #     Uses the Simplified Field Notation for calculating the field's value. This allows for
+        #     more complex calculations involving addition, subtraction, multiplication and
+        #     division. Field values are specified by using the full field names which should not
+        #     contain spaces or punctuation characters except point.
+        #
+        #     The +fields+ argument needs to contain a string with the SFN calculation rule.
+        #
+        #     Here are some examples:
+        #
+        #       field1 + field2 - field3
+        #       (field.1 + field.2) * (field.3 - field.4)
+        #
+        # Note: Setting this action appends the field to the main Form's /CO entry which specifies
+        # the calculation order. Rearrange the entries as needed.
+        def set_calculate_action(type, fields: nil)
+          action_string = case type
+                          when :sum, :average, :product, :min, :max
+                            JavaScriptActions.af_simple_calculate_action(type, fields)
+                          when :sfn
+                            JavaScriptActions.simplified_field_notation_action(document.acro_form, fields)
+                          else
+                            raise ArgumentError, "Invalid value for type argument: #{type.inspect}"
+                          end
+          self[:AA] ||= {}
+          self[:AA][:C] = {S: :JavaScript, JS: action_string}
+          (document.acro_form[:CO] ||= []) << self
+        end
+
         private
 
         def perform_validation #:nodoc:

data/lib/hexapdf/type/acro_form.rb

@@ -51,6 +51,7 @@ module HexaPDF
       autoload(:SignatureField, 'hexapdf/type/acro_form/signature_field')
 
       autoload(:AppearanceGenerator, 'hexapdf/type/acro_form/appearance_generator')
+      autoload(:JavaScriptActions, 'hexapdf/type/acro_form/java_script_actions')
 
     end
 

data/lib/hexapdf/type/annotations/widget.rb

@@ -85,7 +85,7 @@ module HexaPDF
         define_field :BS,      type: :Border, version: '1.2'
         define_field :Parent,  type: Dictionary
 
-        # Returs the AcroForm field object to which this widget annotation belongs.
+        # Returns the AcroForm field object to which this widget annotation belongs.
         #
         # Since a widget and a field can share the same dictionary object, the returned object is
         # often just the widget re-wrapped in the correct field class.

data/lib/hexapdf/type/resources.rb

@@ -143,7 +143,8 @@ module HexaPDF
       #
       # If the dictionary is not found, an error is raised.
       def font(name)
-        object_getter(:Font, name)
+        font = object_getter(:Font, name)
+        font.kind_of?(Hash) ? document.wrap(font) : font
       end
 
       # Adds the font dictionary to the resources and returns the name under which it is stored.

data/lib/hexapdf/utils.rb

@@ -39,8 +39,27 @@ require 'geom2d/utils'
 module HexaPDF
 
   # This module contains helper methods for the whole library.
+  #
+  # Furthermore, it refines Numeric to provide #mm, #cm, and #inch methods.
   module Utils
 
+    refine Numeric do
+      # Intrepeting self as millimeters returns the equivalent number of points.
+      def mm
+        self * 72 / 25.4
+      end
+
+      # Intrepeting self as centimeters returns the equivalent number of points.
+      def cm
+        self * 72 / 2.54
+      end
+
+      # Intrepeting self as inches returns the equivalent number of points.
+      def inch
+        self * 72
+      end
+    end
+
     # The precision with which to compare floating point numbers.
     #
     # This is chosen with respect to precision that is used for serializing floating point numbers.

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.40.0'
+  VERSION = '0.42.0'
 
 end

data/test/hexapdf/encryption/test_aes.rb

@@ -17,7 +17,6 @@ describe HexaPDF::Encryption::AES do
       end
 
       def process(data)
-        raise "invalid data" if data.empty? || data.length % 16 != 0
         data
       end
     end
@@ -56,10 +55,17 @@ describe HexaPDF::Encryption::AES do
       assert_equal('', @algorithm_class.decrypt('some key' * 2, 'iv' * 8))
     end
 
-    it "fails on decryption if not enough bytes are provided" do
+    it "handles invalid files where not enough bytes are provided" do
+      @algorithm_class.decrypt('some' * 4, 'a' * 36) do |msg|
+        assert_match(/32 \+ 16/, msg)
+        false
+      end
       assert_raises(HexaPDF::EncryptionError) do
         @algorithm_class.decrypt('some' * 4, 'no iv')
       end
+      assert_raises(HexaPDF::EncryptionError) do
+        @algorithm_class.decrypt('some' * 4, 'no iv') { true }
+      end
     end
   end
 
@@ -126,12 +132,16 @@ describe HexaPDF::Encryption::AES do
       assert_equal('', collector(@algorithm_class.decryption_fiber('key', Fiber.new { '' })))
     end
 
-    it "fails on decryption if not enough bytes are provided" do
-      [4, 20, 40].each do |length|
-        assert_raises(HexaPDF::EncryptionError) do
-          collector(@algorithm_class.decryption_fiber('some' * 4,
-                                                      Fiber.new { 'a' * length }))
-        end
+    it "handles invalid files where not enough bytes are provided" do
+      collector(@algorithm_class.decryption_fiber('some' * 4, Fiber.new { 'a' * 40 }) do |msg|
+        assert_match(/32 \+ 16/, msg)
+        false
+      end)
+      assert_raises(HexaPDF::EncryptionError) do
+        collector(@algorithm_class.decryption_fiber('some' * 4, Fiber.new { 'a' * 40 }))
+      end
+      assert_raises(HexaPDF::EncryptionError) do
+        collector(@algorithm_class.decryption_fiber('some' * 4, Fiber.new { 'a' * 40 })) { true }
       end
     end
   end

data/test/hexapdf/encryption/test_security_handler.rb

@@ -332,11 +332,28 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
 
     it "enhances a thrown EncryptionError by setting the PDF object" do
+      @document.config['encryption.on_decryption_error'] = proc { true }
       @handler.set_up_encryption(key_length: 256)
       error = assert_raises(HexaPDF::EncryptionError) { @handler.decrypt(@obj) }
       assert_match(/Object \(1,0\):/, error.message)
     end
 
+    it "uses the encryption.on_decryption_error configuration option" do
+      @handler.set_up_encryption(key_length: 256)
+      @handler.decrypt(@obj)
+      assert_equal('', @obj[:Key])
+
+      @obj[:Key] = @encrypted
+      called = false
+      @document.config['encryption.on_decryption_error'] = proc do |obj, msg|
+        assert_same(@obj, obj)
+        assert_match(/32 \+ 16/, msg)
+        called = true
+      end
+      assert_raises(HexaPDF::EncryptionError) { @handler.decrypt(@obj) }
+      assert(called)
+    end
+
     it "fails if V < 5 and the object number changes" do
       @obj.oid = 55
       @handler.decrypt(@obj)

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -258,7 +258,7 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
       end
 
       it "fails if the field cannot be decrypted" do
-        @dict[:Perms].succ!
+        @dict[:Perms].setbyte(-1, (@dict[:Perms].getbyte(-1) + 1) % 256)
         exp = assert_raises(HexaPDF::EncryptionError) { @handler.set_up_decryption(@dict) }
         assert_match(/cannot be decrypted/, exp.message)
       end

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

@@ -33,10 +33,11 @@ describe HexaPDF::Font::CMap::Parser do
         <8145> <8145> 8123
         <8146> <8148> 9000
         endcidrange
-        2 beginbfrange
+        4 beginbfrange
         <0000> <005E> <0020>
         <1379> <137B> <90FE>
         <005F> <0061> [ <00660066> <00660069> <00660066006C> ]
+        <E040> <E041> <D840DC3D>
         endbfrange
         1 beginbfchar
         <3A51> <D840DC3E>
@@ -82,8 +83,9 @@ describe HexaPDF::Font::CMap::Parser do
       assert_equal("ff", cmap.to_unicode(0x5F))
       assert_equal("fi", cmap.to_unicode(0x60))
       assert_equal("ffl", cmap.to_unicode(0x61))
-      assert_equal("\xD8\x40\xDC\x3E".encode("UTF-8", "UTF-16BE"),
-                   cmap.to_unicode(0x3A51))
+      symbol = "\xD8\x40\xDC\x3E".encode("UTF-8", "UTF-16BE")
+      assert_equal(symbol, cmap.to_unicode(0xE041))
+      assert_equal(symbol, cmap.to_unicode(0x3A51))
       assert_nil(cmap.to_unicode(0xFF))
     end
 

data/test/hexapdf/font/test_cmap.rb

@@ -97,6 +97,14 @@ describe HexaPDF::Font::CMap do
       assert_equal("ABC", @cmap.to_unicode(20))
     end
 
+    it "allows adding a code range to unicode mapping and retrieving the values" do
+      @cmap.add_unicode_range_mapping(20, 30, [65])
+      @cmap.add_unicode_range_mapping(40, 41, [0xD840, 0xDC3D])
+      assert_equal("A", @cmap.to_unicode(20))
+      assert_equal("K", @cmap.to_unicode(30))
+      assert_equal("𠀾", @cmap.to_unicode(41))
+    end
+
     it "returns nil for unknown mappings" do
       assert_nil(@cmap.to_unicode(20))
     end

data/test/hexapdf/font_loader/test_from_configuration.rb

@@ -37,6 +37,10 @@ describe HexaPDF::FontLoader::FromConfiguration do
     assert_nil(@klass.call(@doc, "Unknown"))
   end
 
+  it "allows arbitrary keywords arguments" do
+    assert_nil(@klass.call(@doc, "Unknown", something: :other))
+  end
+
   it "returns a hash with all configured fonts" do
     assert_equal({'font' => [:none], 'font1' => [:none]}, @klass.available_fonts(@doc))
   end

data/test/hexapdf/font_loader/test_variant_from_name.rb

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font_loader'
+require 'hexapdf/document'
+
+describe HexaPDF::FontLoader::VariantFromName do
+  before do
+    @doc = HexaPDF::Document.new
+    @obj = HexaPDF::FontLoader::VariantFromName
+  end
+
+  it "loads the font if the name contains a valid variant" do
+    wrapper = @obj.call(@doc, "Helvetica bold")
+    assert_equal("Helvetica-Bold", wrapper.wrapped_font.font_name)
+    wrapper = @obj.call(@doc, "Helvetica italic")
+    assert_equal("Helvetica-Oblique", wrapper.wrapped_font.font_name)
+    wrapper = @obj.call(@doc, "Helvetica bold_italic")
+    assert_equal("Helvetica-BoldOblique", wrapper.wrapped_font.font_name)
+  end
+
+  it "returns nil if the font name contains an unknown variant" do
+    assert_nil(@obj.call(@doc, "Helvetica oblique"))
+  end
+
+  it "ignores a supplied variant keyword argument" do
+    wrapper = @obj.call(@doc, "Helvetica bold", variant: :italic)
+    assert_equal("Helvetica-Bold", wrapper.wrapped_font.font_name)
+  end
+
+  it "returns nil for unknown fonts" do
+    assert_nil(@obj.call(@doc, "Unknown"))
+  end
+end

data/test/hexapdf/test_utils.rb

@@ -6,6 +6,22 @@ require 'hexapdf/utils'
 describe HexaPDF::Utils do
   include HexaPDF::Utils
 
+  describe "Numeric refinement" do
+    using HexaPDF::Utils
+
+    it "converts mm to points" do
+      assert_equal(72, 25.4.mm)
+    end
+
+    it "converts cm to points" do
+      assert_equal(72, 2.54.cm)
+    end
+
+    it "converts inch to points" do
+      assert_equal(144, 2.inch)
+    end
+  end
+
   it "checks floats for equality with a certain precision" do
     assert(float_equal(1.0, 1))
     assert(float_equal(1.0, 1.0000003))

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

@@ -235,6 +235,12 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
         assert(@widget.flagged?(:print))
       end
 
+      it "removes the hidden flag on the widgets" do
+        @widget.flag(:hidden)
+        @generator.create_appearances
+        refute(@widget.flagged?(:hidden))
+      end
+
       it "adjusts the /Rect if width is zero" do
         @generator.create_appearances
         assert_equal(12, @widget[:Rect].width)
@@ -272,6 +278,19 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
         end
       end
 
+      it "creates the needed appearance dictionary for the normal appearance" do
+        @widget[:AP][:N] = 5
+        @generator.create_appearances
+        assert_equal(:XObject, @widget[:AP][:N][:Off].type)
+        assert_equal(:XObject, @widget[:AP][:N][:Yes].type)
+
+        @field[:V] = :Other
+        @widget[:AP][:N] = @doc.wrap({Type: :XObject, Subtype: :Form})
+        @generator.create_appearances
+        assert_equal(:XObject, @widget[:AP][:N][:Off].type)
+        assert_equal(:XObject, @widget[:AP][:N][:Other].type)
+      end
+
       it "creates the needed appearance streams" do
         @widget[:AP][:N].delete(:Off)
         @generator.create_appearances
@@ -309,7 +328,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                           [:restore_graphics_state]])
       end
 
-      it "fails if the appearance dictionaries are not set up" do
+      it "fails if the appearance dictionary doesn't contain a name for the on state" do
         @widget[:AP][:N].delete(:Yes)
         assert_raises(HexaPDF::Error) { @generator.create_appearances }
       end
@@ -371,6 +390,12 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       assert(@widget.flagged?(:print))
     end
 
+    it "removes the hidden flag on the widgets" do
+      @widget.flag(:hidden)
+      @generator.create_appearances
+      refute(@widget.flagged?(:hidden))
+    end
+
     describe "it adjusts the :Rect when necessary" do
       before do
         @widget.border_style(width: 3)
@@ -549,52 +574,11 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
         end
       end
 
-      describe "Javascript action AFNumber_Format" do
-        before do
-          @field[:V] = '1234567.898765'
-          @action = {S: :JavaScript, JS: ''}
-          @field[:AA] = {F: @action}
-        end
-
-        def assert_format(arg_string, result, range)
-          @action[:JS] = "AFNumber_Format(#{arg_string});"
-          @generator.create_appearances
-          assert_operators(@widget[:AP][:N].stream, result, range: range)
-        end
-
-        it "respects the set number of decimals" do
-          assert_format('0, 2, 0, 0, "E", false',
-                        [:show_text, ["1.234.568E"]], 9)
-          assert_format('2, 2, 0, 0, "E", false',
-                        [:show_text, ["1.234.567,90E"]], 9)
-        end
-
-        it "respects the digit separator style" do
-          ["1,234,567.90", "1234567.90", "1.234.567,90", "1234567,90"].each_with_index do |result, style|
-            assert_format("2, #{style}, 0, 0, \"\", false", [:show_text, [result]], 9)
-          end
-        end
-
-        it "respects the negative value styling" do
-          @field[:V] = '-1234567.898'
-          @widget[:Rect].height = 11.25
-          ["-E1234567,90", "E1234567,90", "(E1234567,90)", "(E1234567,90)"].each_with_index do |result, style|
-            assert_format("2, 3, #{style}, 0, \"E\", true",
-                          [[:set_device_rgb_non_stroking_color, [style % 2, 0.0, 0.0]],
-                           [:begin_text],
-                           [:set_text_matrix, [1, 0, 0, 1, 2, 3.183272]],
-                           [:show_text, [result]]], 6..9)
-          end
-        end
-
-        it "respects the specified currency string and position" do
-          assert_format('2, 3, 0, 0, " E", false', [:show_text, ["1234567,90 E"]], 9)
-          assert_format('2, 3, 0, 0, "E ", true', [:show_text, ["E 1234567,90"]], 9)
-        end
-
-        it "does nothing to the value if the Javascript method could not be determined " do
-          assert_format('2, 3, 0, 0, " E", false, a', [:show_text, ["1234567.898765"]], 8)
-        end
+      it "applies JavaScript format actions" do
+        @field[:V] = '1234567.898765'
+        @field[:AA] = {F: {S: :JavaScript, JS: 'AFNumber_Format(0, 2, 0, 0, "E", false);'}}
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream, [:show_text, ["1.234.568E"]], range: 9)
       end
 
       it "creates the /N appearance stream according to the set string" do

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

@@ -93,6 +93,11 @@ describe HexaPDF::Type::AcroForm::ButtonField do
       @field.field_value = "check"
       assert_equal(:check, @field[:V])
       assert_raises(HexaPDF::Error) { @field.field_value = :unknown }
+
+      @field.field_value = :Off
+      @field.create_widget(@doc.pages[0], value: :other)
+      @field.field_value = true
+      assert_equal(:check, @field[:V])
     end
 
     it "returns the correct concrete field type" do

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

@@ -34,6 +34,13 @@ describe HexaPDF::Type::AcroForm::Field do
     assert_equal(:Ch, @field[:FT])
   end
 
+  it "wraps fields inside the correct subclass" do
+    field = HexaPDF::Type::AcroForm::Field.wrap(@doc, {FT: :Tx})
+    assert_kind_of(HexaPDF::Type::AcroForm::TextField, field)
+    field = HexaPDF::Type::AcroForm::Field.wrap(@doc, {})
+    assert_kind_of(HexaPDF::Type::AcroForm::Field, field)
+  end
+
   it "has convenience methods for accessing the field flags" do
     assert_equal([], @field.flags)
     refute(@field.flagged?(:required))
@@ -100,6 +107,10 @@ describe HexaPDF::Type::AcroForm::Field do
     refute(@field.terminal_field?)
   end
 
+  it "returns itself when asked for the form field" do
+    assert_same(@field, @field.form_field)
+  end
+
   it "can check whether a widget is embedded in the field" do
     refute(@field.embedded_widget?)
     @field[:Subtype] = :Wdiget

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

@@ -241,6 +241,53 @@ describe HexaPDF::Type::AcroForm::Form do
     end
   end
 
+  describe "fill" do
+    it "works for text field types" do
+      field = @acro_form.create_text_field('test')
+      @acro_form.fill("test" => "value")
+      assert_equal("value", field.field_value)
+    end
+
+    it "works for radio buttons" do
+      field = @acro_form.create_radio_button("test")
+      field.create_widget(@doc.pages.add, value: :name)
+      @acro_form.fill("test" => "name")
+      assert_equal(:name, field.field_value)
+    end
+
+    it "works for check boxes" do
+      field = @acro_form.create_check_box('test')
+      field.create_widget(@doc.pages.add)
+
+      ["t", "true", "y", "yes"].each do |value|
+        @acro_form.fill("test" => value)
+        assert_equal(:Yes, field.field_value)
+        field.field_value = :Off
+      end
+
+      ["f", "false", "n", "no"].each do |value|
+        @acro_form.fill("test" => value)
+        assert_nil(field.field_value)
+        field.field_value = :Yes
+      end
+
+      field.create_widget(@doc.pages.add, value: :Other)
+      @acro_form.fill("test" => "Other")
+      assert_equal(:Other, field.field_value)
+    end
+
+    it "raises an error if a field is not found" do
+      error = assert_raises(HexaPDF::Error) { @acro_form.fill("unknown" => "test") }
+      assert_match(/named 'unknown' not found/, error.message)
+    end
+
+    it "raises an error if a field type is not supported for filling in" do
+      @acro_form.create_check_box('test').initialize_as_push_button
+      error = assert_raises(HexaPDF::Error) { @acro_form.fill("test" => "test") }
+      assert_match(/push_button not yet supported/, error.message)
+    end
+  end
+
   it "returns the default resources" do
     assert_kind_of(HexaPDF::Type::Resources, @acro_form.default_resources)
   end
@@ -342,6 +389,39 @@ describe HexaPDF::Type::AcroForm::Form do
     end
   end
 
+  describe "recalculate_fields" do
+    before do
+      @text1 = @acro_form.create_text_field('text1')
+      @text2 = @acro_form.create_text_field('text2')
+      @text3 = @acro_form.create_text_field('text3')
+    end
+
+    it "recalculates all fields listed in /CO" do
+      @text1.field_value = "10"
+      @text2.field_value = "30"
+      @text3.set_calculate_action(:sum, fields: ['text1', @text2])
+      @acro_form.recalculate_fields
+      assert_equal("40", @text3.field_value)
+    end
+
+    it "doesn't change the field's value if there is an error" do
+      @text3.set_calculate_action(:sfn, fields: 'text1 - text2')
+      @text3[:AA][:C][:JS] = @text3[:AA][:C][:JS].sub('text1', 'text4')
+      @acro_form.recalculate_fields
+      assert_nil(@text3.field_value)
+    end
+
+    it "works if fields aren't already loaded and correctly wrapped" do
+      @text1.field_value = "10"
+      @text3.set_calculate_action(:sfn, fields: 'text1')
+      @text3[:AA] = {C: HexaPDF::Reference.new(@doc.add(@text3[:AA][:C]).oid)}
+      @acro_form[:CO] = [HexaPDF::Reference.new(@text3.oid, @text3.gen)]
+      @doc.revisions.current.update(@doc.wrap(@text3, type: HexaPDF::Dictionary))
+      @acro_form.recalculate_fields
+      assert_equal("10", @text3.field_value)
+    end
+  end
+
   describe "perform_validation" do
     it "checks whether the /DR field is available when /DA is set" do
       @acro_form[:DA] = 'test'