hexapdf 0.1.0

data/test/hexapdf/test_serializer.rb

@@ -0,0 +1,169 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'hexapdf/serializer'
+require 'hexapdf/object'
+require 'hexapdf/stream'
+
+describe HexaPDF::Serializer do
+  before do
+    @serializer = HexaPDF::Serializer.new
+  end
+
+  it "allows access to the top serialized object" do
+    object = nil
+    @serializer.singleton_class.send(:define_method, :serialize_symbol) do |obj|
+      object = @object
+      "/#{obj}"
+    end
+    @serializer.serialize(this: :is, null: nil)
+    assert_equal({this: :is, null: nil}, object)
+  end
+
+  def assert_serialized(result, object)
+    assert_equal(result, @serializer.serialize(object))
+  end
+
+  it "serializes nil" do
+    assert_serialized("null", nil)
+  end
+
+  it "serializes true" do
+    assert_serialized("true", true)
+  end
+
+  it "serializes false" do
+    assert_serialized("false", false)
+  end
+
+  it "serializes integers" do
+    assert_serialized("100", 100)
+    assert_serialized("-100", -100)
+    assert_serialized("0", 0)
+    assert_serialized("1208925819614629174706176", 1208925819614629174706176)
+  end
+
+  it "serializes floats with a precision of 4" do
+    assert_serialized("1.5", 1.5)
+    assert_serialized("-1.5", -1.5)
+    assert_serialized("9.123456", 9.123456)
+    assert_serialized("9.123457", 9.1234567)
+    assert_serialized("0.000005", 0.000005)
+    assert_serialized("-0.000005", -0.000005)
+    assert_serialized("0.0", 0.0)
+  end
+
+  it "serializes numerics" do
+    assert_equal("1", @serializer.serialize_numeric(1))
+    assert_equal("1.5", @serializer.serialize_numeric(1.5))
+  end
+
+  it "serializes symbols" do
+    assert_serialized("/Name", :Name)
+    assert_serialized("/A;Name_With-Various***Chars?", 'A;Name_With-Various***Chars?'.intern)
+    assert_serialized("/1.2", '1.2'.intern)
+    assert_serialized("/$$", '$$'.intern)
+    assert_serialized("/@pattern", '@pattern'.intern)
+    assert_serialized('/.notdef', '.notdef'.intern)
+    assert_serialized('/lime#20Green', 'lime Green'.intern)
+    assert_serialized('/paired#28#29parentheses', 'paired()parentheses'.intern)
+    assert_serialized('/The_Key_of_F#23_Minor', 'The_Key_of_F#_Minor'.intern)
+    assert_serialized('/', ''.intern)
+    assert_serialized('/H#c3#b6#c3#9fgang', "Hößgang".intern)
+    assert_serialized('/H#e8lp', "H\xE8lp".force_encoding('BINARY').intern)
+  end
+
+  it "serializes arrays" do
+    assert_serialized("[-12 2.4321/Name true(345)true]", [-12, 2.4321, :Name, true, '345', true])
+    assert_serialized("[]", [])
+  end
+
+  it "serializes hashes" do
+    assert_serialized("<</hallo 5/other true/name[5]>>", hallo: 5, other: true, name: [5])
+    assert_serialized("<<>>", {})
+  end
+
+  it "serializes strings" do
+    assert_serialized("(Hallo)", "Hallo")
+    assert_serialized("(Hallo\\r\n\t\\(\\)\\\\)", "Hallo\r\n\t()\\")
+    assert_serialized("(\xFE\xFF\x00H\x00a\x00l\x00\f\x00\b\x00\\()".force_encoding('BINARY'),
+                      "Hal\f\b(")
+  end
+
+  it "serializes time like objects" do
+    begin
+      tz = ENV['TZ']
+      ENV['TZ'] = 'Europe/Vienna'
+      assert_serialized("(D:20150416094100)", Time.new(2015, 04, 16, 9, 41, 0, 0))
+      assert_serialized("(D:20150416094100+01'00')", Time.new(2015, 04, 16, 9, 41, 0, 3600))
+      assert_serialized("(D:20150416094100-01'20')", Time.new(2015, 04, 16, 9, 41, 0, -4800))
+      assert_serialized("(D:20150416000000+02'00')", Date.parse("2015-04-16 9:41:00 +02:00"))
+      assert_serialized("(D:20150416094100+02'00')", DateTime.parse("2015-04-16 9:41:00 +02:00"))
+    ensure
+      ENV['TZ'] = tz
+    end
+  end
+
+  it "serializes HexaPDF objects" do
+    assert_serialized("/Name", HexaPDF::Object.new(:Name))
+    assert_serialized("/Name", HexaPDF::Object.new(:Name, oid: 1))
+    assert_serialized("<</Name 2 0 R>>",
+                      HexaPDF::Object.new({Name: HexaPDF::Object.new(5, oid: 2)}, oid: 1))
+  end
+
+  it "serializes HexaPDF reference objects" do
+    assert_serialized("5 3 R", HexaPDF::Reference.new(5, 3))
+  end
+
+  describe "stream serialization" do
+    before do
+      @doc = Object.new
+      def (@doc).unwrap(obj); obj; end
+      def (@doc).config; {chunk_size: 100}; end
+      @stream = HexaPDF::Stream.new({Key: "value", Length: 5}, oid: 2, document: @doc)
+    end
+
+    it "serializes streams" do
+      @stream.stream = "somedata"
+      assert_serialized("<</Key(value)/Length 8>>stream\nsomedata\nendstream", @stream)
+      assert_serialized("<</Name 2 0 R>>", HexaPDF::Object.new(Name: @stream))
+    end
+
+    it "serializes stream more efficiently when an IO is provided" do
+      @stream.stream = HexaPDF::StreamData.new(proc { "some" }, length: 6)
+      io = StringIO.new(''.b)
+      @serializer.serialize_to_io(@stream, io)
+      assert_equal("<</Key(value)/Length 6>>stream\nsome\nendstream", io.string)
+    end
+
+    it "fails if a stream without object identifier is serialized" do
+      @stream.oid = 0
+      assert_raises(HexaPDF::Error) { @serializer.serialize(@stream) }
+      assert_raises(HexaPDF::Error) { @serializer.serialize(Name: @stream) }
+    end
+  end
+
+  describe "with an encrypter" do
+    before do
+      @serializer.encrypter = encrypter = Object.new
+      def encrypter.encrypt_string(str, obj); "enc:#{obj.oid}:#{str}"; end
+      def encrypter.encrypt_stream(obj); Fiber.new { "encs:#{obj.oid}:#{obj.stream}" }; end
+    end
+
+    it "encrypts strings in indirect PDF objects" do
+      assert_serialized("(enc:1:test)", HexaPDF::Object.new("test", oid: 1))
+      assert_serialized("<</x[(enc:1:test)]>>", HexaPDF::Object.new({x: ["test"]}, oid: 1))
+    end
+
+    it "doesn't encrypt strings in direct PDF objects" do
+      assert_serialized("(test)", HexaPDF::Object.new("test"))
+      assert_serialized("(test)", "test")
+    end
+
+    it "encrypts streams" do
+      obj = HexaPDF::Stream.new({}, oid: 1, stream: "stream")
+      assert_serialized("<</Length 13>>stream\nencs:1:stream\nendstream", obj)
+    end
+  end
+end

