hexapdf 0.17.0 → 0.18.0

data/test/hexapdf/common_tokenizer_tests.rb

@@ -0,0 +1,236 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+
+module CommonTokenizerTests
+  extend Minitest::Spec::DSL
+
+  it "next_token: returns all available kinds of tokens on next_token" do
+    create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
+        % Regular tokens
+          		true false
+        123 +17 -98 0 0059
+        34.5 -3.62 +123.6 4. -.002 .002 0.0
+
+        % Keywords
+        obj endobj f* *f
+
+        % Specials
+        { }
+
+        % Literal string tests
+        (parenthese\\s ( ) and \\(\r
+        special \\0053\\053\\53characters\r (*!&}^% and \\
+        so \\\r
+        on).\\n)
+        ()
+
+        % Hex strings
+        <4E6F762073 686D6F7A20	6B612070
+        6F702E>
+        < 901FA3 ><901fA>
+
+        % Names
+        /Name1
+        /ASomewhatLongerName
+        /A;Name_With-Various***Characters?
+        /1.2/$$
+        /@pattern
+        /.notdef
+        /lime#20Green
+        /paired#28#29parentheses
+        /The_Key_of_F#23_Minor
+        /A#42
+        /
+
+        % Arrays
+        [ 5 6 /Name ]
+        [5 6 /Name]
+
+        % Dictionaries
+        <</Name 5>>
+
+        % Test
+    EOF
+
+    expected_tokens = [
+      true, false,
+      123, 17, -98, 0, 59,
+      34.5, -3.62, 123.6, 4.0, -0.002, 0.002, 0.0,
+      'obj', 'endobj', 'f*', '*f', '{', '}',
+      "parentheses ( ) and (\nspecial \0053++characters\n (*!&}^% and so on).\n", '',
+      "Nov shmoz ka pop.", "\x90\x1F\xA3", "\x90\x1F\xA0",
+      :Name1, :ASomewhatLongerName, :"A;Name_With-Various***Characters?",
+      :"1.2", :"$$", :"@pattern", :".notdef", :"lime Green", :"paired()parentheses",
+      :"The_Key_of_F#_Minor", :AB, :"",
+      '[', 5, 6, :Name, ']', '[', 5, 6, :Name, ']',
+      '<<', :Name, 5, '>>'
+    ].each {|t| t.force_encoding('BINARY') if t.respond_to?(:force_encoding) }
+
+    until expected_tokens.empty?
+      expected_token = expected_tokens.shift
+      token = @tokenizer.next_token
+      assert_equal(expected_token, token)
+      assert_equal(Encoding::BINARY, token.encoding) if token.kind_of?(String)
+    end
+    assert_equal(0, expected_tokens.length)
+    assert_equal(HexaPDF::Tokenizer::NO_MORE_TOKENS, @tokenizer.next_token)
+  end
+
+  it "next_token: should return name tokens in US-ASCII/UTF-8 or binary encoding" do
+    create_tokenizer("/ASomewhatLongerName")
+    token = @tokenizer.next_token
+    assert_equal(:ASomewhatLongerName, token)
+    assert_equal(Encoding::US_ASCII, token.encoding)
+
+    create_tokenizer("/Hößgang")
+    token = @tokenizer.next_token
+    assert_equal(:"Hößgang", token)
+    assert_equal(Encoding::UTF_8, token.encoding)
+
+    create_tokenizer('/H#c3#b6#c3#9fgang')
+    token = @tokenizer.next_token
+    assert_equal(:"Hößgang", token)
+    assert_equal(Encoding::UTF_8, token.encoding)
+
+    create_tokenizer('/H#E8lp')
+    token = @tokenizer.next_token
+    assert_equal("H\xE8lp".b.intern, token)
+    assert_equal(Encoding::BINARY, token.encoding)
+  end
+
+  it "next_token: fails on a greater than sign that is not part of a hex string" do
+    create_tokenizer(" >")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_token }
+  end
+
+  it "next_token: fails on a missing greater than sign in a hex string" do
+    create_tokenizer("<ABCD")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_token }
+  end
+
+  it "next_token: fails on unbalanced parentheses in a literal string" do
+    create_tokenizer("(href(test)")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_token }
+  end
+
+  it "next_token: returns a PDF keyword for a solitary plus sign" do
+    create_tokenizer("+")
+    token = @tokenizer.next_token
+    assert_equal("+", token)
+    assert(token.kind_of?(HexaPDF::Tokenizer::Token))
+  end
+
+  it "next_token: should not fail when reading super long numbers" do
+    create_tokenizer("1" << "0" * 10_000)
+    assert_equal(10**10_000, @tokenizer.next_token)
+  end
+
+  it "next_object: works for all PDF object types, including array and dictionary" do
+    create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
+        true false null 123 34.5 (string) <4E6F76> /Name
+        [5 6 /Name] <</Name 5/Null null>>
+    EOF
+    assert_equal(true, @tokenizer.next_object)
+    assert_equal(false, @tokenizer.next_object)
+    assert_nil(@tokenizer.next_object)
+    assert_equal(123, @tokenizer.next_object)
+    assert_equal(34.5, @tokenizer.next_object)
+    assert_equal("string".b, @tokenizer.next_object)
+    assert_equal("Nov".b, @tokenizer.next_object)
+    assert_equal(:Name, @tokenizer.next_object)
+    assert_equal([5, 6, :Name], @tokenizer.next_object)
+    assert_equal({Name: 5}, @tokenizer.next_object)
+  end
+
+  it "next_object: allows keywords if the corresponding option is set" do
+    create_tokenizer("name")
+    obj = @tokenizer.next_object(allow_keyword: true)
+    assert_kind_of(HexaPDF::Tokenizer::Token, obj)
+    assert_equal('name', obj)
+  end
+
+  it "next_object: fails if the value is not a correct object" do
+    create_tokenizer("<< /name ] >>")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    create_tokenizer("other")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    create_tokenizer("<< (string) (key) >>")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    create_tokenizer("<< /NoValueForKey >>")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+  end
+
+  it "next_object: fails for an array without closing bracket, encountering EOS" do
+    create_tokenizer("[1 2")
+    exception = assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    assert_match(/Unclosed array found/, exception.message)
+  end
+
+  it "next_object: fails for a dictionary without closing bracket, encountering EOS" do
+    create_tokenizer("<</Name 5")
+    exception = assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    assert_match(/must be PDF name objects.*EOS/, exception.message)
+    create_tokenizer("<</Name 5 /Other")
+    exception = assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    assert_match(/must be PDF name objects.*EOS/, exception.message)
+  end
+
+  it "returns the correct position on operations" do
+    create_tokenizer("hallo du" << " " * 50000 << "hallo du")
+    @tokenizer.next_token
+    assert_equal(5, @tokenizer.pos)
+
+    @tokenizer.skip_whitespace
+    assert_equal(6, @tokenizer.pos)
+
+    @tokenizer.next_byte
+    assert_equal(7, @tokenizer.pos)
+
+    @tokenizer.peek_token
+    assert_equal(7, @tokenizer.pos)
+
+    @tokenizer.next_token
+    assert_equal(8, @tokenizer.pos)
+
+    @tokenizer.next_token
+    assert_equal(50013, @tokenizer.pos)
+
+    @tokenizer.next_token
+    assert_equal(50016, @tokenizer.pos)
+
+    @tokenizer.next_token
+    assert_equal(50016, @tokenizer.pos)
+  end
+
+  it "returns the next byte" do
+    create_tokenizer('hallo')
+    assert_equal('h'.ord, @tokenizer.next_byte)
+    assert_equal('a'.ord, @tokenizer.next_byte)
+  end
+
+  it "returns the next token but doesn't advance the position on peek_token" do
+    create_tokenizer("hallo du")
+    2.times do
+      assert_equal('hallo', @tokenizer.peek_token)
+      assert_equal(0, @tokenizer.pos)
+    end
+  end
+
+  it "next_xref_entry: works on correct entries" do
+    create_tokenizer("0000000001 00001 n \n0000000001 00032 f \n")
+    assert_equal([1, 1, 'n'], @tokenizer.next_xref_entry)
+    assert_equal([1, 32, 'f'], @tokenizer.next_xref_entry)
+  end
+
+  it "next_xref_entry: fails on invalidly formatted entries" do
+    create_tokenizer("0000000001 00001 g \n")
+    assert_raises(RuntimeError) { @tokenizer.next_xref_entry {|recoverable| refute(recoverable); raise } }
+    create_tokenizer("0000000001 00001 n\n")
+    assert_raises(RuntimeError) { @tokenizer.next_xref_entry {|recoverable| assert(recoverable); raise } }
+    create_tokenizer("0000000001 00001 n\r")
+    assert_raises(RuntimeError) { @tokenizer.next_xref_entry {|recoverable| assert(recoverable); raise } }
+    create_tokenizer("0000000001 00001 n\r\r")
+    assert_raises(RuntimeError) { @tokenizer.next_xref_entry {|recoverable| assert(recoverable); raise } }
+  end
+end

