hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -0,0 +1,322 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/encryption/standard_security_handler'
+require 'hexapdf/document'
+require 'hexapdf/writer'
+require 'stringio'
+
+describe HexaPDF::Encryption::StandardEncryptionDictionary do
+  before do
+    @document = HexaPDF::Document.new
+    @dict = HexaPDF::Encryption::StandardEncryptionDictionary.new({}, document: @document)
+    @dict[:Filter] = :Standard
+    @dict[:V] = 1
+    @dict[:R] = 2
+    @dict[:U] = 'test' * 8
+    @dict[:O] = 'test' * 8
+    @dict[:P] = -5
+    @dict[:UE] = 'test' * 8
+    @dict[:OE] = 'test' * 8
+    @dict[:Perms] = 'test' * 8
+  end
+
+  it "validates the /R value" do
+    @dict[:R] = 2
+    assert(@dict.validate)
+    @dict[:R] = 5
+    refute(@dict.validate)
+  end
+
+  [:U, :O].each do |field|
+    it "validates the length of /#{field} field for R <= 4" do
+      @dict[field] = 'test'
+      refute(@dict.validate)
+    end
+  end
+
+  [:U, :O, :UE, :OE, :Perms].each do |field|
+    it "validates the length of /#{field} field for R=6" do
+      @dict[:R] = 6
+      @dict[field] = 'test'
+      refute(@dict.validate)
+    end
+  end
+
+  [:UE, :OE, :Perms].each do |field|
+    it "validates the existence of the /#{field} field for R=6" do
+      @dict[:R] = 6
+      @dict.delete(field)
+      refute(@dict.validate)
+    end
+  end
+end
+
+describe HexaPDF::Encryption::StandardSecurityHandler do
+  test_files = Dir[File.join(TEST_DATA_DIR, 'standard-security-handler', '*.pdf')].sort
+  user_password = 'uhexapdf'
+  owner_password = 'ohexapdf'
+
+  minimal_doc = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
+
+  test_files.each do |file|
+    basename = File.basename(file)
+    it "can decrypt, encrypt and decrypt the encrypted file #{basename} with the user password" do
+      begin
+        doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),
+                                    decryption_opts: {password: user_password})
+        assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+
+        out = StringIO.new(''.b)
+        HexaPDF::Writer.new(doc, out).write
+        doc = HexaPDF::Document.new(io: out, decryption_opts: {password: user_password})
+        assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+      rescue HexaPDF::EncryptionError => e
+        flunk("Error processing #{basename}: #{e}")
+      end
+    end
+
+    unless basename.start_with?("userpwd")
+      it "can decrypt the encrypted file #{basename} with the owner password" do
+        begin
+          doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),
+                                      decryption_opts: {password: owner_password})
+          assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+        rescue HexaPDF::EncryptionError => e
+          flunk("Error processing #{basename}: #{e}")
+        end
+      end
+    end
+  end
+
+  before do
+    @document = HexaPDF::Document.new
+    @handler = HexaPDF::Encryption::StandardSecurityHandler.new(@document)
+  end
+
+  it "can encrypt and then decrypt with all encryption variations" do
+    {arc4: [40, 48, 128], aes: [128, 256]}.each do |algorithm, key_lengths|
+      key_lengths.each do |key_length|
+        begin
+          doc = HexaPDF::Document.new
+          doc.encrypt(algorithm: algorithm, key_length: key_length)
+          sio = StringIO.new
+          doc.write(sio)
+          doc = HexaPDF::Document.new(io: sio)
+          assert_kind_of(Time, doc.trailer.info[:ModDate], "alg: #{algorithm} #{key_length} bits")
+        rescue HexaPDF::Error => e
+          flunk("Error using variation: #{algorithm} #{key_length} bits\n" << e.message)
+        end
+      end
+    end
+  end
+
+  describe "prepare_encryption" do
+    it "returns the encryption dictionary wrapped with a custom class" do
+      dict = @handler.set_up_encryption
+      assert_kind_of(HexaPDF::Encryption::StandardEncryptionDictionary, dict)
+    end
+
+    it "sets the correct revision independent /Filter value" do
+      dict = @handler.set_up_encryption
+      assert_equal(:Standard, dict[:Filter])
+    end
+
+    it "sets the correct revision independent /P value" do
+      dict = @handler.set_up_encryption
+      assert_equal(@handler.class::Permissions::ALL | \
+                   @handler.class::Permissions::RESERVED - 2**32,
+                   dict[:P])
+      dict = @handler.set_up_encryption(permissions: @handler.class::Permissions::COPY_CONTENT)
+      assert_equal(@handler.class::Permissions::COPY_CONTENT | \
+                   @handler.class::Permissions::RESERVED - 2**32,
+                   dict[:P])
+      dict = @handler.set_up_encryption(permissions: [:modify_content, :modify_annotation])
+      assert_equal(@handler.class::Permissions::MODIFY_CONTENT | \
+                   @handler.class::Permissions::MODIFY_ANNOTATION | \
+                   @handler.class::Permissions::RESERVED - 2**32,
+                   dict[:P])
+    end
+
+    it "sets the correct revision independent /EncryptMetadata value" do
+      dict = @handler.set_up_encryption
+      assert(dict[:EncryptMetadata])
+      dict = @handler.set_up_encryption(encrypt_metadata: false)
+      refute(dict[:EncryptMetadata])
+    end
+
+    it "sets the correct encryption dictionary values for revision 2 and 3" do
+      arc4_assertions = lambda do |d|
+        assert_equal(32, d[:U].length)
+        assert_equal(32, d[:O].length)
+        refute(d.value.key?(:UE))
+        refute(d.value.key?(:OE))
+        refute(d.value.key?(:Perms))
+      end
+      dict = @handler.set_up_encryption(key_length: 40, algorithm: :arc4)
+      assert_equal(2, dict[:R])
+      arc4_assertions.call(dict)
+
+      dict = @handler.set_up_encryption(key_length: 128, algorithm: :arc4)
+      assert_equal(3, dict[:R])
+      arc4_assertions.call(dict)
+    end
+
+    it "sets the correct encryption dictionary values for revisions 4 and 6" do
+      crypt_filter = lambda do |d, r, alg, length|
+        assert_equal(r, d[:R])
+        assert_equal(alg == :AESV3 ? 48 : 32, d[:U].length)
+        assert_equal(alg == :AESV3 ? 48 : 32, d[:O].length)
+        assert_equal({CFM: alg, Length: length, AuthEvent: :DocOpen}, d[:CF][:StdCF])
+        assert_equal(:StdCF, d[:StrF])
+        assert_equal(:StdCF, d[:StmF])
+      end
+
+      dict = @handler.set_up_encryption(key_length: 128, algorithm: :arc4, force_v4: true)
+      refute(dict.value.key?(:UE))
+      refute(dict.value.key?(:OE))
+      refute(dict.value.key?(:Perms))
+      crypt_filter.call(dict, 4, :V2, 16)
+
+      dict = @handler.set_up_encryption(key_length: 128, algorithm: :aes)
+      refute(dict.value.key?(:UE))
+      refute(dict.value.key?(:OE))
+      refute(dict.value.key?(:Perms))
+      crypt_filter.call(dict, 4, :AESV2, 16)
+
+      dict = @handler.set_up_encryption(key_length: 256, algorithm: :aes)
+      assert_equal(32, dict[:UE].length)
+      assert_equal(32, dict[:OE].length)
+      assert_equal(16, dict[:Perms].length)
+      crypt_filter.call(dict, 6, :AESV3, 32)
+    end
+
+    it "uses the password keyword as fallback, the user password as owner password if necessary" do
+      dict1 = @handler.set_up_encryption(password: 'user', owner_password: 'owner')
+      dict2 = @handler.set_up_encryption(password: 'owner', user_password: 'user')
+      dict3 = @handler.set_up_encryption(user_password: 'user', owner_password: 'owner')
+      dict4 = @handler.set_up_encryption(user_password: 'test', owner_password: 'test')
+      dict5 = @handler.set_up_encryption(user_password: 'test')
+
+      assert_equal(dict1[:U], dict2[:U])
+      assert_equal(dict2[:U], dict3[:U])
+      assert_equal(dict1[:O], dict2[:O])
+      assert_equal(dict2[:O], dict3[:O])
+      assert_equal(dict4[:O], dict5[:O])
+    end
+
+    it "fails if the password contains invalid characters" do
+      assert_raises(HexaPDF::EncryptionError) { @handler.set_up_encryption(password: 'œ test') }
+    end
+
+    it "fails for unknown keywords" do
+      assert_raises(ArgumentError) { @handler.set_up_encryption(unknown: 'test') }
+    end
+  end
+
+  describe "prepare_decryption" do
+    it "fails if the /Filter value is incorrect" do
+      exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
+        @handler.set_up_decryption({Filter: :NonStandard, V: 2})
+      end
+      assert_match(/Invalid \/Filter/i, exp.message)
+    end
+
+    it "fails if the /R value is incorrect" do
+      exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
+        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 5})
+      end
+      assert_match(/Invalid \/R/i, exp.message)
+    end
+
+    it "fails if the ID in the document's trailer is missing although it is needed" do
+      exp = assert_raises(HexaPDF::EncryptionError) do
+        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 2})
+      end
+      assert_match(/Document ID/i, exp.message)
+    end
+
+    it "fails if the supplied password is invalid" do
+      exp = assert_raises(HexaPDF::EncryptionError) do
+        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 6, U: 'a' * 48, O: 'a' * 48,
+                                    UE: 'a' * 32, OE: 'a' * 32})
+      end
+      assert_match(/Invalid password/i, exp.message)
+    end
+
+    describe "/Perms field checking" do
+      before do
+        @dict = @handler.set_up_encryption(key_length: 256, algorithm: :aes)
+      end
+
+      it "fails if the field cannot be decrypted" do
+        @dict[:Perms].succ!
+        exp = assert_raises(HexaPDF::EncryptionError) { @handler.set_up_decryption(@dict) }
+        assert_match(/cannot be decrypted/, exp.message)
+      end
+
+      it "fails if the /P field doesn't match" do
+        @dict[:P] = 500
+        exp = assert_raises(HexaPDF::EncryptionError) { @handler.set_up_decryption(@dict) }
+        assert_match(/\/P/, exp.message)
+      end
+
+      it "fails if the /EncryptMetadata field doesn't match" do
+        @dict[:EncryptMetadata] = false
+        exp = assert_raises(HexaPDF::EncryptionError) { @handler.set_up_decryption(@dict) }
+        assert_match(/\/EncryptMetadata/, exp.message)
+      end
+
+      it "ignores the /Perms when requested" do
+        obj = HexaPDF::Object.new(nil, oid: 1)
+        obj.value = @handler.encrypt_string('test', obj)
+
+        @dict[:P] = 500
+        @handler.set_up_decryption(@dict, check_permissions: false)
+        assert_equal('test', @handler.decrypt(obj).value)
+      end
+    end
+  end
+
+  it "encryption key stays valid even if default dict values are set while setting up decryption" do
+    @document.encrypt(key_length: 128, algorithm: :aes)
+    assert(@document.security_handler.encryption_key_valid?)
+
+    @document.trailer[:Encrypt].delete(:EncryptMetadata)
+    handler = HexaPDF::Encryption::SecurityHandler.set_up_decryption(@document)
+    assert(handler.encryption_key_valid?)
+  end
+
+  it "returns an array of permission symbols" do
+    perms = @handler.class::Permissions::MODIFY_CONTENT | @handler.class::Permissions::COPY_CONTENT
+    @handler.set_up_encryption(permissions: perms)
+    assert_equal([:copy_content, :modify_content], @handler.permissions.sort)
+  end
+
+  describe "handling of metadata streams" do
+    before do
+      @doc = HexaPDF::Document.new
+      @output = StringIO.new(''.b)
+    end
+
+    it "doesn't decrypt or encrypt a metadata stream if /EncryptMetadata is false" do
+      @doc.encrypt(encrypt_metadata: false)
+      @doc.catalog[:Metadata] = @doc.wrap({Type: :Metadata, Subtype: :XML}, stream: "HELLODATA")
+      @doc.write(@output)
+      assert_match(/stream\nHELLODATA\nendstream/, @output.string)
+
+      doc = HexaPDF::Document.new(io: @output)
+      assert_equal('HELLODATA', doc.catalog[:Metadata].stream)
+    end
+
+    it "doesn't modify decryption/encryption for metadata streams if /V is not 4 or 5" do
+      @doc.encrypt(encrypt_metadata: false, algorithm: :arc4)
+      @doc.catalog[:Metadata] = @doc.wrap({Type: :Metadata, Subtype: :XML}, stream: "HELLODATA")
+      @doc.write(@output)
+      refute_match(/stream\nHELLODATA\nendstream/, @output.string)
+
+      doc = HexaPDF::Document.new(io: @output)
+      assert_equal('HELLODATA', doc.catalog[:Metadata].stream)
+    end
+  end
+end

