hexapdf 0.26.2 → 0.28.0

data/test/hexapdf/filter/test_predictor.rb

@@ -4,7 +4,6 @@ require_relative 'common'
 require 'hexapdf/filter/predictor'
 
 describe HexaPDF::Filter::Predictor do
-
   module CommonPredictorTests
     def test_decoding_through_decoder_method
       @testcases.each do |name, data|

data/test/hexapdf/layout/test_box.rb

@@ -131,7 +131,8 @@ describe HexaPDF::Layout::Box do
       assert_equal([nil, box], box.split(150, 150, nil))
     end
 
-    it "can't be split if it doesn't (completely) fit as the default implementation knows nothing about the content" do
+    it "can't be split if it doesn't (completely) fit as the default implementation " \
+      "knows nothing about the content" do
       @box.style.position = :flow # make sure we would generally be splitable
       @box.fit(90, 100, nil)
       assert_equal([nil, @box], @box.split(150, 150, nil))

data/test/hexapdf/layout/test_column_box.rb

@@ -11,7 +11,7 @@ describe HexaPDF::Layout::ColumnBox do
     @text_boxes = 5.times.map do
       HexaPDF::Layout::TextBox.new(items: [inline_box] * 15, style: {position: :default})
     end
-    draw_block = lambda do |canvas, box|
+    draw_block = lambda do |canvas, _box|
       canvas.move_to(0, 0).end_path
     end
     @fixed_size_boxes = 15.times.map { HexaPDF::Layout::Box.new(width: 20, height: 10, &draw_block) }

data/test/hexapdf/layout/test_list_box.rb

@@ -222,7 +222,7 @@ describe HexaPDF::Layout::ListBox do
     end
 
     it "allows drawing custom markers" do
-      marker = lambda do |doc, list_box, index|
+      marker = lambda do |_doc, _list_box, _index|
         HexaPDF::Layout::Box.create(width: 10, height: 10) {}
       end
       box = create_box(children: @fixed_size_boxes[0, 1], item_type: marker)

data/test/hexapdf/test_document.rb

@@ -163,14 +163,8 @@ describe HexaPDF::Document do
       refute_equal(0, obj.oid)
     end
 
-    it "fails if the given object is not a PDF object" do
-      assert_raises(ArgumentError) { @doc.import(5) }
-    end
-
-    it "fails if the given object is associated with no or the destination document" do
-      assert_raises(ArgumentError) { @doc.import(HexaPDF::Object.new(5)) }
-      obj = @doc.add(5)
-      assert_raises(ArgumentError) { @doc.import(obj) }
+    it "works if the given object is not a PDF object" do
+      assert_equal(5, @doc.import(5))
     end
   end
 

data/test/hexapdf/test_importer.rb

@@ -19,6 +19,7 @@ describe HexaPDF::Importer::NullableWeakRef do
 end
 
 describe HexaPDF::Importer do
+  class TestClass < HexaPDF::Dictionary; end
   before do
     @source = HexaPDF::Document.new
     obj = @source.add("test")
@@ -30,12 +31,12 @@ describe HexaPDF::Importer do
     @source.pages.add
     @source.pages.root[:Rotate] = 90
     @dest = HexaPDF::Document.new
-    @importer = HexaPDF::Importer.for(source: @source, destination: @dest)
+    @importer = HexaPDF::Importer.for(@dest)
   end
 
   describe "::for" do
     it "caches the importer" do
-      assert_same(@importer, HexaPDF::Importer.for(source: @source, destination: @dest))
+      assert_same(@importer, HexaPDF::Importer.for(@dest))
     end
   end
 
@@ -60,8 +61,14 @@ describe HexaPDF::Importer do
     end
 
     it "can import a direct object" do