data/test/hexapdf/content/common.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/processor'
+
+module TestHelper
+
+  # Can be used to to record operators parsed from content streams.
+  class OperatorRecorder < HexaPDF::Content::Processor
+
+    undef :paint_xobject
+
+    attr_reader :recorded_ops
+
+    def initialize
+      super
+      operators.clear
+      @recorded_ops = []
+    end
+
+    def respond_to_missing?(*)
+      true
+    end
+
+    def method_missing(msg, *params)
+      @recorded_ops << (params.empty? ? [msg] : [msg, params])
+    end
+
+  end
+
+  # Asserts that the content string contains the operators.
+  def assert_operators(content, operators, only_names: false, range: 0..-1)
+    processor = TestHelper::OperatorRecorder.new
+    HexaPDF::Content::Parser.new.parse(content, processor)
+    result = processor.recorded_ops[range]
+    result.map!(&:first) if only_names
+    assert_equal(operators, result)
+  end
+end

data/test/hexapdf/content/graphic_object/test_arc.rb

@@ -0,0 +1,102 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/content'
+require 'hexapdf/content/graphic_object'
+
+describe HexaPDF::Content::GraphicObject::Arc do
+  before do
+    @arc = HexaPDF::Content::GraphicObject::Arc.configure(start_angle: -30, end_angle: 30,
+                                                          inclination: 90)
+  end
+
+  describe "initialize" do
+    it "creates a default arc representing the counterclockwise unit circle at the origin" do
+      arc = HexaPDF::Content::GraphicObject::Arc.new
+      assert_equal(0, arc.cx)
+      assert_equal(0, arc.cy)
+      assert_equal(1, arc.a)
+      assert_equal(1, arc.b)
+      assert_equal(0, arc.start_angle)
+      assert_equal(360, arc.end_angle)
+      assert_equal(0, arc.inclination)
+    end
+  end
+
+  it "returns the start and end points" do
+    x, y = @arc.start_point
+    assert_in_delta(0.5, x, 0.00001)
+    assert_in_delta(Math.sin(Math::PI / 3), y, 0.00001)
+
+    x, y = @arc.end_point
+    assert_in_delta(-0.5, x, 0.00001)
+    assert_in_delta(Math.sin(Math::PI / 3), y, 0.00001)
+  end
+
+  describe "point_at" do
+    it "returns an arbitrary point on the arc" do
+      x, y = @arc.point_at(0)
+      assert_in_delta(0, x, 0.00001)
+      assert_in_delta(1, y, 0.00001)
+    end
+  end
+
+  describe "configure" do
+    it "fails if a == 0 or b == 0" do
+      assert_raises(HexaPDF::Error) do
+        HexaPDF::Content::GraphicObject::Arc.configure(a: 0)
+      end
+      assert_raises(HexaPDF::Error) do
+        HexaPDF::Content::GraphicObject::Arc.configure(b: 0)
+      end
+    end
+  end
+
+  describe "curves" do
+    def assert_curve_values(exp, act)
+      assert_in_delta(exp[0], act[0], 0.00001)
+      assert_in_delta(exp[1], act[1], 0.00001)
+      assert_in_delta(exp[2][:p1][0], act[2][:p1][0], 0.00001)
+      assert_in_delta(exp[2][:p1][1], act[2][:p1][1], 0.00001)
+      assert_in_delta(exp[2][:p2][0], act[2][:p2][0], 0.00001)
+      assert_in_delta(exp[2][:p2][1], act[2][:p2][1], 0.00001)
+    end
+
+    it "returns the curves for the arc" do
+      arc = HexaPDF::Content::GraphicObject::Arc.configure(end_angle: 180)
+      arc.max_curves = 4
+      curves = arc.curves
+      assert_equal(2, curves.size)
+      assert_curve_values([0, 1, {p1: [1, 0.548584], p2: [0.548584, 1]}], curves[0])
+      assert_curve_values([-1, 0, {p1: [-0.548584, 1], p2: [-1, 0.548584]}], curves[1])
+
+      arc.configure(clockwise: true)
+      curves = arc.curves
+      assert_equal(2, curves.size)
+      assert_curve_values([0, -1, {p1: [1, -0.548584], p2: [0.548584, -1]}], curves[0])
+      assert_curve_values([-1, 0, {p1: [-0.548584, -1], p2: [-1, -0.548584]}], curves[1])
+    end
+  end
+
+  describe "draw" do
+    before do
+      @doc = HexaPDF::Document.new
+      @page = @doc.pages.add
+      @canvas = @page.canvas
+    end
+
+    it "draws the arc onto the canvas" do
+      @arc.draw(@canvas)
+      refute(@page.contents.empty?)
+    end
+
+    it "uses the configuration option for max_curves if no value is set" do
+      @arc.draw(@canvas)
+      assert_equal(@doc.config['graphic_object.arc.max_curves'], @arc.max_curves)
+      @arc.max_curves = 2
+      @arc.draw(@canvas)
+      assert_equal(2, @arc.max_curves)
+    end
+  end
+end