data/test/hexapdf/filter/common.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+
+# Provides common tests for all filter implementations.
+#
+# The filter object needs to be available in the @obj variable and the @all_test_cases variable
+# needs to hold an array of test cases, i.e. [decoded, encoded] objects.
+module CommonFilterTests
+  include TestHelper
+
+  TEST_BIG_STR = ''.b
+  TEST_BIG_STR << [rand(2**32)].pack('N') while TEST_BIG_STR.length < 2**16
+  TEST_BIG_STR.freeze
+
+  def test_decodes_correctly
+    @all_test_cases.each_with_index do |(result, str), index|
+      assert_equal(result, collector(@obj.decoder(feeder(str.dup))), "testcase #{index}")
+    end
+  end
+
+  def test_encodes_correctly
+    @all_test_cases.each_with_index do |(str, result), index|
+      assert_equal(result, collector(@obj.encoder(feeder(str.dup))), "testcase #{index}")
+    end
+  end
+
+  def test_works_with_big_data
+    assert_equal(TEST_BIG_STR, collector(@obj.decoder(@obj.encoder(feeder(TEST_BIG_STR.dup)))))
+  end
+
+  def test_decoder_returns_strings_in_binary_encoding
+    assert_encodings(@obj.decoder(@obj.encoder(feeder('some test data', 1))), "decoder")
+  end
+
+  def test_encoder_returns_strings_in_binary_encoding
+    assert_encodings(@obj.encoder(feeder('some test data', 1)), "encoder")
+  end
+
+  def assert_encodings(source, type)
+    while source.alive? && (data = source.resume)
+      assert_equal(Encoding::BINARY, data.encoding, "encoding problem in #{type}")
+    end
+  end
+
+  def test_decoder_works_with_single_byte_input
+    assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded.dup, 1))))
+  end
+
+  def test_encoder_works_with_single_byte_input
+    assert_equal(@encoded, collector(@obj.encoder(feeder(@decoded.dup, 1))))
+  end
+end