-      obj = @importer.import(key: @obj)
-      assert(@dest.object?(obj[:key]))
+      assert_nil(@importer.import(nil))
+      assert_equal(5, @importer.import(5))
+      assert(@dest.object?(@importer.import({key: @obj})[:key]))
+    end
+
+    it "determines the source document dynamically" do
+      obj = @importer.import(@obj.value)
+      assert_equal("test", obj[:ref].value)
     end
 
     it "copies the data of the imported objects" do
@@ -86,6 +93,19 @@ describe HexaPDF::Importer do
       assert_same(hash, obj[:hash])
     end
 
+    it "uses the class of the argument when directly importing a HexaPDF::Object" do
+      src_obj = @source.wrap(@hash, type: TestClass)
+      dest_obj = @importer.import(src_obj)
+      assert_instance_of(TestClass, dest_obj)
+    end
+
+    it "uses the class of the argument when importing an already mapped HexaPDF::Object" do
+      @importer.import(@obj) # also maps @hash
+      src_obj = @source.wrap(@hash, type: TestClass)
+      dest_obj = @importer.import(src_obj)
+      assert_instance_of(TestClass, dest_obj)
+    end
+
     it "duplicates the stream if it is a string" do
       src_obj = @source.add({}, stream: 'data')
       dst_obj = @importer.import(src_obj)
@@ -106,10 +126,11 @@ describe HexaPDF::Importer do
       assert_equal(90, page[:Rotate])
     end
 
-    it "raise an error if the given object doesn't belong to the source document" do
+    it "works for importing objects from different documents" do
       other_doc = HexaPDF::Document.new
       other_obj = other_doc.add("test")
-      assert_raises(HexaPDF::Error) { @importer.import(other_obj) }
+      imported = @importer.import(other_obj)
+      assert_equal("test", imported.value)
     end
   end
 end

data/test/hexapdf/test_parser.rb

@@ -54,6 +54,23 @@ describe HexaPDF::Parser do
     @parser = HexaPDF::Parser.new(@parse_io, @document)
   end
 
+  describe "linearized?" do
+    it "can determine whether a document is linearized" do
+      create_parser("%PDF-1.7\n%abcdefgh\n1 0 obj\n<</Linearized 1/H [2 4]/O 1/E 1/N 1/T 1>>\nendobj")
+      assert(@parser.linearized?)
+    end
+
+    it "returns false if the first object is not a linearization dictionary" do
+      create_parser("%PDF-1.7\n%abcdefgh\n1 0 obj\n<</Length 2 0 R>>\nstream\nhallo\nendstream\nendobj")
+      refute(@parser.linearized?)
+    end
+
+    it "returns false if there is a parse error" do
+      create_parser("%PDF-1.7\n%abcdefgh\n1 a obj thing")
+      refute(@parser.linearized?)
+    end
+  end
+
   describe "parse_indirect_object" do
     it "reads indirect objects sequentially" do
       object, oid, gen, stream = @parser.parse_indirect_object
@@ -108,7 +125,7 @@ describe HexaPDF::Parser do
     end
 
     it "treats indirect objects with invalid values as null objects" do
-      create_parser("1 0 obj <</test ( /other (end)>> endobj")
+      create_parser("1 0 obj <</test <end)> > endobj")
       object, * = @parser.parse_indirect_object
       assert_nil(object)
     end
@@ -210,7 +227,7 @@ describe HexaPDF::Parser do
       end
 
       it "fails for invalid values" do
-        create_parser("1 0 obj <</test ( /other (end)>> endobj")
+        create_parser("1 0 obj <</test <end)> >endobj")
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
         assert_match(/Invalid value after '1 0 obj'/, exp.message)
       end

data/test/hexapdf/test_revision.rb

@@ -199,6 +199,14 @@ describe HexaPDF::Revision do
       deleted = @rev.object(6)
       @rev.delete(6)
       assert_equal([obj, @obj, deleted], @rev.each_modified_object.to_a)
+      assert_same(obj, @rev.object(3))
+    end
+
+    it "optionally deletes the modified objects from the revision" do
+      obj = @rev.object(3)
+      obj.value = :other
+      assert_equal([obj], @rev.each_modified_object(delete: true).to_a)
+      refute_same(obj, @rev.object(3))
     end
 
     it "ignores object and xref streams that were deleted" do