data/test/hexapdf/test_stream.rb

@@ -0,0 +1,262 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'ostruct'
+require 'stringio'
+require 'tempfile'
+require 'hexapdf/configuration'
+require 'hexapdf/stream'
+
+
+describe HexaPDF::StreamData do
+  it "fails if no valid source is specified on creation" do
+    assert_raises(ArgumentError) { HexaPDF::StreamData.new }
+  end
+
+  it "normalizes the filter value" do
+    s = HexaPDF::StreamData.new(:source, filter: :test)
+    assert_equal([:test], s.filter)
+    s = HexaPDF::StreamData.new(:source, filter: [:a, nil, :b])
+    assert_equal([:a, :b], s.filter)
+    s = HexaPDF::StreamData.new(:source)
+    assert_equal([], s.filter)
+  end
+
+  it "normalizes the decode_parms value" do
+    s = HexaPDF::StreamData.new(:source, decode_parms: :test)
+    assert_equal([:test], s.decode_parms)
+    s = HexaPDF::StreamData.new(:source, decode_parms: [:a, nil, :b])
+    assert_equal([:a, nil, :b], s.decode_parms)
+    s = HexaPDF::StreamData.new(:source)
+    assert_equal([nil], s.decode_parms)
+  end
+
+  describe "fiber" do
+    it "returns a fiber for a Proc source" do
+      s = HexaPDF::StreamData.new(proc { :source })
+      assert_equal(:source, s.fiber.resume)
+    end
+
+    it "returns a fiber for a source specified via a block" do
+      s = HexaPDF::StreamData.new { :source }
+      assert_equal(:source, s.fiber.resume)
+    end
+
+    it "returns a fiber for an IO source" do
+      s = HexaPDF::StreamData.new(StringIO.new('source'))
+      assert_equal('source', s.fiber.resume)
+    end
+
+    it "returns a fiber for a string representing a file name" do
+      begin
+        file = Tempfile.new('hexapdf-stream')
+        file.write('source')
+        file.close
+        s = HexaPDF::StreamData.new(file.path)
+        assert_equal('source', s.fiber.resume)
+      ensure
+        file.unlink
+      end
+    end
+  end
+end
+
+
+describe HexaPDF::Stream do
+  include TestHelper
+
+  before do
+    @document = OpenStruct.new
+    @document.config = HexaPDF::Configuration.with_defaults
+    @document.instance_variable_set(:@version, '1.2')
+    def (@document).unwrap(obj); obj; end
+    def (@document).deref(obj); obj; end
+
+    @stm = HexaPDF::Stream.new({}, oid: 1, document: @document)
+  end
+
+  it "#initialize accepts the stream keyword" do
+    stm = HexaPDF::Stream.new({}, document: @document, stream: 'other')
+    assert_equal('other', stm.stream)
+  end
+
+  it "must always be indirect" do
+    @stm.must_be_indirect = false
+    assert(@stm.must_be_indirect?)
+  end
+
+  describe "stream=" do
+    it "allows assigning nil" do
+      @stm.stream = nil
+      assert_equal('', @stm.raw_stream)
+      assert_equal('', @stm.stream)
+      assert_equal(Encoding::BINARY, @stm.stream.encoding)
+    end
+
+    it "allows assigning a string" do
+      @stm.stream = 'hallo'
+      assert_equal('hallo', @stm.raw_stream)
+      assert_equal('hallo', @stm.stream)
+    end
+
+    it "retains the encoding if a String is assigned" do
+      @stm.stream = 'hallo'
+      assert_equal(Encoding::UTF_8, @stm.stream.encoding)
+      @stm.stream = 'hallo'.encode('ISO-8859-1')
+      assert_equal(Encoding::ISO_8859_1, @stm.stream.encoding)
+    end
+
+    it "allows assigning a StreamData object" do
+      @stmdata = HexaPDF::StreamData.new(StringIO.new('testing'))
+      @stm.stream = @stmdata
+      assert_equal(@stmdata, @stm.raw_stream)
+      assert_equal('testing', @stm.stream)
+      assert_equal(Encoding::BINARY, @stm.stream.encoding)
+    end
+
+    it "fails on any object class other than String, StreamData, NilClass" do
+      assert_raises(ArgumentError) { @stm.stream = 5 }
+    end
+  end
+
+  describe "stream" do
+    it "doesn't allow changing the returned value directly" do
+      @stm.stream = 'data'
+      @stm.stream.upcase!
+      assert_equal('data', @stm.stream)
+
+      @stm.stream = HexaPDF::StreamData.new { "data" }
+      @stm.stream.upcase!
+      assert_equal('data', @stm.stream)
+    end
+  end
+
+  def encoded_data(str, encoders = [])
+    map = HexaPDF::GlobalConfiguration['filter.map']
+    tmp = feeder(str)
+    encoders.each {|e| tmp = ::Object.const_get(map[e]).encoder(tmp)}
+    collector(tmp)
+  end
+
+  describe "stream_decoder" do
+    it "works with a string stream" do
+      @stm.stream = 'testing'
+      result = collector(@stm.stream_decoder)
+      assert_equal('testing', result)
+      assert_equal(Encoding::BINARY, result.encoding)
+    end
+
+    it "works with an IO object inside StreamData" do
+      io = StringIO.new(encoded_data('testing', [:A85, :AHx]))
+      @stm.stream = HexaPDF::StreamData.new(io, filter: [:AHx, :A85])
+      assert_equal('testing', collector(@stm.stream_decoder))
+    end
+
+    it "works with a Proc object inside StreamData" do
+      @stm.stream = HexaPDF::StreamData.new(proc {'testing'})
+      assert_equal('testing', collector(@stm.stream_decoder))
+    end
+
+    it "fails if an unknown filter name is used" do
+      @stm.stream = HexaPDF::StreamData.new(feeder('testing'), filter: [:Unknown])
+      assert_raises(HexaPDF::Error) { @stm.stream_decoder }
+    end
+  end
+
+  describe "stream_encoder" do
+    it "uses the :Filter and :DecodeParms entries of the value attribute correctly" do
+      @stm.value[:Filter] = nil
+      @stm.stream = 'test'
+      assert_equal('test', collector(@stm.stream_encoder))
+
+      @stm.value[:Filter] = :AHx
+      @stm.stream = 'test'
+      assert_equal('74657374>', collector(@stm.stream_encoder))
+
+      @stm.value[:Filter] = [:AHx, :Fl]
+      @stm.value[:DecodeParms] = nil
+      @stm.stream = 'abcdefg'
+      assert_equal("78da4b4c4a4e494d4b07000adb02bd>", collector(@stm.stream_encoder))
+
+      @stm.value[:Filter] = [:AHx, :Fl]
+      @stm.value[:DecodeParms] = [nil, {Predictor: 12}]
+      @stm.stream = 'abcdefg'
+      assert_equal("78da634a6462444000058f0076>", collector(@stm.stream_encoder))
+
+      @stm.value[:Filter] = [:AHx, nil, :Fl]
+      @stm.value[:DecodeParms] = [nil, nil, {Predictor: 10}]
+      @stm.stream = 'abcdefg'
+      assert_equal("78da6348644862486648614865486348070012fa02bd>", collector(@stm.stream_encoder))
+    end
+
+    it "decodes a StreamData stream before encoding" do
+      @stm.value[:Filter] = :AHx
+      data_proc = proc { encoded_data('test', [:A85, :AHx]) }
+      @stm.stream = HexaPDF::StreamData.new(data_proc, filter: [:AHx, :A85])
+      assert_equal('74657374>', collector(@stm.stream_encoder))
+    end
+
+    it "decodes only what is necessary of a StreamData stream on encoding" do
+      @stm.value[:Filter] = :AHx
+      data_proc = proc { encoded_data('test', [:AHx, :A85]) }
+      @stm.stream = HexaPDF::StreamData.new(data_proc, filter: [:A85, :AHx])
+      assert_equal('74657374>', collector(@stm.stream_encoder))
+
+      @stm.value[:Filter] = [:Unknown]
+      @stm.stream = HexaPDF::StreamData.new(proc { 'test' }, filter: [:Unknown])
+      assert_equal('test', collector(@stm.stream_encoder))
+    end
+  end
+
+  describe "set_filter" do
+    it "sets correct filter values without decode parameters" do
+      @stm.set_filter(:Test)
+      assert_equal(:Test, @stm.value[:Filter])
+      refute(@stm.value.key?(:DecodeParms))
+
+      @stm.set_filter([:Test, :Test1])
+      assert_equal([:Test, :Test1], @stm.value[:Filter])
+      refute(@stm.value.key?(:DecodeParms))
+    end
+
+    it "sets correct filter/decode parameter values" do
+      @stm.set_filter([:Test, :Test], :Other)
+      assert_equal([:Test, :Test], @stm.value[:Filter])
+      assert_equal(:Other, @stm.value[:DecodeParms])
+
+      @stm.set_filter([:Test, :Test], [:Other, :Other])
+      assert_equal([:Test, :Test], @stm.value[:Filter])
+      assert_equal([:Other, :Other], @stm.value[:DecodeParms])
+    end
+
+    it "deletes the /Filter and/or decode parameters values when arguments are nil" do
+      @stm.set_filter(:Test, :Other)
+      @stm.set_filter(nil, :Other)
+      refute(@stm.value.key?(:Filter))
+      refute(@stm.value.key?(:DecodeParms))
+
+      @stm.set_filter(:Test, :Other)
+      @stm.set_filter(:Test, nil)
+      assert_equal(:Test, @stm[:Filter])
+      refute(@stm.value.key?(:DecodeParms))
+    end
+  end
+
+  describe "validation" do
+    it "validates the /Filter entry" do
+      assert(@stm.validate)
+
+      @stm.set_filter(:FlateDecode)
+      assert(@stm.validate(auto_correct: false))
+      assert_equal(:FlateDecode, @stm[:Filter])
+
+      @stm.set_filter(:AHx)
+      assert(@stm.validate(auto_correct: true))
+      assert_equal(:ASCIIHexDecode, @stm[:Filter])
+
+      @stm.set_filter([:FlateDecode, :AHx])
+      assert(@stm.validate(auto_correct: true))
+      assert_equal([:FlateDecode, :ASCIIHexDecode], @stm[:Filter])
+    end
+  end
+end