data/test/hexapdf/filter/test_ascii85_decode.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/ascii85_decode'
+
+describe HexaPDF::Filter::ASCII85Decode do
+  include CommonFilterTests
+
+  before do
+    @obj = HexaPDF::Filter::ASCII85Decode
+    @all_test_cases ||= [['Nov shmoz ka pop.', ':2b:uF(fE/H6@!3+E27</c~>'],
+                         ['Nov shmoz ka pop.1', ':2b:uF(fE/H6@!3+E27</hm~>'],
+                         ['Nov shmoz ka pop.12', ':2b:uF(fE/H6@!3+E27</ho*~>'],
+                         ['Nov shmoz ka pop.123', ':2b:uF(fE/H6@!3+E27</ho+;~>'],
+                         ["\0\0\0\0Nov shmoz ka pop.", 'z:2b:uF(fE/H6@!3+E27</c~>'],
+                         ["Nov \x0\x0\x0\x0shmoz ka pop.", ':2b:uzF(fE/H6@!3+E27</c~>']]
+    @decoded = @all_test_cases[0][0]
+    @encoded = @all_test_cases[0][1]
+  end
+
+  describe "decoder" do
+    it "works with single byte input on specially crated input" do
+      assert_equal("Nov \0\0\0", collector(@obj.decoder(feeder(':2b:u!!!!~>', 1))))
+    end
+
+    it "ignores whitespace in the input" do
+      encoded = @encoded.dup.scan(/./).map {|a| "#{a} \r\t" }.join("\n")
+      assert_equal(@decoded, collector(@obj.decoder(feeder(encoded))))
+    end
+
+    it "works without the EOD marker" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded.sub(/~>/, '')))))
+    end
+
+    it "ignores data after the EOD marker" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded << "~>abcdefg"))))
+    end
+
+    it "fails if the input contains invalid characters" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder(':2bwx!'))) }
+    end
+
+    it "fails if the input contains values outside the BASE85 range" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder('uuuuu'))) }
+    end
+
+    it "fails if the last rest contains a 'z' character" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder('uuz'))) }
+    end
+
+    it "fails if the last rest contains a '~' character" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder('uu~'))) }
+    end
+
+    it "fails if the last rest contains values outside the BASE85 range" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder('uuu>', 1))) }
+    end
+  end
+end