@@ -207,6 +215,13 @@ describe HexaPDF::Revision do
       assert_equal([], @rev.each_modified_object.to_a)
     end
 
+    it "handles object and xref streams that were added appropriately depending on the 'all' arg" do
+      xref = @rev.add(HexaPDF::Dictionary.new({Type: :XRef}, oid: 8))
+      objstm = @rev.add(HexaPDF::Dictionary.new({Type: :ObjStm}, oid: 9))
+      assert_equal([], @rev.each_modified_object.to_a)
+      assert_equal([xref, objstm], @rev.each_modified_object(all: true).to_a)
+    end
+
     it "doesn't return non-modified objects" do
       @rev.object(2)
       assert_equal([], @rev.each_modified_object.to_a)
@@ -230,18 +245,4 @@ describe HexaPDF::Revision do
       assert_equal([], @rev.each_modified_object.to_a)
     end
   end
-
-  describe "reset_objects" do
-    it "deletes loaded objects" do
-      @rev.object(2)
-      @rev.reset_objects
-      assert(@rev.instance_variable_get(:@objects).oids.empty?)
-    end
-
-    it "deletes added objects" do
-      @rev.add(@obj)
-      @rev.reset_objects
-      assert(@rev.instance_variable_get(:@objects).oids.empty?)
-    end
-  end
 end

data/test/hexapdf/test_revisions.rb

@@ -273,40 +273,48 @@ describe HexaPDF::Revisions do
       1 0 obj
       10
       endobj
+      xref
+      0 2
+      0000000000 65535 f 
+      0000000009 00000 n 
+      trailer
+      << /Size 2 >>
+      startxref
+      27
+      %%EOF
 
       2 0 obj
       20
       endobj
 
       3 0 obj
-      << /Type /XRef /Size 3 /Index [2 1] /W [1 1 1] /Filter /ASCIIHexDecode /Length 6
+      << /Type /XRef /Size 4 /Index [2 1] /W [1 1 1] /Filter /ASCIIHexDecode /Length 6
       >>stream
-      011C00
+      017600
       endstream
       endobj
 
       xref
-      0 4
-      0000000000 65535 f 
-      0000000009 00000 n 
+      2 2
       0000000000 65535 f 
-      0000000047 00000 n 
+      0000000137 00000 n 
       trailer
-      << /Size 3 >>
+      << /Size 4 /Prev 27>>
       startxref
-      170
+      260
       %%EOF
 
       xref
       0 0
       trailer
-      << /Size 3 /Prev 170 /XRefStm 47>>
+      << /Size 4 /Prev 260 /XRefStm 137>>
       startxref
-      302
+      360
       %%EOF
     EOF
-    doc = HexaPDF::Document.new(io: io)
-    assert_equal(1, doc.revisions.count)
+    doc = HexaPDF::Document.new(io: io, config: {'parser.try_xref_reconstruction' => false})
+    assert_equal(2, doc.revisions.count)
+    assert_equal(10, doc.object(1).value)
     assert_equal(20, doc.object(2).value)
   end
 
@@ -348,4 +356,47 @@ describe HexaPDF::Revisions do
       HexaPDF::Document.new(io: io, config: {'parser.try_xref_reconstruction' => false})
     end
   end