data/test/hexapdf/content/graphic_object/test_endpoint_arc.rb

@@ -0,0 +1,98 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/canvas'
+require 'hexapdf/content/graphic_object'
+require 'hexapdf/document'
+
+describe HexaPDF::Content::GraphicObject::EndpointArc do
+  describe "initialize" do
+    it "creates a default arc representing a line from the current point to the origin" do
+      arc = HexaPDF::Content::GraphicObject::EndpointArc.new
+      assert_equal(0, arc.x)
+      assert_equal(0, arc.y)
+      assert_equal(0, arc.a)
+      assert_equal(0, arc.b)
+      assert_equal(0, arc.inclination)
+      assert(arc.large_arc)
+      refute(arc.clockwise)
+    end
+  end
+
+  describe "configure" do
+    it "changes the values" do
+      arc = HexaPDF::Content::GraphicObject::EndpointArc.new
+      arc.configure(x: 1, y: 2, a: 3, b: 4, inclination: 5, large_arc: false, clockwise: true)
+      assert_equal(1, arc.x)
+      assert_equal(2, arc.y)
+      assert_equal(3, arc.a)
+      assert_equal(4, arc.b)
+      assert_equal(5, arc.inclination)
+      refute(arc.large_arc)
+      assert(arc.clockwise)
+    end
+  end
+
+  describe "draw" do
+    before do
+      @doc = HexaPDF::Document.new
+      @page = @doc.pages.add
+    end
+
+    it "draws nothing if the endpoint is the same as the current point" do
+      canvas = @page.canvas
+      canvas.move_to(50, 50)
+      canvas.draw(:endpoint_arc, x: 50, y: 50, a: 50, b: 25)
+      assert_equal("50 50 m\n", canvas.contents)
+    end
+
+    it "draws only a straight line if either one of the semi-axis is zero" do
+      canvas = @page.canvas
+      canvas.move_to(50, 50)
+      canvas.draw(:endpoint_arc, x: 100, y: 50, a: 0, b: 25)
+      assert_equal("50 50 m\n100 50 l\n", canvas.contents)
+    end
+
+    it "draws the arc onto the canvas" do
+      {
+        [false, false] => {cx: 100, cy: 50, a: 50, b: 25, start_angle: 180, end_angle: 270, clockwise: false},
+        [false, true] => {cx: 50, cy: 25, a: 50, b: 25, start_angle: 90, end_angle: 0, clockwise: true},
+        [true, false] => {cx: 50, cy: 25, a: 50, b: 25, start_angle: 90, end_angle: 360, clockwise: false},
+        [true, true] => {cx: 0, cy: 0, a: 40, b: 30, start_angle: 60, end_angle: 120},
+      }.each do |(large_arc, clockwise), data|
+        @page.delete(:Contents)
+        canvas = @page.canvas
+        arc = canvas.graphic_object(:arc, **data)
+        canvas.draw(arc)
+        arc_data = @page.contents
+
+        canvas.contents.clear
+        assert(@page.contents.empty?)
+        canvas.move_to(*arc.start_point)
+        earc = canvas.graphic_object(:endpoint_arc, x: arc.end_point[0], y: arc.end_point[1],
+                                     a: data[:a], b: data[:b], inclination: data[:inclination] || 0,
+                                     large_arc: large_arc, clockwise: clockwise)
+        canvas.draw(earc)
+        narc = canvas.graphic_object(:arc, **earc.send(:compute_arc_values, *arc.start_point))
+        assert_in_delta(arc.start_point[0], narc.start_point[0], 0.0001)
+        assert_in_delta(arc.start_point[1], narc.start_point[1], 0.0001)
+        assert_in_delta(arc.end_point[0], narc.end_point[0], 0.0001)
+        assert_in_delta(arc.end_point[1], narc.end_point[1], 0.0001)
+        assert_equal(arc_data, @page.contents)
+      end
+    end
+
+    it "draws the correct arc even if it is inclined" do
+      canvas = @page.canvas
+      canvas.draw(:arc, cx: 25, cy: 0, a: 50, b: 25, start_angle: 90, end_angle: 270,
+                  inclination: 90, clockwise: false)
+      arc_data = @page.contents
+
+      canvas.contents.clear
+      canvas.move_to(0.0, 1e-15)
+      canvas.draw(:endpoint_arc, x: 50, y: 0, a: 20, b: 10, inclination: 90, large_arc: false,
+                  clockwise: false)
+      assert_equal(arc_data, @page.contents)
+    end
+  end
+end