data/test/hexapdf/filter/test_ascii_hex_decode.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/ascii_hex_decode'
+
+describe HexaPDF::Filter::ASCIIHexDecode do
+  include CommonFilterTests
+
+  before do
+    @obj = HexaPDF::Filter::ASCIIHexDecode
+    @all_test_cases = [['Nov shmoz ka pop.', '4e6f762073686d6f7a206b6120706f702e>']]
+    @decoded = @all_test_cases[0][0]
+    @encoded = @all_test_cases[0][1]
+  end
+
+  describe "decoder" do
+    it "ignores whitespace in the input" do
+      with_whitespace = @encoded.scan(/./).map {|a| "#{a} \r\t" }.join("\n")
+      assert_equal(@decoded, collector(@obj.decoder(feeder(with_whitespace, 1))))
+    end
+
+    it "works without the EOD marker" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded.chop, 5))))
+    end
+
+    it "ignores data after the EOD marker" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded << '4e6f7gzz'))))
+    end
+
+    it "assumes the missing char is '0' if the input length is odd" do
+      assert_equal(@decoded.chop << ' ', collector(@obj.decoder(feeder(@encoded.chop.chop))))
+    end
+
+    it "fails on invalid characters" do
+      assert_raises(HexaPDF::FilterError) { @obj.decoder(feeder('f0f0z')).resume }
+    end
+  end
+end