data/test/hexapdf/test_tokenizer.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/tokenizer'
+require 'stringio'
+require_relative 'common_tokenizer_tests'
+
+describe HexaPDF::Tokenizer do
+  include CommonTokenizerTests
+
+  def create_tokenizer(str)
+    @tokenizer = HexaPDF::Tokenizer.new(StringIO.new(str.b))
+  end
+
+  it "handles object references" do
+    create_tokenizer("1 0 R 2 15 R ")
+    assert_equal(HexaPDF::Reference.new(1, 0), @tokenizer.next_token)
+    assert_equal(HexaPDF::Reference.new(2, 15), @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)
+  end
+
+  it "next_token: should not fail when resetting the position (due to the use of the internal StringScanner buffer)" do
+    create_tokenizer("0 1 2 3 4 " * 4000)
+    4000.times do
+      5.times {|i| assert_equal(i, @tokenizer.next_token)}
+    end
+  end
+end

data/test/hexapdf/test_writer.rb

@@ -0,0 +1,120 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/writer'
+require 'hexapdf/document'
+require 'stringio'
+
+describe HexaPDF::Writer do
+  before do
+    @std_input_io = StringIO.new(<<EOF.force_encoding(Encoding::BINARY))
+%PDF-1.7
+%\xCF\xEC\xFF\xE8\xD7\xCB\xCD
+1 0 obj
+10
+endobj
+2 0 obj
+20
+endobj
+xref
+0 3
+0000000000 65535 f 
+0000000018 00000 n 
+0000000036 00000 n 
+trailer
+<</Size 3>>
+startxref
+54
+%%EOF
+2 0 obj
+<</Length 10>>stream
+Some data!
+endstream
+endobj
+xref
+2 1
+0000000162 00000 n 
+trailer
+<</Size 3/Prev 54>>
+startxref
+219
+%%EOF
+3 0 obj
+<</Producer(HexaPDF version 0.1.0)>>
+endobj
+xref
+3 1
+0000000296 00000 n 
+trailer
+<</Prev 219/Size 4/Root<</Type/Catalog>>/Info 3 0 R>>
+startxref
+348
+%%EOF
+EOF
+
+    @compressed_input_io = StringIO.new(<<EOF.force_encoding(Encoding::BINARY))
+%PDF-1.7
+%\xCF\xEC\xFF\xE8\xD7\xCB\xCD
+5 0 obj
+<</Type/ObjStm/N 1/First 4/Filter/FlateDecode/Length 15>>stream
+x\xDA3T0P04P\x00\x00\x04\xA1\x01#
+endstream
+endobj
+2 0 obj
+20
+endobj
+3 0 obj
+<</Size 6/Type/XRef/W[1 1 2]/Index[0 4 5 1]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 31>>stream
+x\xDAcb`\xF8\xFF\x9F\x89\x89\x95\x91\x91\xE9\x7F\x19\x03\x03\x13\x83\x10\x88he`\x00\x00B4\x04\x1E
+endstream
+endobj
+startxref
+141
+%%EOF
+6 0 obj
+<</Producer(HexaPDF version 0.1.0)>>
+endobj
+2 0 obj
+<</Length 10>>stream
+Some data!
+endstream
+endobj
+4 0 obj
+<</Size 7/Prev 141/Root<</Type/Catalog>>/Info 6 0 R/Type/XRef/W[1 2 2]/Index[2 1 4 1 6 1]/Filter/FlateDecode/DecodeParms<</Columns 5/Predictor 12>>/Length 22>>stream
+x\xDAcbdlc``b`\xB0\x04\x93\x93\x19\x18\x00\f\x0F\x01[
+endstream
+endobj
+startxref
+447
+%%EOF
+EOF
+  end
+
+  def assert_document_conversion(input_io)
+    document = HexaPDF::Document.new(io: input_io)
+    document.trailer.info[:Producer] = "unknown"
+    output_io = StringIO.new(''.force_encoding(Encoding::BINARY))
+    HexaPDF::Writer.write(document, output_io)
+    assert_equal(input_io.string, output_io.string)
+  end
+
+  it "writes a complete document" do
+    assert_document_conversion(@std_input_io)
+    assert_document_conversion(@compressed_input_io)
+  end
+
+  it "raises an error if no xref stream is in a revision but object streams are" do
+    document = HexaPDF::Document.new
+    document.add(Type: :ObjStm)
+    assert_raises(HexaPDF::Error) { HexaPDF::Writer.new(document, StringIO.new).write }
+  end
+
+  it "raises an error if the class is misused and an xref section contains invalid entries" do
+    document = HexaPDF::Document.new
+    io = StringIO.new
+    writer = HexaPDF::Writer.new(document, io)
+    xref_section = HexaPDF::XRefSection.new
+    xref_section.add_compressed_entry(1, 2, 3)
+    assert_raises(HexaPDF::Error) { writer.send(:write_xref_section, xref_section) }
+  end
+end

data/test/hexapdf/test_xref_section.rb

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/xref_section'
+
+describe HexaPDF::XRefSection do
+  before do
+    @xref_section = HexaPDF::XRefSection.new
+  end
+
+  describe "each_subsection" do
+    def assert_subsections(result)
+      assert_equal(result, @xref_section.each_subsection.map {|s| s.map(&:oid)})
+    end
+
+    it "works for newly initialized objects" do
+      assert_subsections([[]])
+    end
+
+    it "works for a single subsection" do
+      @xref_section.add_in_use_entry(1, 0, 0)
+      @xref_section.add_in_use_entry(2, 0, 0)
+      assert_subsections([[1, 2]])
+    end
+
+    it "works for multiple subsections" do
+      @xref_section.add_in_use_entry(10, 0, 0)
+      @xref_section.add_in_use_entry(11, 0, 0)
+      @xref_section.add_in_use_entry(1, 0, 0)
+      @xref_section.add_in_use_entry(2, 0, 0)
+      @xref_section.add_in_use_entry(20, 0, 0)
+      assert_subsections([[1, 2], [10, 11], [20]])
+    end
+  end
+end

data/test/hexapdf/type/test_catalog.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/catalog'
+
+describe HexaPDF::Type::Catalog do
+  before do
+    @doc = HexaPDF::Document.new
+    @catalog = @doc.add(Type: :Catalog)
+  end
+
+  it "must always be indirect" do
+    @catalog.must_be_indirect = false
+    assert(@catalog.must_be_indirect?)
+  end
+
+  it "creates the page tree on access" do
+    assert_nil(@catalog[:Pages])
+    pages = @catalog.pages
+    assert_equal(:Pages, pages.type)
+  end
+
+  describe "validation" do
+    it "creates the page tree if necessary" do
+      refute(@catalog.validate(auto_correct: false))
+      assert(@catalog.validate)
+    end
+  end
+end

data/test/hexapdf/type/test_embedded_file.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+require 'hexapdf/type/embedded_file'
+
+describe HexaPDF::Type::EmbeddedFile::MacInfo do
+  it "uses a custom type" do
+    obj = HexaPDF::Type::EmbeddedFile::MacInfo.new({})
+    assert_equal(:XXEmbeddedFileParametersMacInfo, obj.type)
+  end
+end
+
+describe HexaPDF::Type::EmbeddedFile::Parameters do
+  it "uses a custom type" do
+    obj = HexaPDF::Type::EmbeddedFile::Parameters.new({})
+    assert_equal(:XXEmbeddedFileParameters, obj.type)
+  end
+end