hexapdf 0.1.0

data/test/hexapdf/font_loader/test_from_configuration.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font_loader'
+require 'hexapdf/document'
+
+describe HexaPDF::FontLoader::FromConfiguration do
+  before do
+    @doc = HexaPDF::Document.new
+    font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+    @doc.config['font.map'] = {'font' => {none: font_file}}
+    @klass = HexaPDF::FontLoader::FromConfiguration
+  end
+
+  it "loads the configured font" do
+    wrapper = @klass.call(@doc, "font")
+    assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
+  end
+
+  it "fails if the font file cannot be read" do
+    @doc.config['font.map']['font'][:none] << "unknown"
+    assert_raises(HexaPDF::Error) { @klass.call(@doc, "font") }
+  end
+
+  it "returns nil for unknown fonts" do
+    assert_nil(@klass.call(@doc, "Unknown"))
+  end
+end

data/test/hexapdf/font_loader/test_standard14.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font_loader'
+require 'hexapdf/document'
+
+describe HexaPDF::FontLoader::Standard14 do
+  before do
+    @doc = HexaPDF::Document.new
+  end
+
+  it "loads the font if it is a standard PDF built-in font" do
+    wrapper = @doc.fonts.load("Times")
+    assert_equal("Times-Roman", wrapper.wrapped_font.font_name)
+    wrapper = @doc.fonts.load("Helvetica", variant: :bold)
+    assert_equal("Helvetica-Bold", wrapper.wrapped_font.font_name)
+  end
+
+  it "returns nil for unknown fonts" do
+    assert_nil(HexaPDF::FontLoader::Standard14.call(@doc, "Unknown"))
+  end
+end

data/test/hexapdf/image_loader/test_jpeg.rb

@@ -0,0 +1,83 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/image_loader/jpeg'
+
+describe HexaPDF::ImageLoader::JPEG do
+  before do
+    @images = Dir.glob(File.join(TEST_DATA_DIR, 'images', '*.jpg'))
+    @doc = HexaPDF::Document.new
+    @loader = HexaPDF::ImageLoader::JPEG
+  end
+
+  describe "handles?" do
+    it "works for jpeg files" do
+      @images.each do |image|
+        assert(@loader.handles?(image))
+        File.open(image, 'rb') {|file| assert(@loader.handles?(file))}
+      end
+    end
+  end
+
+  describe "load" do
+    it "can work with an IO stream instead of a file" do
+      jpeg = @images.grep(/rgb\.jpg/).first
+      File.open(jpeg, 'rb') do |file|
+        image = @loader.load(@doc, file)
+        assert_equal(File.binread(jpeg), image.stream)
+      end
+    end
+
+    it "works for a grayscale jpeg" do
+      jpeg = @images.grep(/gray\.jpg/).first
+      image = @loader.load(@doc, jpeg)
+      assert_equal(5, image[:Width])
+      assert_equal(5, image[:Height])
+      assert_equal(:DeviceGray, image[:ColorSpace])
+      assert_equal(File.binread(jpeg), image.stream)
+    end
+
+    it "works for a standard RGB jpeg" do
+      jpeg = @images.grep(/rgb\.jpg/).first
+      image = @loader.load(@doc, jpeg)
+      assert_equal(5, image[:Width])
+      assert_equal(5, image[:Height])
+      assert_equal(:DeviceRGB, image[:ColorSpace])
+      assert_equal(File.binread(jpeg), image.stream)
+    end
+
+    it "works for a jpeg image containing fill bytes" do
+      jpeg = @images.grep(/fillbytes\.jpg/).first
+      image = @loader.load(@doc, jpeg)
+      assert_equal(5, image[:Width])
+      assert_equal(5, image[:Height])
+      assert_equal(:DeviceRGB, image[:ColorSpace])
+      assert_equal(File.binread(jpeg), image.stream)
+    end
+
+    it "works for a CMYK jpeg" do
+      jpeg = @images.grep(/cmyk\.jpg/).first
+      image = @loader.load(@doc, jpeg)
+      assert_equal(5, image[:Width])
+      assert_equal(5, image[:Height])
+      assert_equal(:DeviceCMYK, image[:ColorSpace])
+      assert_equal([1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0], image[:Decode])
+      assert_equal(File.binread(jpeg), image.stream)
+    end
+
+    it "fails if the JPEG is corrupt" do
+      exp = assert_raises(HexaPDF::Error) do
+        @loader.load(@doc, StringIO.new("some non JPEG data"))
+      end
+      assert_match(/marker code/, exp.message)
+    end
+
+    it "fails if the JPEG contains components with more/less bits than 8" do
+      exp = assert_raises(HexaPDF::Error) do
+        @loader.load(@doc, StringIO.new("\xFF\xD8\xFF\xC0\x00\x06\x04\x00\x05\x00\x05\x03".b))
+      end
+      assert_match(/Unsupported.*bits.*4/, exp.message)
+    end
+  end
+end