data/test/hexapdf/filter/test_crypt.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/filter/crypt'
+
+describe HexaPDF::Filter::Crypt do
+  before do
+    @obj = HexaPDF::Filter::Crypt
+    @source = Fiber.new { "hallo" }
+  end
+
+  it "works with the Identity filter" do
+    assert_equal(@source, @obj.decoder(@source, nil))
+    assert_equal(@source, @obj.encoder(@source, {})) # sic: 'encoder'
+    assert_equal(@source, @obj.decoder(@source, {Name: :Identity}))
+  end
+
+  it "fails if crypt filter name is not Identity" do
+    assert_raises(HexaPDF::FilterError) { @obj.decoder(@source, {Name: :Other}) }
+  end
+end

data/test/hexapdf/filter/test_encryption.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/encryption'
+
+describe HexaPDF::Filter::Encryption do
+  before do
+    @obj = HexaPDF::Filter::Encryption
+  end
+
+  it "returns the correct decryption fiber" do
+    algorithm = Minitest::Mock.new
+    algorithm.expect(:decryption_fiber, :fiber, [:key, :source])
+    assert_equal(:fiber, @obj.decoder(:source, key: :key, algorithm: algorithm))
+    algorithm.verify
+  end
+
+  it "returns the correct encryption fiber" do
+    algorithm = Minitest::Mock.new
+    algorithm.expect(:encryption_fiber, :fiber, [:key, :source])
+    assert_equal(:fiber, @obj.encoder(:source, key: :key, algorithm: algorithm))
+    algorithm.verify
+  end
+end