data/test/hexapdf/content/graphic_object/test_geom2d.rb

@@ -0,0 +1,79 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../common'
+require 'hexapdf/document'
+require 'hexapdf/content'
+require 'hexapdf/content/graphic_object'
+
+describe HexaPDF::Content::GraphicObject::Geom2D do
+  before do
+    @obj = HexaPDF::Content::GraphicObject::Geom2D.new
+  end
+
+  it "allows creation via the ::configure method" do
+    obj = HexaPDF::Content::GraphicObject::Geom2D.configure(object: Geom2D::Point(5, 5))
+    assert_equal(Geom2D::Point(5, 5), obj.object)
+  end
+
+  it "creates a default Geom2D drawing support object" do
+    obj = HexaPDF::Content::GraphicObject::Geom2D.new
+    assert_nil(obj.object)
+    assert_equal(1, obj.point_radius)
+    assert_equal(false, obj.path_only)
+  end
+
+  it "allows configuration of the object" do
+    @obj.configure(object: Geom2D::Point(5, 5), point_radius: 3, path_only: true)
+    assert_equal(Geom2D::Point(5, 5), @obj.object)
+    assert_equal(3, @obj.point_radius)
+    assert_equal(true, @obj.path_only)
+  end
+
+  describe "draw" do
+    before do
+      doc = HexaPDF::Document.new
+      @canvas = doc.pages.add.canvas
+    end
+
+    it "draws a Geom2D::Point onto the canvas" do
+      @obj.object = Geom2D::Point(5, 5)
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :curve_to, :curve_to,
+                        :close_subpath, :fill_path_non_zero],
+                       only_names: true)
+    end
+
+    it "draws a Geom2D::Segment onto the canvas" do
+      @obj.object = Geom2D::Segment([5, 6], [10, 11])
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:stroke_path]])
+    end
+
+    it "draws a Geom2D::Polygon onto the canvas" do
+      @obj.object = Geom2D::Polygon([5, 6], [10, 11], [7, 9])
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:line_to, [7, 9]],
+                        [:stroke_path]])
+    end
+
+    it "draws a Geom2D::PolygonSet onto the canvas" do
+      @obj.object = Geom2D::PolygonSet(Geom2D::Polygon([5, 6], [10, 11], [7, 9]),
+                                       Geom2D::Polygon([0, 0], [4, 0], [2, 3]))
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:line_to, [7, 9]],
+                        [:close_subpath],
+                        [:move_to, [0, 0]], [:line_to, [4, 0]], [:line_to, [2, 3]],
+                        [:close_subpath], [:stroke_path]])
+    end
+
+    it "fails for unkown classes" do
+      @obj.object = 5
+      assert_raises(HexaPDF::Error) { @obj.draw(@canvas) }
+    end
+  end
+end