data/test/hexapdf/image_loader/test_pdf.rb

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/image_loader/pdf'
+
+describe HexaPDF::ImageLoader::PDF do
+  before do
+    @doc = HexaPDF::Document.new
+    @loader = HexaPDF::ImageLoader::PDF
+    @pdf = File.join(TEST_DATA_DIR, 'minimal.pdf')
+  end
+
+  describe "handles?" do
+    it "works for PDF files" do
+      assert(@loader.handles?(@pdf))
+      File.open(@pdf, 'rb') {|file| assert(@loader.handles?(file))}
+    end
+  end
+
+  describe "load" do
+    it "works for PDF files using a File object" do
+      File.open(@pdf, 'rb') do |file|
+        form = @loader.load(@doc, file)
+        assert_equal(:Form, form[:Subtype])
+      end
+    end
+
+    it "works for PDF files using a string object and use_stringio=true" do
+      @doc.config['image_loader.pdf.use_stringio'] = true
+      form = @loader.load(@doc, @pdf)
+      assert_equal(:Form, form[:Subtype])
+    end
+
+    it "works for PDF files using a string object and use_stringio=false" do
+      begin
+        @doc.config['image_loader.pdf.use_stringio'] = false
+        form = @loader.load(@doc, @pdf)
+        assert_equal(:Form, form[:Subtype])
+      ensure
+        ObjectSpace.each_object(File) do |file|
+          file.close if file.path == @pdf && !file.closed?
+        end
+      end
+    end
+  end
+end

data/test/hexapdf/image_loader/test_png.rb

