hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -1,322 +0,0 @@
-# -*- 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

@@ -1,53 +0,0 @@
-# -*- 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

@@ -1,59 +0,0 @@
-# -*- 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

@@ -1,38 +0,0 @@
-# -*- 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

@@ -1,21 +0,0 @@
-# -*- 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

@@ -1,24 +0,0 @@
-# -*- 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

@@ -1,44 +0,0 @@
-# -*- 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

@@ -1,52 +0,0 @@
-# -*- 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