+
+  it "merges the two revisions of a linearized PDF into one" do
+    io = StringIO.new(<<~EOF)
+      %PDF-1.2
+      5 0 obj
+      <</Linearized 1>>
+      endobj
+      xref
+      5 1
+      0000000009 00000 n
+      trailer
+      <</ID[(a)(b)]/Info 1 0 R/Root 2 0 R/Size 6/Prev 394>>
+      %
+      1 0 obj
+      <</ModDate(D:20221205233910+01'00')/Producer(HexaPDF version 0.27.0)>>
+      endobj
+      2 0 obj
+      <</Type/Catalog/Pages 3 0 R>>
+      endobj
+      3 0 obj
+      <</Type/Pages/Kids[4 0 R]/Count 1>>
+      endobj
+      4 0 obj
+      <</Type/Page/MediaBox[0 0 595 842]/Parent 3 0 R/Resources<<>>>>
+      endobj
+      xref
+      0 5
+      0000000000 65535 f 
+      0000000133 00000 n 
+      0000000219 00000 n 
+      0000000264 00000 n 
+      0000000315 00000 n 
+      trailer
+      <</ID[(a)(b)]/Info 1 0 R/Root 2 0 R/Size 5>>
+      startxref
+      41
+      %%EOF
+    EOF
+    doc = HexaPDF::Document.new(io: io, config: {'parser.try_xref_reconstruction' => false})
+    assert(doc.revisions.parser.linearized?)
+    assert_equal(1, doc.revisions.count)
+    assert_same(5, doc.revisions.current.xref_section.max_oid)
+  end
 end

data/test/hexapdf/test_stream.rb

@@ -142,7 +142,7 @@ describe HexaPDF::Stream do
   def encoded_data(str, encoders = [])
     map = @document.config['filter.map']
     tmp = feeder(str)
-    encoders.each {|e| tmp = ::Object.const_get(map[e]).encoder(tmp) }
+    encoders.each {|e| tmp = Object.const_get(map[e]).encoder(tmp) }
     collector(tmp)
   end
 

data/test/hexapdf/test_tokenizer.rb

@@ -13,9 +13,18 @@ describe HexaPDF::Tokenizer do
   end
 
   it "handles object references" do
-    create_tokenizer("1 0 R 2 15 R ")
+    #HexaPDF::Reference.new(1, 0), HexaPDF::Reference.new(1, 2), 2, -1, 'R', 0, 0, 'R', -1, 0, 'R',
+    create_tokenizer("1 0 R +2 +15 R 2 -1 R 0 0 R 0 10 R -1 0 R")
     assert_equal(HexaPDF::Reference.new(1, 0), @tokenizer.next_token)
     assert_equal(HexaPDF::Reference.new(2, 15), @tokenizer.next_token)
+    assert_equal(2, @tokenizer.next_token)
+    assert_equal(-1, @tokenizer.next_token)
+    assert_equal('R', @tokenizer.next_token)
+    assert_nil(@tokenizer.next_token)
+    assert_nil(@tokenizer.next_token)
+    assert_equal(-1, @tokenizer.next_token)
+    assert_equal(0, @tokenizer.next_token)
+    assert_equal('R', @tokenizer.next_token)
     @tokenizer.pos = 0
     assert_equal(HexaPDF::Reference.new(1, 0), @tokenizer.next_object)
     assert_equal(HexaPDF::Reference.new(2, 15), @tokenizer.next_object)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.26.2)>>
+      <</Producer(HexaPDF version 0.28.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.26.2)>>
+      <</Producer(HexaPDF version 0.28.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -125,6 +125,14 @@ describe HexaPDF::Writer do
       refute_match(/^trailer/, output_io.string)
     end
 
+    it "updates the PDF version using the catalog's /Version entry if necessary" do
+      doc = HexaPDF::Document.new(io: @std_input_io)
+      doc.version = '2.0'
+      output_io = StringIO.new
+      HexaPDF::Writer.write(doc, output_io, incremental: true)
+      assert_equal('2.0', HexaPDF::Document.new(io: output_io).version)
+    end
+
     it "raises an error if the used encryption was changed" do
       io = StringIO.new
       doc = HexaPDF::Document.new
@@ -206,7 +214,7 @@ describe HexaPDF::Writer do
       <</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>
       endobj
       5 0 obj
-      <</Producer(HexaPDF version 0.26.2)>>
+      <</Producer(HexaPDF version 0.28.0)>>
       endobj
       4 0 obj
       <</Root 1 0 R/Info 5 0 R/Size 6/Type/XRef/W[1 1 2]/Index[0 6]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 33>>stream

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

@@ -18,12 +18,6 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
     end
 
-    it "fails for unsupported button fields" do
-      @field.flag(:push_button)
-      @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
-      assert_raises(HexaPDF::Error) { @generator.create_appearances }
-    end
-
     it "fails for unsupported field types" do
       @field[:FT] = :Unknown
       assert_raises(HexaPDF::Error) { @generator.create_appearances }
@@ -141,8 +135,8 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
     end
 
     def execute
-      @generator.send(:draw_marker, @xform.canvas, @widget[:Rect], @widget.border_style.width,
-                      @widget.marker_style)
+      @generator.send(:draw_marker, @xform.canvas, @widget[:Rect].width, @widget[:Rect].height,
+                      @widget.border_style.width, @widget.marker_style)
     end
 
     it "handles the marker :circle specially for radio button widgets" do
@@ -196,6 +190,18 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                           [:show_text, ["4"]],
                           [:end_text]])
       end