@@ -0,0 +1,258 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/image_loader/png'
+
+describe HexaPDF::ImageLoader::PNG do
+  before do
+    @images = Dir.glob(File.join(TEST_DATA_DIR, 'images', '*.png'))
+    @doc = HexaPDF::Document.new
+    @loader = HexaPDF::ImageLoader::PNG
+  end
+
+  describe "handles?" do
+    it "works for png files" do
+      @images.each do |image|
+        assert(@loader.handles?(image))
+        File.open(image, 'rb') {|file| assert(@loader.handles?(file))}
+      end
+    end
+  end
+
+  def build_png(header_data, others = '')
+    @loader::MAGIC_FILE_MARKER + [13, "IHDR", *header_data].pack('NA4N2C5N') + others +
+      [0, "IEND", 0].pack('NA4N')
+  end
+
+  def assert_image(image, width, height, bpc, color_space, stream)
+    assert_equal(width, image[:Width])
+    assert_equal(height, image[:Height])
+    assert_equal(bpc, image[:BitsPerComponent])
+    assert_equal(color_space, image[:ColorSpace]) if color_space
+    data = stream.map {|row| [row.map {|i| i.to_s(2).rjust(bpc, '0')}.join("")].pack('B*')}.join("")
+    assert_equal(data, image.stream)
+  end
+
+  # Note: colors and image data for comparisons were extracted using GIMP and its color tools
+  describe "load" do
+    before do
+      @greyscale_1bit_data = [[1, 1, 0, 0, 0],
+                              [1, 1, 0, 1, 0],
+                              [1, 1, 1, 1, 1],
+                              [0, 1, 0, 1, 0],
+                              [0, 0, 0, 0, 0]]
+    end
+
+    it "can work with an IO stream instead of a file" do
+      png = @images.grep(/greyscale-1bit\.png/).first
+      File.open(png, 'rb') do |file|
+        image = @loader.load(@doc, file)
+        assert_image(image, 5, 5, 1, :DeviceGray, @greyscale_1bit_data)
+      end
+    end
+
+    it "works for a 1-bit greyscale png" do
+      png = @images.grep(/greyscale-1bit\.png/).first
+      image = @loader.load(@doc, png)
+      assert_image(image, 5, 5, 1, :DeviceGray, @greyscale_1bit_data)
+    end
+
+    it "works for a 2-bit greyscale png" do
+      png = @images.grep(/greyscale-2bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[2, 2, 0, 0, 0],
+              [2, 3, 0, 3, 0],
+              [3, 3, 3, 3, 3],
+              [1, 3, 0, 3, 0],
+              [1, 1, 0, 0, 0]]
+      assert_image(image, 5, 5, 2, :DeviceGray, data)
+    end
+
+    it "works for a 4-bit greyscale png" do
+      png = @images.grep(/greyscale-4bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[15, 12, 9, 6, 3]] * 5
+      assert_image(image, 5, 5, 4, :DeviceGray, data)
+    end
+
+    it "works for a 8-bit greyscale png" do
+      png = @images.grep(/greyscale-8bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[254, 203, 153, 101, 50],
+              [253, 203, 152, 100, 50],
+              [254, 203, 151, 101, 50],
+              [253, 202, 151, 100, 50],
+              [253, 202, 151, 100, 49]]
+      assert_image(image, 5, 5, 8, :DeviceGray, data)
+    end
+
+    it "works for a 8-bit greyscale png with alpha" do
+      png = @images.grep(/greyscale-alpha-8bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[254, 203, 153, 101, 50],
+              [253, 203, 152, 100, 50],
+              [254, 203, 151, 101, 50],
+              [255, 202, 151, 101, 50],
+              [255, 202, 151, 101, 50]]
+      assert_image(image, 5, 5, 8, :DeviceGray, data)
+
+      data = [[255, 255, 255, 255, 255]] * 3 +
+        [[129, 129, 129, 129, 129]] * 2
+      assert_image(image[:SMask], 5, 5, 8, :DeviceGray, data)
+    end
+
+    it "works for a 8-bit greyscale png with a single transparent color" do
+      png = @images.grep(/greyscale-trns-8bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[254, 203, 153, 101, 50],
+              [253, 203, 152, 100, 50],
+              [254, 203, 151, 101, 50],
+              [253, 202, 151, 100, 50],
+              [253, 202, 151, 100, 49]]
+      assert_image(image, 5, 5, 8, :DeviceGray, data)
+      assert_equal([203, 203], image[:Mask])
+    end
+
+    it "works for a greyscale png with a gamma value of 1" do
+      png = @images.grep(/greyscale-with-gamma1\.0\.png/).first
+      image = @loader.load(@doc, png)
+      assert_equal(:DeviceGray, image[:ColorSpace])
+    end
+
+    it "works for a greyscale png with a gamma value of 1/1.5" do
+      png = @images.grep(/greyscale-with-gamma1\.5\.png/).first
+      image = @loader.load(@doc, png)
+      assert_equal([:CalGray, {WhitePoint: [1.0, 1.0, 1.0], Gamma: 1 / 1.5}], image[:ColorSpace])
+    end
+
+    it "works for an indexed 1-bit png" do
+      png = @images.grep(/indexed-1bit\.png/).first
+      image = @loader.load(@doc, png)
+      color_space = [:Indexed, :DeviceRGB, 1, "\xFF".b * 3 << "\x0".b * 3]
+      data = [[1, 0, 0, 0, 1]] * 5
+      assert_image(image, 5, 5, 1, color_space, data)
+    end
+
+    it "works for an indexed 2-bit png" do
+      png = @images.grep(/indexed-2bit\.png/).first
+      image = @loader.load(@doc, png)
+      colors = [44, 117, 63, 55, 118, 165, 97, 172, 110, 164, 189, 209].pack('C*')
+      data = [[1, 1, 3, 2, 0]] * 5
+      assert_image(image, 5, 5, 2, [:Indexed, :DeviceRGB, 3, colors], data)
+    end
+
+    it "works for an indexed 4-bit png" do
+      png = @images.grep(/indexed-4bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[0, 6, 13, 11, 3],
+              [0, 7, 14, 11, 2],
+              [0, 7, 15, 10, 1],
+              [4, 8, 12, 9, 5],
+              [4, 8, 12, 9, 5]]
+      assert_image(image, 5, 5, 4, nil, data)
+    end
+
+    it "works for an indexed 8-bit png" do
+      png = @images.grep(/indexed-8bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[0, 8, 21, 15, 1],
+              [0, 7, 20, 13, 3],
+              [0, 10, 17, 14, 5],
+              [2, 11, 18, 16, 6],
+              [2, 9, 19, 12, 4]]
+      assert_image(image, 5, 5, 8, nil, data)
+    end
+
+    it "works for an indexed 4-bit png with alpha values" do
+      png = @images.grep(/indexed-alpha-4bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[5, 6, 7, 8, 9],
+              [5, 10, 11, 8, 9],
+              [5, 10, 11, 8, 9],
+              [0, 1, 2, 3, 4],
+              [0, 1, 2, 3, 4]]
+      assert_image(image, 5, 5, 4, nil, data)
+
+      data = [[255, 255, 255, 255, 255]] * 3 +
+        [[191, 191, 191, 191, 191]] * 2
+      assert_image(image[:SMask], 5, 5, 8, :DeviceGray, data)
+    end
+
+    it "works for an indexed 8-bit png with alpha values" do
+      png = @images.grep(/indexed-alpha-8bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[5, 10, 11, 7, 6],
+              [5, 8, 9, 7, 6],
+              [5, 8, 9, 7, 6],
+              [0, 1, 4, 2, 3],
+              [0, 1, 4, 2, 3]]
+      assert_image(image, 5, 5, 8, nil, data)
+
+      data = [[255, 255, 255, 255, 255]] * 3 +
+        [[191, 191, 191, 191, 191]] * 2
+      assert_image(image[:SMask], 5, 5, 8, :DeviceGray, data)
+    end
+
+    it "works for a true color 8-bit png" do
+      png = @images.grep(/truecolour-8bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[12, 92, 146, 80, 136, 175, 167, 193, 213, 97, 175, 101, 38, 113, 50],
+              [12, 92, 146, 81, 137, 176, 168, 194, 214, 97, 175, 101, 38, 113, 49],
+              [12, 92, 146, 81, 137, 176, 169, 195, 214, 96, 175, 101, 37, 113, 49],
+              [12, 92, 146, 81, 138, 176, 171, 195, 214, 96, 176, 101, 37, 113, 49],
+              [12, 92, 146, 82, 137, 177, 171, 196, 215, 97, 176, 102, 37, 113, 49]]
+      assert_image(image, 5, 5, 8, :DeviceRGB, data)
+    end
+
+    it "works for a true color 8-bit png with alpha" do
+      png = @images.grep(/truecolour-alpha-8bit\.png/).first
+      image = @loader.load(@doc, png)
+      data = [[12, 92, 146, 80, 136, 175, 167, 193, 213, 97, 175, 101, 38, 113, 50],
+              [12, 92, 146, 81, 137, 176, 168, 194, 214, 97, 175, 101, 38, 113, 49],
+              [12, 92, 146, 81, 137, 176, 169, 195, 214, 96, 175, 101, 37, 113, 49],
+              [12, 92, 146, 81, 137, 176, 169, 195, 214, 96, 175, 101, 37, 113, 49],
+              [12, 92, 146, 81, 137, 176, 169, 195, 214, 96, 175, 101, 37, 113, 49]]
+      assert_image(image, 5, 5, 8, :DeviceRGB, data)
+
+      data = [[255, 255, 255, 255, 255]] * 3 +
+        [[191, 191, 191, 191, 191]] * 2
+      assert_image(image[:SMask], 5, 5, 8, :DeviceGray, data)
+    end
+
+    it "works for true color 8-bit pngs with an sRGB chunk or gAMA/cHRM chunks" do
+      @images.grep(/truecolour-(?:srgb|gama-chrm)-8bit\.png/).each do |png|
+        image = @loader.load(@doc, png)
+        # For the literal numbers see http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+        [0.9505, 1.0, 1.0891].zip(image[:ColorSpace][1][:WhitePoint]).each do |r, e|
+          assert_in_delta(r, e, 0.0001)
+        end
+        [0.4124, 0.2126, 0.0193, 0.3576, 0.7152, 0.1192, 0.1805, 0.0722, 0.9505].
+          zip(image[:ColorSpace][1][:Matrix]).each do |r, e|
+          assert_in_delta(r, e, 0.0001)
+        end
+        if png =~ /srgb/
+          assert_equal(:AbsoluteColorimetric, image[:Intent])
+        end
+      end
+    end
+
+    it "fails for unsupported PNG compression methods" do
+      data = build_png([0, 0, 8, 0, 1, 0, 0, 4])
+      exp = assert_raises(HexaPDF::Error) { @loader.load(@doc, StringIO.new(data)) }
+      assert_match(/compression method/, exp.message)
+    end
+
+    it "fails for unsupported PNG filter methods" do
+      data = build_png([0, 0, 8, 0, 0, 1, 0, 4])
+      exp = assert_raises(HexaPDF::Error) { @loader.load(@doc, StringIO.new(data)) }
+      assert_match(/filter method/, exp.message)
+    end
+
+    it "fails for unsupported PNG interlace methods" do
+      data = build_png([0, 0, 8, 0, 0, 0, 1, 4])
+      exp = assert_raises(HexaPDF::Error) { @loader.load(@doc, StringIO.new(data)) }
+      assert_match(/interlace method/, exp.message)
+    end
+  end
+end