data/test/hexapdf/filter/test_flate_decode.rb

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/flate_decode'
+
+describe HexaPDF::Filter::FlateDecode do
+  include CommonFilterTests
+
+  before do
+    @obj = HexaPDF::Filter::FlateDecode
+    @all_test_cases = [["abcdefg".force_encoding(Encoding::BINARY),
+                        "x\xDAKLJNIMK\a\x00\n\xDB\x02\xBD".force_encoding(Encoding::BINARY)]]
+    @decoded = @all_test_cases[0][0]
+    @encoded = @all_test_cases[0][1]
+    @encoded_predictor = "x\xDAcJdbD@\x00\x05\x8F\x00v".force_encoding(Encoding::BINARY)
+    @predictor_opts = {Predictor: 12}
+  end
+
+  describe "decoder" do
+    it "works for empty input" do
+      assert_equal('', collector(@obj.decoder(Fiber.new { "" })))
+      assert_equal('', collector(@obj.decoder(Fiber.new {})))
+    end
+
+    it "applies the Predictor after decoding" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded_predictor), @predictor_opts)))
+    end
+
+    it "fails on invalid input" do
+      assert_raises(HexaPDF::FilterError) do
+        collector(@obj.decoder(feeder(@encoded[0..-2], @encoded.length - 3)))
+      end
+      assert_raises(HexaPDF::FilterError) do
+        collector(@obj.decoder(feeder("some data")))
+      end
+    end
+  end
+
+  describe "encoder" do
+    it "applies the Predictor before encoding" do
+      assert_equal(@encoded_predictor, collector(@obj.encoder(feeder(@decoded), @predictor_opts)))
+    end
+  end
+end

data/test/hexapdf/filter/test_lzw_decode.rb

@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/lzw_decode'
+
+describe HexaPDF::Filter::LZWDecode do
+  include CommonFilterTests
+
+  before do
+    @obj = HexaPDF::Filter::LZWDecode
+    @all_test_cases ||= [["-----A---B".b, "\x80\x0b\x60\x50\x22\x0c\x0c\x85\x01".b],
+                         ['abcabcaaaabbbcdeffffffagggggg'.b,
+                          "\x80\x18LF8\x14\x10\xC3\a1BLfC)\x9A\x1D\x0F0\x99\xE2Q8\b".b]]
+    @decoded = @all_test_cases[0][0]
+    @encoded = @all_test_cases[0][1]
+    @encoded_predictor = "\x80\x00\x85\xA0 \x04\x12\r\x05\n\x00\x9D\x90p\x10V\x02".b
+    @predictor_opts = {Predictor: 12}
+  end
+
+  describe "decoder" do
+    it "applies the Predictor after decoding" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded_predictor), @predictor_opts)))
+    end
+
+    it "fails if an unknown code is found after CLEAR_TABLE" do
+      assert_raises(HexaPDF::FilterError) { @obj.decoder(feeder("\xff\xff")).resume }
+    end
+
+    it "fails if an unknown code is found elsewhere" do
+      assert_raises(HexaPDF::FilterError) { @obj.decoder(feeder("\x00\x7f\xff\xf0")).resume }
+    end
+
+    it "fails if the code size would be more than 12bit" do
+      stream = HexaPDF::Utils::BitStreamWriter.new
+      result = stream.write(256, 9)
+      result << stream.write(65, 9)
+      258.upto(510) {|i| result << stream.write(i, 9) }
+      511.upto(1022) {|i| result << stream.write(i, 10) }
+      1023.upto(2046) {|i| result << stream.write(i, 11) }
+      2047.upto(4095) {|i| result << stream.write(i, 12) }
+      result << stream.write(96, 12)
+      result << stream.finalize
+      assert_raises(HexaPDF::FilterError) { @obj.decoder(feeder(result)).resume }
+    end
+  end
+
+  describe "encoder" do
+    it "applies the Predictor before encoding" do
+      assert_equal(@encoded_predictor, collector(@obj.encoder(feeder(@decoded), @predictor_opts)))
+    end
+  end
+end