+
+      it "draws the default marker if an empty string is specified as marker" do
+        @widget.marker_style(style: '', color: 0.5, size: 5)
+        execute
+        assert_operators(@xform.stream,
+                         [[:set_font_and_size, [:F1, 5]],
+                          [:set_device_gray_non_stroking_color, [0.5]],
+                          [:begin_text],
+                          [:set_text_matrix, [1, 0, 0, 1, 2.885, 8.2725]],
+                          [:show_text, ["4"]],
+                          [:end_text]])
+      end
     end
   end
 
@@ -213,7 +219,15 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
 
       it "updates the widgets' /AS entry to point to the selected appearance" do
         @generator.create_appearances
-        assert_equal(@field[:V], @widget[:AS])
+        assert_equal(:Off, @widget[:AS])
+
+        @field.field_value = :Yes
+        @generator.create_appearances
+        assert_equal(:Yes, @widget[:AS])
+
+        @field.delete(:V)
+        @generator.create_appearances
+        assert_equal(:Off, @widget[:AS])
       end
 
       it "set the print flag on the widgets" do
@@ -231,6 +245,33 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
         assert_equal(12, @widget[:Rect].height)
       end
 
+      describe "takes the rotation into account" do
+        def check_rotation(angle, width, height, matrix)
+          @widget[:MK] = {R: angle}
+          @field[:V] = :Yes
+          @generator.create_appearances
+          form = @widget[:AP][:N][@widget[:AS]]
+          assert_equal([0, 0, width, height], form[:BBox].value)
+          assert_equal(matrix, form[:Matrix].value)
+        end
+
+        it "works for 0 degrees" do
+          check_rotation(-360, @widget[:Rect].width, @widget[:Rect].height, [1, 0, 0, 1, 0, 0])
+        end
+
+        it "works for 90 degrees" do
+          check_rotation(450, @widget[:Rect].height, @widget[:Rect].width, [0, 1, -1, 0, 0, 0])
+        end
+
+        it "works for 180 degrees" do
+          check_rotation(180, @widget[:Rect].width, @widget[:Rect].height, [0, -1, -1, 0, 0, 0])
+        end
+
+        it "works for 270 degrees" do
+          check_rotation(-90, @widget[:Rect].height, @widget[:Rect].width, [0, -1, 1, 0, 0, 0])
+        end
+      end
+
       it "creates the needed appearance streams" do
         @widget[:AP][:N].delete(:Off)
         @generator.create_appearances
@@ -292,61 +333,21 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
         assert_equal(:Off, @widget[:AS])
       end
 
-      it "set the print flag on the widgets" do
-        @generator.create_appearances
-        assert(@widget.flagged?(:print))
-      end
-
-      it "adjusts the /Rect if width is zero" do
-        @generator.create_appearances
-        assert_equal(12, @widget[:Rect].width)
-      end
-
-      it "adjusts the /Rect if height is zero" do
-        @generator.create_appearances
-        assert_equal(12, @widget[:Rect].height)
-      end
-
       it "creates the needed appearance streams" do
         @generator.create_appearances
         assert_equal(:XObject, @widget[:AP][:N][:Off].type)
         assert_equal(:XObject, @widget[:AP][:N][:radio].type)
       end