data/test/hexapdf/task/test_dereference.rb

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/task/dereference'
+
+describe HexaPDF::Task::Dereference do
+  before do
+    @doc = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
+  end
+
+  it "dereferences all references to objects" do
+    obj = @doc.add(:test)
+    len = @doc.add(5)
+    str = @doc.add(@doc.wrap({Length: len}, stream: ''))
+    @doc.trailer[:Test] = str
+    checker = lambda do |val, done = {}|
+      case val
+      when Array then val.all? {|v| checker.call(v, done)}
+      when Hash then val.all? {|_, v| checker.call(v, done)}
+      when HexaPDF::Reference
+        false
+      when HexaPDF::Object
+        if done.key?(val)
+          true
+        else
+          done[val] = true if val.oid != 0
+          checker.call(val.value, done)
+        end
+      else
+        true
+      end
+    end
+    refute(checker.call(@doc.trailer))
+    assert_equal([obj, len], @doc.task(:dereference))
+    assert(checker.call(@doc.trailer))
+    assert_equal([obj, len], @doc.task(:dereference))
+    assert(checker.call(@doc.trailer))
+  end
+
+  it "dereferences only a single object" do
+    assert(@doc.object(5).value[:Font][:F1].kind_of?(HexaPDF::Reference))
+    assert_nil(@doc.task(:dereference, object: @doc.object(5)))
+    refute(@doc.object(5).value[:Font][:F1].kind_of?(HexaPDF::Reference))
+  end
+end