data/test/hexapdf/content/graphic_object/test_solid_arc.rb

@@ -0,0 +1,86 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../common'
+require 'hexapdf/document'
+require 'hexapdf/content'
+require 'hexapdf/content/graphic_object'
+
+describe HexaPDF::Content::GraphicObject::SolidArc do
+  describe "initialize" do
+    it "creates a default solid arc representing the disk at the origin" do
+      arc = HexaPDF::Content::GraphicObject::SolidArc.configure
+      assert_equal(0, arc.cx)
+      assert_equal(0, arc.cy)
+      assert_equal(0, arc.inner_a)
+      assert_equal(0, arc.inner_b)
+      assert_equal(1, arc.outer_a)
+      assert_equal(1, arc.outer_b)
+      assert_equal(0, arc.start_angle)
+      assert_equal(0, arc.end_angle)
+      assert_equal(0, arc.inclination)
+    end
+  end
+
+  describe "configure" do
+    it "changes the values" do
+      arc = HexaPDF::Content::GraphicObject::SolidArc.new
+      arc.configure(cx: 1, cy: 2, inner_a: 3, inner_b: 4, outer_a: 5, outer_b: 6,
+                    start_angle: 7, end_angle: 8, inclination: 9)
+      assert_equal(1, arc.cx)
+      assert_equal(2, arc.cy)
+      assert_equal(3, arc.inner_a)
+      assert_equal(4, arc.inner_b)
+      assert_equal(5, arc.outer_a)
+      assert_equal(6, arc.outer_b)
+      assert_equal(7, arc.start_angle)
+      assert_equal(8, arc.end_angle)
+      assert_equal(9, arc.inclination)
+    end
+  end
+
+  describe "draw" do
+    def operators(content)
+      processor = TestHelper::OperatorRecorder.new
+      parser = HexaPDF::Content::Parser.new
+      parser.parse(content, processor)
+      processor.recorded_ops
+    end
+
+    before do
+      @doc = HexaPDF::Document.new
+      @doc.config['graphic_object.arc.max_curves'] = 4
+      @page = @doc.pages.add
+      @canvas = @page.canvas
+    end
+
+    it "draws a disk" do
+      @canvas.draw(:solid_arc)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+
+    it "draws a sector" do
+      @canvas.draw(:solid_arc, end_angle: 90)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :line_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+
+    it "draws an annulus" do
+      @canvas.draw(:solid_arc, inner_a: 5, inner_b: 5)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath,
+                    :move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+
+    it "draws an annular sector" do
+      @canvas.draw(:solid_arc, inner_a: 5, inner_b: 5, end_angle: 90)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :curve_to, :line_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+  end
+end