hexapdf 0.39.1 → 0.41.0

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/layout/test_list_box.rb

@@ -73,6 +73,12 @@ describe HexaPDF::Layout::ListBox do
         check_box(box, 100, 40)
       end
 
+      it "respects the set initial height and the property overflow=:truncate" do
+        box = create_box(children: @text_boxes[0, 2], height: 20,
+                         style: {overflow: :truncate, position: position})
+        check_box(box, 100, 20)
+      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})
@@ -108,7 +114,14 @@ describe HexaPDF::Layout::ListBox do
       check_box(box, 100, 70, [[10, 80], [10, 30]])
     end
 
-    it "fails for unknown item types" do
+    it "creates a new box for each marker even if the marker is the same" do
+      box = create_box(children: @text_boxes[0, 2])
+      check_box(box, 100, 40)
+      results = box.instance_variable_get(:@results)
+      refute_same(results[0].marker, results[1].marker)
+    end
+
+    it "fails for unknown marker types" do
       box = create_box(children: @text_boxes[0, 1], marker_type: :unknown)
       assert_raises(HexaPDF::Error) { box.fit(100, 100, @frame) }
     end
@@ -136,6 +149,17 @@ describe HexaPDF::Layout::ListBox do
       assert_equal(2, box_b.children.size)
       assert_equal(1, box_b.start_number)
     end
+
+    it "splits a list item containg multiple boxes along box lines" do
+      box = create_box(children: [@text_boxes[0], @text_boxes[1, 2]])
+      box.fit(100, 40, @frame)
+      box_a, box_b = box.split(100, 40, @frame)
+      assert_same(box, box_a)
+      assert_equal(:hide_first_marker, box_b.split_box?)
+      assert_equal(1, box_a.instance_variable_get(:@results)[1].box_fitter.fit_results.size)
+      assert_equal(1, box_b.children.size)
+      assert_equal(2, box_b.start_number)
+    end
   end
 
   describe "draw" do
@@ -315,5 +339,10 @@ describe HexaPDF::Layout::ListBox do
       assert_equal(:ZapfDingbats, @canvas.resources.font(:F1)[:BaseFont])
     end
 
+    it "fails if the initial height is set and property overflow is set to :error" do
+      box = create_box(children: @fixed_size_boxes[0, 2], height: 10)
+      box.fit(100, 100, @frame)
+      assert_raises(HexaPDF::Error) { box.draw(@canvas, 0, 100 - box.height) }
+    end
   end
 end

data/test/hexapdf/layout/test_style.rb

@@ -783,7 +783,7 @@ describe HexaPDF::Layout::Style do
     refute(@style.superscript)
     refute(@style.last_line_gap)
     refute(@style.fill_horizontal)
-    assert_equal(:error, @style.text_overflow)
+    assert_equal(:error, @style.overflow)
     assert_kind_of(HexaPDF::Layout::Style::Layers, @style.underlays)
     assert_kind_of(HexaPDF::Layout::Style::Layers, @style.overlays)
     assert_equal(:default, @style.position)

data/test/hexapdf/layout/test_text_box.rb

@@ -79,13 +79,13 @@ describe HexaPDF::Layout::TextBox do
       end
     end
 
-    it "respects the style property text_overflow when fitting too much text" do
+    it "respects the style property overflow when fitting too much text" do
       box = create_box([@inline_box] * 20, height: 15)
       refute(box.fit(100, 100, @frame))
-      box.style.text_overflow = :truncate
+      box.style.overflow = :truncate
       assert(box.fit(100, 100, @frame))
 
-      box = create_box([@inline_box] * 20, style: {text_overflow: :truncate})
+      box = create_box([@inline_box] * 20, style: {overflow: :truncate})
       refute(box.fit(100, 15, @frame))
     end
 
@@ -196,7 +196,7 @@ describe HexaPDF::Layout::TextBox do
       assert_operators(@canvas.contents, [])
     end
 
-    it "raises an error if there is too much content for a set height with text_overlow=:error" do
+    it "raises an error if there is too much content for a set height with overflow=:error" do
       box = create_box([@inline_box] * 20, height: 15)
       box.fit(100, 100, @frame)
       assert_raises(HexaPDF::Error) { box.draw(@canvas, 0, 0) }

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_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