data/test/hexapdf/task/test_optimize.rb

@@ -0,0 +1,137 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/task/optimize'
+
+describe HexaPDF::Task::Optimize do
+  class TestType < HexaPDF::Dictionary
+    define_field :Optional, type: Symbol, default: :Optional
+  end
+
+  before do
+    @doc = HexaPDF::Document.new
+    @obj1 = @doc.add(@doc.wrap({Optional: :Optional}, type: TestType))
+    @doc.trailer[:Test] = @doc.wrap(@obj1)
+    @doc.revisions.add
+    @obj2 = @doc.add(Type: :UsedEntry)
+    @obj3 = @doc.add(Unused: @obj2)
+    @obj4 = @doc.add(Test: :Test)
+    @obj1[:Test] = @doc.wrap(@obj4, type: TestType)
+  end
+
+  def assert_objstms_generated
+    assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :ObjStm}})
+    assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :XRef}})
+  end
+
+  def assert_xrefstms_generated
+    assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :XRef}})
+  end
+
+  def assert_no_objstms
+    assert(@doc.each(current: false).all? {|obj| obj.type != :ObjStm})
+  end
+
+  def assert_no_xrefstms
+    assert(@doc.each(current: false).all? {|obj| obj.type != :XRef})
+  end
+
+  def assert_default_deleted
+    refute(@obj1.value.key?(:Optional))
+  end
+
+  describe "compact" do
+    it "compacts the document" do
+      @doc.task(:optimize, compact: true)
+      assert_equal(1, @doc.revisions.size)
+      assert_equal(2, @doc.each(current: false).to_a.size)
+      refute_equal(@obj2, @doc.object(@obj2))
+      refute_equal(@obj3, @doc.object(@obj3))
+      assert_default_deleted
+      assert_equal(2, @obj4.oid)
+      assert_equal(@obj1[:Test], @obj4)
+    end
+
+    it "compacts and generates object streams" do
+      @doc.task(:optimize, compact: true, object_streams: :generate)
+      assert_objstms_generated
+      assert_default_deleted
+    end
+
+    it "compacts and deletes object streams" do
+      @doc.add(Type: :ObjStm)
+      @doc.task(:optimize, compact: true, object_streams: :delete)
+      assert_no_objstms
+      assert_default_deleted
+    end
+
+    it "compacts and generates xref streams" do
+      @doc.task(:optimize, compact: true, xref_streams: :generate)
+      assert_xrefstms_generated
+      assert_default_deleted
+    end
+
+    it "compacts and deletes xref streams" do
+      @doc.add({Type: :XRef}, revision: 0)
+      @doc.add({Type: :XRef}, revision: 1)
+      @doc.task(:optimize, compact: true, xref_streams: :delete)
+      assert_no_xrefstms
+      assert_default_deleted
+    end
+  end
+
+  describe "object_streams" do
+    it "generates object streams" do
+      objstm = @doc.add(Type: :ObjStm)
+      xref = @doc.add(Type: :XRef)
+      210.times { @doc.add(5) }
+      @doc.task(:optimize, object_streams: :generate)
+      assert_objstms_generated
+      assert_default_deleted
+      assert_nil(@doc.object(objstm).value)
+      assert(3, @doc.revisions.current.find_all {|obj| obj.type == :ObjStm}.size)
+      assert([xref], @doc.revisions.current.find_all {|obj| obj.type == :XRef})
+    end
+
+    it "deletes object and xref streams" do
+      @doc.add(Type: :ObjStm)
+      @doc.task(:optimize, object_streams: :delete, xref_streams: :delete)
+      assert_no_objstms
+      assert_no_xrefstms
+      assert_default_deleted
+    end
+
+    it "deletes object and generates xref streams" do
+      @doc.add(Type: :ObjStm)
+      @doc.task(:optimize, object_streams: :delete, xref_streams: :generate)
+      assert_no_objstms
+      assert_xrefstms_generated
+      assert_default_deleted
+    end
+  end
+
+  describe "xref_streams" do
+    it "generates xref streams" do
+      @doc.task(:optimize, xref_streams: :generate)
+      assert_xrefstms_generated
+      assert_default_deleted
+    end
+
+    it "deletes xref streams" do
+      @doc.add(Type: :XRef)
+      @doc.task(:optimize, xref_streams: :delete)
+      assert_no_xrefstms
+      assert_default_deleted
+    end
+  end
+
+  describe "compress_pages" do
+    it "compresses pages streams" do
+      page = @doc.pages.add_page
+      page.contents = "   10  10   m    q            Q    BI /Name   5 ID dataEI   "
+      @doc.task(:optimize, compress_pages: true)
+      assert_equal("10 10 m\nq\nQ\nBI\n/Name 5 ID\ndataEI\n", page.contents)
+    end
+  end
+end