+    end
 
-      it "creates the /Off appearance stream" do
-        @widget.marker_style(style: :cross)
-        @generator.create_appearances
-        assert_operators(@widget[:AP][:N][:Off].stream,
-                         [[:save_graphics_state],
-                          [:set_device_gray_non_stroking_color, [1.0]],
-                          [:append_rectangle, [0, 0, 12, 12]],
-                          [:fill_path_non_zero],
-                          [:append_rectangle, [0.5, 0.5, 11, 11]],
-                          [:stroke_path], [:restore_graphics_state]])
-      end
-
-      it "creates the appearance stream according to the set value" do
-        @widget.marker_style(style: :check)
-        @generator.create_appearances
-        assert_operators(@widget[:AP][:N][:radio].stream,
-                         [[:save_graphics_state],
-                          [:set_device_gray_non_stroking_color, [1.0]],
-                          [:append_rectangle, [0, 0, 12, 12]],
-                          [:fill_path_non_zero],
-                          [:append_rectangle, [0.5, 0.5, 11, 11]],
-                          [:stroke_path], [:restore_graphics_state],
-
-                          [:save_graphics_state],
-                          [:set_font_and_size, [:F1, 10]],
-                          [:begin_text],
-                          [:set_text_matrix, [1, 0, 0, 1, 1.77, 2.545]],
-                          [:show_text, ["4"]],
-                          [:end_text],
-                          [:restore_graphics_state]])
+    describe "push buttons" do
+      before do
+        @field.initialize_as_push_button
+        @widget = @field.create_widget(@page, Rect: [0, 0, 0, 0])
+        @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
       end
 
-      it "fails if the appearance dictionaries are not set up" do
-        @widget[:AP][:N].delete(:radio)
+      it "fails because it is not implemented yet" do
         assert_raises(HexaPDF::Error) { @generator.create_appearances }
       end
     end
@@ -417,6 +418,37 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       assert_match(/test1/, form.contents)
     end
 
+    describe "takes the rotation into account" do
+      before do
+        @widget[:Rect] = [0, 0, 100, 20]
+      end
+
+      def check_rotation(angle, width, height, matrix)
+        @widget[:MK] = {R: angle}
+        @field[:V] = 'test'
+        @generator.create_appearances
+        form = @widget[:AP][:N]
+        assert_equal([0, 0, width, height], form[:BBox].value)
+        assert_equal(matrix, form[:Matrix].value)
+      end
+
+      it "works for 0 degrees" do
+        check_rotation(-360, @widget[:Rect].width, @widget[:Rect].height, [1, 0, 0, 1, 0, 0])
+      end
+
+      it "works for 90 degrees" do
+        check_rotation(450, @widget[:Rect].height, @widget[:Rect].width, [0, 1, -1, 0, 0, 0])
+      end
+
+      it "works for 180 degrees" do
+        check_rotation(180, @widget[:Rect].width, @widget[:Rect].height, [0, -1, -1, 0, 0, 0])
+      end
+
+      it "works for 270 degrees" do
+        check_rotation(-90, @widget[:Rect].height, @widget[:Rect].width, [0, -1, 1, 0, 0, 0])
+      end
+    end
+
     describe "font size calculation" do
       before do
         @widget[:Rect].height = 20
@@ -496,6 +528,53 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
         end
       end
 
+      describe "Javascript action AFNumber_Format" do
+        before do
+          @field.field_value = '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.field_value = '-1234567.898'
+          ["-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.240724]],
+                           [: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
+      end
+
       it "creates the /N appearance stream according to the set string" do
         @field.field_value = 'Text'
         @field.set_default_appearance_string(font_color: "red")