@@ -342,6 +342,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'

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

@@ -0,0 +1,226 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/java_script_actions'
+
+describe HexaPDF::Type::AcroForm::JavaScriptActions do
+  before do
+    @klass = HexaPDF::Type::AcroForm::JavaScriptActions
+    @action = {S: :JavaScript}
+  end
+
+  describe "format" do
+    it "returns the original value if the format action can't be processed" do
+      @action[:JS] = 'Unknown();'
+      @klass.apply_format("10", @action)
+    end
+
+    describe "AFNumber_Format" do
+      before do
+        @value = '1234567.898765'
+        @action[:JS] = ''
+      end
+
+      it "returns a correct JavaScript string" do
+        assert_equal('AFNumber_Format(2, 0, 0, 0, "", true);',
+                     @klass.af_number_format_action)
+        assert_equal('AFNumber_Format(1, 1, 1, 0, "E", false);',
+                     @klass.af_number_format_action(decimals: 1, separator_style: :point_no_thousands,
+                                                    negative_style: :red, currency_string: "E",
+                                                    prepend_currency: false))
+      end
+
+      def assert_format(arg_string, result_value, result_color)
+        @action[:JS] = "AFNumber_Format(#{arg_string});"
+        value, text_color = @klass.apply_format(@value, @action)
+        assert_equal(result_value, value)
+        result_color ? assert_equal(result_color, text_color) : assert_nil(text_color)
+      end
+
+      it "works with both commas and points as decimal separator" do
+        @value = '1234567.898'
+        assert_format('2, 2, 0, 0, "", false', "1.234.567,90", "black")
+        @value = '1234567,898'
+        assert_format('2, 2, 0, 0, "", false', "1.234.567,90", "black")
+        @value = '123,4567,898'
+        assert_format('2, 2, 0, 0, "", false', "123,46", "black")
+      end
+
+      it "respects the set number of decimals" do
+        assert_format('0, 2, 0, 0, "E", false', "1.234.568E", "black")
+        assert_format('2, 2, 0, 0, "E", false', "1.234.567,90E", "black")
+      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", result, "black")
+        end
+      end
+
+      it "respects the negative value styling" do
+        @value = '-1234567.898'
+        [["-E1234567,90", "black"], ["E1234567,90", "red"], ["(E1234567,90)", "black"],
+         ["(E1234567,90)", "red"]].each_with_index do |result, style|
+          assert_format("2, 3, #{style}, 0, \"E\", true", result[0], result[1])
+        end
+      end
+
+      it "respects the specified currency string and position" do
+        assert_format('2, 3, 0, 0, " E", false', "1234567,90 E", "black")
+        assert_format('2, 3, 0, 0, "E ", true', "E 1234567,90", "black")
+      end
+
+      it "allows omitting the trailing semicolon" do
+        @action[:JS] = "AFNumber_Format(2,2,0,0,\"\",false )"
+        value, = @klass.apply_format('1234.567', @action)
+        assert_equal('1.234,57', value)
+      end
+
+      it "does nothing to the value if the JavasSript method could not be determined " do
+        assert_format('2, 3, 0, 0, " E", false, a', "1234567.898765", nil)
+      end
+    end
+  end
+
+  describe "calculate" do
+    before do
+      @doc = HexaPDF::Document.new
+      @form = @doc.acro_form(create: true)
+      @form.create_text_field('text')
+      @field1 = @form.create_text_field('text.1')
+      @field1.field_value = "10"
+      @field2 = @form.create_text_field('text.2')
+      @field2.field_value = "20"
+      @field3 = @form.create_text_field('text.3')
+      @field3.field_value = "30"
+    end
+
+    it "returns nil if the calculate action is not a JavaScript action" do
+      @action[:S] = :GoTo
+      assert_nil(@klass.calculate(@form, @action))
+    end
+
+    it "returns nil if the calculate action contains unknown JavaScript" do
+      @action[:JS] = 'Unknown();'
+      assert_nil(@klass.calculate(@form, @action))
+    end
+
+    describe "predefined calculations" do
+      it "returns a correct JavaScript string" do
+        assert_equal('AFSimple_Calculate("SUM", ["text.1","text.2"]);',
+                     @klass.af_simple_calculate_action(:sum, ['text.1', @field2]))
+      end
+
+      def assert_calculation(function, fields, value)
+        fields = fields.map {|field| "\"#{field.full_field_name}\"" }.join(", ")
+        @action[:JS] = "AFSimple_Calculate(\"#{function}\", new Array(#{fields}));"
+        assert_equal(value, @klass.calculate(@form, @action))
+      end
+
+      it "can sum fields" do
+        assert_calculation('SUM', [@field1, @field2, @field3], "60")
+      end
+
+      it "can average fields" do
+        assert_calculation('AVG', [@field1, @field2, @field3], "20")
+      end
+
+      it "can multiply fields" do
+        assert_calculation('PRD', [@field1, @field2, @field3], "6000")
+      end
+
+      it "can find the minimum field value" do
+        assert_calculation('MIN', [@field1, @field2, @field3], "10")
+      end
+
+      it "can find the maximum field value" do
+        assert_calculation('MAX', [@field1, @field2, @field3], "30")
+      end
+
+      it "works with floats" do
+        @field1.field_value = "10,54"
+        assert_calculation('SUM', [@field1, @field2], "30.54")
+      end
+
+      it "returns nil if a field cannot be resolved" do
+        @action[:JS] = 'AFSimple_Calculate("SUM", ["unknown"]);'
+        assert_nil(@klass.calculate(@form, @action))
+      end
+
+      it "allows omitting the trailing semicolon" do
+        @action[:JS] = 'AFSimple_Calculate("SUM", ["text.1"] )'
+        assert_equal("10", @klass.calculate(@form, @action))
+      end
+    end
+
+    describe "simplified field notation calculations" do
+      it "returns a correct JavaScript string" do
+        sfn = '(text.1 + text.2) * text.3 - text.1 / text.1 + 0 + 5.43 + 7,24'
+        assert_equal("/** BVCALC #{sfn} EVCALC **/ " \
+                     'event.value = (AFMakeNumber(getField("text.1").value) + ' \
+                     'AFMakeNumber(getField("text.2").value)) * ' \
+                     'AFMakeNumber(getField("text.3").value) - ' \
+                     'AFMakeNumber(getField("text.1").value) / ' \
+                     'AFMakeNumber(getField("text.1").value) ' \
+                     '+ 0.0 + 5.43 + 7.24',
+                     @klass.simplified_field_notation_action(@form, sfn))
+      end
+
+      it "fails if the SFN string is invalid when generating a JavaScript action string" do
+        assert_raises(ArgumentError) { @klass.simplified_field_notation_action(@form, '(test') }
+      end
+
+      def assert_calculation(sfn, value)
+        @action[:JS] = "/** BVCALC #{sfn} EVCALC **/"
+        result = @klass.calculate(@form, @action)
+        value ? assert_equal(value, result) : assert_nil(result)
+      end
+
+      it "works for additions" do
+        assert_calculation('text.1 + text.2 + text.1', "40")
+      end
+
+      it "works for substraction" do
+        assert_calculation('text.2-text\.1', "10")
+      end
+
+      it "works for multiplication" do
+        assert_calculation('text.2\* text\.1 * text\.3', "6000")
+      end
+
+      it "works for division" do
+        assert_calculation('text.2 /text\.1', "2")
+      end
+
+      it "works with parentheses" do
+        assert_calculation('(text.2 + (text.1*text.3))', "320")
+      end
+
+      it "works with numbers" do
+        assert_calculation('text.1 + 10.54 - 1,54 + 3', "22")
+      end
+
+      it "works in a more complex case" do
+        assert_calculation('(text.1 + text.2)/(text.3) * text.1', "10")
+      end
+
+      it "works with floats" do
+        @field1.field_value = "10,54"
+        assert_calculation('text.1 + text.2', "30.54")
+      end
+
+      it "fails if a referenced field is not a terminal field" do
+        assert_calculation('text + text.2', nil)
+      end
+
+      it "fails if a referenced field does not exist" do
+        assert_calculation('unknown + text.2', nil)
+      end
+
+      it "fails if parentheses don't match" do
+        assert_calculation('(text.1 + text.2', nil)
+      end
+    end
+  end
+end