From: Guilhem Moulin <guilhem@debian.org>
Date: Sun, 20 Dec 2020 16:23:13 +0100
Subject: Fix FTBFS with phpunit 9.5.0-1.

Forwarded: not-needed
---
 Crypt_GPG-1.6.4/tests/DecryptAndVerifyTest.php |  36 ++---
 Crypt_GPG-1.6.4/tests/DecryptTest.php          |  30 ++--
 Crypt_GPG-1.6.4/tests/DeletePrivateKeyTest.php |   6 +-
 Crypt_GPG-1.6.4/tests/DeletePublicKeyTest.php  |   6 +-
 Crypt_GPG-1.6.4/tests/EncryptAndSignTest.php   |  24 +--
 Crypt_GPG-1.6.4/tests/EncryptTest.php          |  12 +-
 Crypt_GPG-1.6.4/tests/ExceptionsTest.php       |  40 ++---
 Crypt_GPG-1.6.4/tests/ExportPrivateKeyTest.php |  10 +-
 Crypt_GPG-1.6.4/tests/ExportPublicKeyTest.php  |   5 +-
 Crypt_GPG-1.6.4/tests/GeneralTest.php          |  38 ++---
 Crypt_GPG-1.6.4/tests/ImportKeyTest.php        |  12 +-
 Crypt_GPG-1.6.4/tests/KeyGeneratorTest.php     | 194 +++++++++++++++----------
 Crypt_GPG-1.6.4/tests/SignTest.php             |  18 +--
 Crypt_GPG-1.6.4/tests/VerifyTest.php           |  15 +-
 14 files changed, 208 insertions(+), 238 deletions(-)

diff --git a/Crypt_GPG-1.6.4/tests/DecryptAndVerifyTest.php b/Crypt_GPG-1.6.4/tests/DecryptAndVerifyTest.php
index d7a4717..419282e 100644
--- a/Crypt_GPG-1.6.4/tests/DecryptAndVerifyTest.php
+++ b/Crypt_GPG-1.6.4/tests/DecryptAndVerifyTest.php
@@ -188,12 +188,11 @@ TEXT;
     // {{{ testDecryptVerifyKeyNotFoundException_decrypt()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testDecryptVerifyKeyNotFoundException_decrypt()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         // was encrypted with missing-key@example.com, signed with
         // first-keypair@example.com
         // {{{ encrypted data
@@ -229,12 +228,11 @@ TEXT;
     // {{{ testDecryptVerifyKeyNotFoundException_verify()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testDecryptVerifyKeyNotFoundException_verify()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         // was encrypted with first-keypair@example.com, signed with
         // missing-key@example.com
         // {{{ encrypted data
@@ -276,12 +274,11 @@ TEXT;
     // {{{ testDecryptVerifyKeyNotFoundException_both()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testDecryptVerifyKeyNotFoundException_both()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         // was encrypted and signed with missing-key@example.com
         // {{{ encrypted data
         $encryptedData = <<<TEXT
@@ -373,12 +370,11 @@ TEXT;
     // {{{ testDecryptVerifyNoDataException_invalid()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group string
      */
     public function testDecryptVerifyNoDataException_invalid()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $encryptedData = 'Invalid OpenPGP data.';
         $this->gpg->decryptAndVerify($encryptedData);
     }
@@ -387,12 +383,11 @@ TEXT;
     // {{{ testDecryptVerifyNoDataException_empty()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group string
      */
     public function testDecryptVerifyNoDataException_empty()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $encryptedData = '';
         $this->gpg->decryptAndVerify($encryptedData);
     }
@@ -401,12 +396,11 @@ TEXT;
     // {{{ testDecryptVerifyBadPassphraseException_missing()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group string
      */
     public function testDecryptVerifyBadPassphraseException_missing()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         // encrypted with first-keypair@example.com, signed with
         // first-keypair@example.com
         // {{{ encrypted data no passphrase
@@ -442,12 +436,11 @@ TEXT;
     // {{{ testDecryptVerifyBadPassphraseException_bad()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group string
      */
     public function testDecryptVerifyBadPassphraseException_bad()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         // encrypted with first-keypair@example.com, signed with
         // first-keypair@example.com
         // {{{ encrypted data no passphrase
@@ -648,12 +641,11 @@ TEXT;
     // {{{ testDecryptAndVerifyDualNoPassphraseKeyMissing()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group string
      */
     public function testDecryptAndVerifyDualNoPassphraseKeyMissing()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         // encrypted with both first-keypair@example.com and
         // second-keypair@example.com
         // {{{ dual encrypted data
@@ -1142,12 +1134,11 @@ TEXT;
     // {{{ testDecryptVerifyFileFileException_input()
 
     /**
-     * @expectedException Crypt_GPG_FileException
-     *
      * @group file
      */
     public function testDecryptVerifyFileFileException_input()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // input file does not exist
         $inputFilename = $this->getDataFilename(
             'testDecryptVerifyFileFileException_input.asc'
@@ -1160,12 +1151,11 @@ TEXT;
     // {{{ testDecryptVerifyFileFileException_output()
 
     /**
-     * @expectedException Crypt_GPG_FileException
-     *
      * @group file
      */
     public function testDecryptVerifyFileFileException_output()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // input file is encrypted with first-keypair@example.com
         // output file does not exist
         $inputFilename  = $this->getDataFilename('testDecryptVerifyFile.asc');
@@ -1180,12 +1170,11 @@ TEXT;
     // {{{ testDecryptVerifyFileKeyNotFoundException_decrypt()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group file
      */
     public function testDecryptVerifyFileKeyNotFoundException_decrypt()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         // file is encrypted with missing-key@example.com, not signed
         $inputFilename = $this->getDataFilename(
             'testDecryptFileKeyNotFoundException.asc'
@@ -1391,12 +1380,11 @@ TEXT;
     // {{{ testDecryptVerifyFileNoDataException()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group file
      */
     public function testDecryptVerifyFileNoDataException()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $filename = $this->getDataFilename('testFileEmpty.plain');
         $this->gpg->decryptAndVerifyFile($filename);
     }
diff --git a/Crypt_GPG-1.6.4/tests/DecryptTest.php b/Crypt_GPG-1.6.4/tests/DecryptTest.php
index 3dfb37a..49e9c66 100644
--- a/Crypt_GPG-1.6.4/tests/DecryptTest.php
+++ b/Crypt_GPG-1.6.4/tests/DecryptTest.php
@@ -141,12 +141,11 @@ TEXT;
     // {{{ testDecryptKeyNotFoundException()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testDecryptKeyNotFoundException()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         // was encrypted with missing-key@example.com
         // {{{ encrypted data
         $encryptedData = <<<TEXT
@@ -179,12 +178,11 @@ TEXT;
     // {{{ testDecryptNoDataException_invalid()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group string
      */
     public function testDecryptNoDataException_invalid()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $encryptedData = 'Invalid OpenPGP data.';
         $this->gpg->decrypt($encryptedData);
     }
@@ -193,12 +191,11 @@ TEXT;
     // {{{ testDecryptNoDataException_empty()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group string
      */
     public function testDecryptNoDataException_empty()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $encryptedData = '';
         $this->gpg->decrypt($encryptedData);
     }
@@ -207,12 +204,11 @@ TEXT;
     // {{{ testDecryptBadPassphraseException_missing()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group string
      */
     public function testDecryptBadPassphraseException_missing()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         // encrypted with first-keypair@example.com
         // {{{ encrypted data
         $encryptedData = <<<TEXT
@@ -245,12 +241,11 @@ TEXT;
     // {{{ testDecryptBadPassphraseException_bad()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group string
      */
     public function testDecryptBadPassphraseException_bad()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         // encrypted with first-keypair@example.com
         // {{{ encrypted data
         $encryptedData = <<<TEXT
@@ -402,12 +397,11 @@ TEXT;
     // {{{ testDecryptDualNoPassphraseKeyMissing()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group string
      */
     public function testDecryptDualNoPassphraseKeyMissing()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         // encrypted with both first-keypair@example.com and
         // second-keypair@example.com
         // {{{ dual encrypted data
@@ -626,12 +620,11 @@ TEXT;
     // {{{ testDecryptFileFileException_input()
 
     /**
-     * @expectedException Crypt_GPG_FileException
-     *
      * @group file
      */
     public function testDecryptFileFileException_input()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // input file does not exist
         $inputFilename =
             $this->getDataFilename('testDecryptFileFileException_input.asc');
@@ -643,12 +636,11 @@ TEXT;
     // {{{ testDecryptFileFileException_output()
 
     /**
-     * @expectedException Crypt_GPG_FileException
-     *
      * @group file
      */
     public function testDecryptFileFileException_output()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // input file is encrypted with first-keypair@example.com
         // output file does not exist
         $inputFilename  = $this->getDataFilename('testDecryptFile.asc');
@@ -663,12 +655,11 @@ TEXT;
     // {{{ testDecryptFileKeyNotFoundException()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group file
      */
     public function testDecryptFileKeyNotFoundException()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         // file is encrypted with missing-key@example.com
         $inputFilename =
             $this->getDataFilename('testDecryptFileKeyNotFoundException.asc');
@@ -739,12 +730,11 @@ TEXT;
     // {{{ testDecryptFileNoDataException()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group file
      */
     public function testDecryptFileNoDataException()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $filename = $this->getDataFilename('testFileEmpty.plain');
         $this->gpg->decryptFile($filename);
     }
diff --git a/Crypt_GPG-1.6.4/tests/DeletePrivateKeyTest.php b/Crypt_GPG-1.6.4/tests/DeletePrivateKeyTest.php
index 35f3bd5..7d37f57 100644
--- a/Crypt_GPG-1.6.4/tests/DeletePrivateKeyTest.php
+++ b/Crypt_GPG-1.6.4/tests/DeletePrivateKeyTest.php
@@ -111,12 +111,11 @@ class DeletePrivateKeyTestCase extends Crypt_GPG_TestCase
     // {{{ testDeletePrivateKeyNotFoundException()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group delete-private
      */
     public function testDeletePrivateKeyNotFoundException()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $keyId = 'non-existent-key@example.com';
         $this->gpg->deletePrivateKey($keyId);
     }
@@ -125,12 +124,11 @@ class DeletePrivateKeyTestCase extends Crypt_GPG_TestCase
     // {{{ testDeletePrivateKeyNotFoundException_public_only()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group delete-private
      */
     public function testDeletePrivateKeyNotFoundException_public_only()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $keyId = 'public-only@example.com';
         $this->gpg->deletePrivateKey($keyId);
     }
diff --git a/Crypt_GPG-1.6.4/tests/DeletePublicKeyTest.php b/Crypt_GPG-1.6.4/tests/DeletePublicKeyTest.php
index a401fcc..621b0bb 100644
--- a/Crypt_GPG-1.6.4/tests/DeletePublicKeyTest.php
+++ b/Crypt_GPG-1.6.4/tests/DeletePublicKeyTest.php
@@ -76,12 +76,11 @@ class DeletePublicKeyTestCase extends Crypt_GPG_TestCase
     // {{{ testDeletePublicKeyDeletePrivateKeyException()
 
     /**
-     * @expectedException Crypt_GPG_DeletePrivateKeyException
-     *
      * @group delete-public
      */
     public function testDeletePublicKeyDeletePrivateKeyException()
     {
+        $this->expectException('Crypt_GPG_DeletePrivateKeyException');
         // GnuPG 2.1(.11) allows public key deletion in this case
         if (version_compare($this->gpg->getVersion(), '2.1.0', 'ge')) {
             $this->markTestSkipped('GnuPG >= 2.1 allows public key deletion if private key exists.');
@@ -114,12 +113,11 @@ class DeletePublicKeyTestCase extends Crypt_GPG_TestCase
     // {{{ testDeletePublicKeyNotFoundException()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group delete-public
      */
     public function testDeletePublicKeyNotFoundException()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $keyId = 'non-existent-key@example.com';
         $this->gpg->deletePublicKey($keyId);
     }
diff --git a/Crypt_GPG-1.6.4/tests/EncryptAndSignTest.php b/Crypt_GPG-1.6.4/tests/EncryptAndSignTest.php
index 178c3e7..246d5d8 100644
--- a/Crypt_GPG-1.6.4/tests/EncryptAndSignTest.php
+++ b/Crypt_GPG-1.6.4/tests/EncryptAndSignTest.php
@@ -61,12 +61,11 @@ class EncryptAndSignTestCase extends Crypt_GPG_TestCase
     // {{{ testEncryptAndSignKeyNotFoundException_invalid_sign_key()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testEncryptAndSignKeyNotFoundException_invalid_sign_key()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->addSignKey('non-existent-key@example.com');
         $this->gpg->addEncryptKey('first-keypair@example.com');
@@ -77,12 +76,11 @@ class EncryptAndSignTestCase extends Crypt_GPG_TestCase
     // {{{ testEncryptAndSignKeyNotFoundException_no_sign_key()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testEncryptAndSignKeyNotFoundException_no_sign_key()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->addEncryptKey('first-keypair@example.com');
         $this->gpg->encryptAndSign($data);
@@ -92,12 +90,11 @@ class EncryptAndSignTestCase extends Crypt_GPG_TestCase
     // {{{ testEncryptAndSignKeyNotFoundException_invalid_encrypt_key()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testEncryptAndSignKeyNotFoundException_invalid_encrypt_key()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->addSignKey('first-keypair@example.com', 'test1');
         $this->gpg->addEncryptKey('non-existent-key@example.com');
@@ -108,12 +105,11 @@ class EncryptAndSignTestCase extends Crypt_GPG_TestCase
     // {{{ testEncryptAndSignKeyNotFoundException_no_encrypt_key()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testEncryptAndSignKeyNotFoundException_no_encrypt_key()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->addSignKey('first-keypair@example.com', 'test1');
         $this->gpg->encryptAndSign($data);
@@ -123,12 +119,11 @@ class EncryptAndSignTestCase extends Crypt_GPG_TestCase
     // {{{ testEncryptAndSignBadPassphraseException_missing_sign_key()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group string
      */
     public function testEncryptAndSignBadPassphraseException_missing_sign_key()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->addSignKey('first-keypair@example.com');
         $this->gpg->addEncryptKey('first-keypair@example.com');
@@ -139,12 +134,11 @@ class EncryptAndSignTestCase extends Crypt_GPG_TestCase
     // {{{ testEncryptAndSignBadPassphraseException_bad_sign_key()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group string
      */
     public function testEncryptAndSignBadPassphraseException_bad_sign_key()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->addSignKey('first-keypair@example.com', 'incorrect');
         $this->gpg->addEncryptKey('first-keypair@example.com');
@@ -433,12 +427,11 @@ class EncryptAndSignTestCase extends Crypt_GPG_TestCase
     // {{{ testEncryptAndSignFileFileException_input()
 
     /**
-     * @expectedException Crypt_GPG_FileException
-     *
      * @group file
      */
     public function testEncryptAndSignFileFileException_input()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // input file does not exist
         $inputFilename = $this->getDataFilename(
             'testEncryptAndSignFileFileFileException_input.plain');
@@ -452,12 +445,11 @@ class EncryptAndSignTestCase extends Crypt_GPG_TestCase
     // {{{ testEncryptAndSignFileFileException_output()
 
     /**
-     * @expectedException Crypt_GPG_FileException
-     *
      * @group file
      */
     public function testEncryptAndSignFileFileException_output()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // input file is plaintext
         // output file does not exist
         $inputFilename  = $this->getDataFilename('testFileMedium.plain');
diff --git a/Crypt_GPG-1.6.4/tests/EncryptTest.php b/Crypt_GPG-1.6.4/tests/EncryptTest.php
index f86de0b..52bb632 100644
--- a/Crypt_GPG-1.6.4/tests/EncryptTest.php
+++ b/Crypt_GPG-1.6.4/tests/EncryptTest.php
@@ -115,12 +115,11 @@ class EncryptTestCase extends Crypt_GPG_TestCase
     // {{{ testEncryptKeyNotFoundException_invalid()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testEncryptNotFoundException_invalid()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->addEncryptKey('non-existent-key@example.com');
         $this->gpg->encrypt($data);
@@ -130,12 +129,11 @@ class EncryptTestCase extends Crypt_GPG_TestCase
     // {{{ testEncryptKeyNotFoundException_none()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testEncryptNotFoundException_none()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->encrypt($data);
     }
@@ -241,11 +239,10 @@ class EncryptTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group file
-     *
-     * @expectedException Crypt_GPG_FileException
      */
     public function testEncryptFileFileException_input()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // input file does not exist
         $filename =
             $this->getDataFilename('testEncryptFileFileException_input.plain');
@@ -259,11 +256,10 @@ class EncryptTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group file
-     *
-     * @expectedException Crypt_GPG_FileException
      */
     public function testEncryptFileFileException_output()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // output file does not exist
         $inputFilename  = $this->getDataFilename('testFileMedium.plain');
         $outputFilename = './non-existent' .
diff --git a/Crypt_GPG-1.6.4/tests/ExceptionsTest.php b/Crypt_GPG-1.6.4/tests/ExceptionsTest.php
index 4db5aea..b642e50 100644
--- a/Crypt_GPG-1.6.4/tests/ExceptionsTest.php
+++ b/Crypt_GPG-1.6.4/tests/ExceptionsTest.php
@@ -67,11 +67,11 @@ class ExceptionsTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group exception
-     * @expectedException Crypt_GPG_Exception
-     * @expectedExceptionMessage test exception
      */
     public function testException()
     {
+        $this->expectException('Crypt_GPG_Exception');
+        $this->expectExceptionMessage('test exception');
         throw new Crypt_GPG_Exception('test exception');
     }
 
@@ -82,11 +82,11 @@ class ExceptionsTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group file-exception
-     * @expectedException Crypt_GPG_FileException
-     * @expectedExceptionMessage test exception
      */
     public function testFileException()
     {
+        $this->expectException('Crypt_GPG_FileException');
+        $this->expectExceptionMessage('test exception');
         throw new Crypt_GPG_FileException('test exception');
     }
 
@@ -111,11 +111,11 @@ class ExceptionsTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group open-subprocess-exception
-     * @expectedException Crypt_GPG_OpenSubprocessException
-     * @expectedExceptionMessage test exception
      */
     public function testOpenSubprocessException()
     {
+        $this->expectException('Crypt_GPG_OpenSubprocessException');
+        $this->expectExceptionMessage('test exception');
         throw new Crypt_GPG_OpenSubprocessException('test exception');
     }
 
@@ -140,11 +140,11 @@ class ExceptionsTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group invalid-operation-exception
-     * @expectedException Crypt_GPG_InvalidOperationException
-     * @expectedExceptionMessage test exception
      */
     public function testInvalidOperationException()
     {
+        $this->expectException('Crypt_GPG_InvalidOperationException');
+        $this->expectExceptionMessage('test exception');
         throw new Crypt_GPG_InvalidOperationException('test exception');
     }
 
@@ -169,11 +169,11 @@ class ExceptionsTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group key-not-found-exception
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     * @expectedExceptionMessage test exception
      */
     public function testKeyNotFoundException()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
+        $this->expectExceptionMessage('test exception');
         throw new Crypt_GPG_KeyNotFoundException('test exception');
     }
 
@@ -198,11 +198,11 @@ class ExceptionsTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group no-data-exception
-     * @expectedException Crypt_GPG_NoDataException
-     * @expectedExceptionMessage test exception
      */
     public function testNoDataException()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
+        $this->expectExceptionMessage('test exception');
         throw new Crypt_GPG_NoDataException('test exception');
     }
 
@@ -213,11 +213,11 @@ class ExceptionsTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group bad-passphrase-exception
-     * @expectedException Crypt_GPG_BadPassphraseException
-     * @expectedExceptionMessage test exception
      */
     public function testBadPassphraseException()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
+        $this->expectExceptionMessage('test exception');
         throw new Crypt_GPG_BadPassphraseException('test exception');
     }
 
@@ -236,8 +236,8 @@ class ExceptionsTestCase extends Crypt_GPG_TestCase
         $this->assertTrue(is_array($keyIds), 'Failed to assert returned ' .
             'key ids for bad passphrases is an array.');
 
-        $this->assertContains('C097D9EC94C06363', $keyIds);
-        $this->assertContains('9F93F9116728EF12', $keyIds);
+        $this->assertContainsEquals('C097D9EC94C06363', $keyIds);
+        $this->assertContainsEquals('9F93F9116728EF12', $keyIds);
     }
 
     // }}}
@@ -255,8 +255,8 @@ class ExceptionsTestCase extends Crypt_GPG_TestCase
         $this->assertTrue(is_array($keyIds), 'Failed to assert returned ' .
             'key ids for missing passphrases is an array.');
 
-        $this->assertContains('C097D9EC94C06363', $keyIds);
-        $this->assertContains('9F93F9116728EF12', $keyIds);
+        $this->assertContainsEquals('C097D9EC94C06363', $keyIds);
+        $this->assertContainsEquals('9F93F9116728EF12', $keyIds);
     }
 
     // }}}
@@ -266,11 +266,11 @@ class ExceptionsTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group delete-private-key-exception
-     * @expectedException Crypt_GPG_DeletePrivateKeyException
-     * @expectedExceptionMessage test exception
      */
     public function testDeletePrivateKeyException()
     {
+        $this->expectException('Crypt_GPG_DeletePrivateKeyException');
+        $this->expectExceptionMessage('test exception');
         throw new Crypt_GPG_DeletePrivateKeyException('test exception');
     }
 
diff --git a/Crypt_GPG-1.6.4/tests/ExportPrivateKeyTest.php b/Crypt_GPG-1.6.4/tests/ExportPrivateKeyTest.php
index a7bdf53..7f17826 100644
--- a/Crypt_GPG-1.6.4/tests/ExportPrivateKeyTest.php
+++ b/Crypt_GPG-1.6.4/tests/ExportPrivateKeyTest.php
@@ -75,7 +75,7 @@ class ExportPrivateKeyTestCase extends Crypt_GPG_TestCase
 
         $keyData = $this->gpg->exportPrivateKey($keyId);
 
-        $this->assertContains($expectedKeyData, $keyData);
+        $this->assertStringContainsString($expectedKeyData, $keyData);
     }
 
     // }}}
@@ -98,19 +98,18 @@ class ExportPrivateKeyTestCase extends Crypt_GPG_TestCase
         $keyData = $this->gpg->exportPrivateKey($keyId);
 
         // Here we're really testing only the passphrase handling in GnuPG 2.1
-        $this->assertContains('PGP PRIVATE KEY', $keyData);
+        $this->assertStringContainsString('PGP PRIVATE KEY', $keyData);
     }
 
     // }}}
     // {{{ testExportPrivateKey_with_bad_pass()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group export
      */
     public function testExportPrivateKey_with_bad_pass()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         if (version_compare($this->gpg->getVersion(), '2.1.0', 'lt')) {
             $this->markTestSkipped('GnuPG >= 2.1 requires passphrase to export private key.');
         }
@@ -127,12 +126,11 @@ class ExportPrivateKeyTestCase extends Crypt_GPG_TestCase
     // {{{ testExportPrivateKeyNotFoundException()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group export
      */
     public function testExportPrivateKeyNotFoundException()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $keyId = 'non-existent-key@example.com';
         $this->gpg->exportPrivateKey($keyId);
     }
diff --git a/Crypt_GPG-1.6.4/tests/ExportPublicKeyTest.php b/Crypt_GPG-1.6.4/tests/ExportPublicKeyTest.php
index d307a14..d3ec804 100644
--- a/Crypt_GPG-1.6.4/tests/ExportPublicKeyTest.php
+++ b/Crypt_GPG-1.6.4/tests/ExportPublicKeyTest.php
@@ -72,19 +72,18 @@ class ExportPublicKeyTestCase extends Crypt_GPG_TestCase
 
         $keyData = $this->gpg->exportPublicKey($keyId);
 
-        $this->assertContains($expectedKeyData, $keyData);
+        $this->assertStringContainsString($expectedKeyData, $keyData);
     }
 
     // }}}
     // {{{ testExportPublicKeyNotFoundException()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group export
      */
     public function testExportPublicKeyNotFoundException()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $keyId = 'non-existent-key@example.com';
         $this->gpg->exportPublicKey($keyId);
     }
diff --git a/Crypt_GPG-1.6.4/tests/GeneralTest.php b/Crypt_GPG-1.6.4/tests/GeneralTest.php
index 033a27f..82e7f3d 100644
--- a/Crypt_GPG-1.6.4/tests/GeneralTest.php
+++ b/Crypt_GPG-1.6.4/tests/GeneralTest.php
@@ -59,11 +59,9 @@ class GeneralTestCase extends Crypt_GPG_TestCase
 {
     // {{{ testPublicKeyringFileException()
 
-    /**
-     * @expectedException Crypt_GPG_FileException
-     */
     public function testPublicKeyringFileException()
     {
+        $this->expectException('Crypt_GPG_FileException');
         $publicKeyringFile = $this->getTempFilename('pubring.gpg');
         new Crypt_GPG(
             array(
@@ -75,11 +73,9 @@ class GeneralTestCase extends Crypt_GPG_TestCase
     // }}}
     // {{{ testPrivateKeyringFileException()
 
-    /**
-     * @expectedException Crypt_GPG_FileException
-     */
     public function testPrivateKeyringFileException()
     {
+        $this->expectException('Crypt_GPG_FileException');
         $privateKeyringFile = $this->getTempFilename('secring.gpg');
         new Crypt_GPG(
             array(
@@ -91,11 +87,9 @@ class GeneralTestCase extends Crypt_GPG_TestCase
     // }}}
     // {{{ testTrustDatabaseFileException()
 
-    /**
-     * @expectedException Crypt_GPG_FileException
-     */
     public function testTrustDatabaseFileException()
     {
+        $this->expectException('Crypt_GPG_FileException');
         $trustDbFile = $this->getTempFilename('secring.gpg');
         new Crypt_GPG(
             array(
@@ -107,12 +101,10 @@ class GeneralTestCase extends Crypt_GPG_TestCase
     // }}}
     // {{{ testHomedirFileException_NoCreate()
 
-    /**
-     * @expectedException Crypt_GPG_FileException
-     * @expectedExceptionMessage cannot be created
-     */
     public function testHomedirFileException_NoCreate()
     {
+        $this->expectException('Crypt_GPG_FileException');
+        $this->expectExceptionMessage('cannot be created');
         if (posix_getuid() === 0) {
             $this->markTestSkipped('Root can write to any homedir.');
         }
@@ -124,12 +116,10 @@ class GeneralTestCase extends Crypt_GPG_TestCase
     // }}}
     // {{{ testHomedirFileException_NoExecute()
 
-    /**
-     * @expectedException Crypt_GPG_FileException
-     * @expectedExceptionMessage is not enterable
-     */
     public function testHomedirFileException_NoExecute()
     {
+        $this->expectException('Crypt_GPG_FileException');
+        $this->expectExceptionMessage('is not enterable');
         if (posix_getuid() === 0) {
             $this->markTestSkipped('Root can do what it wants to any homedir.');
         }
@@ -144,12 +134,10 @@ class GeneralTestCase extends Crypt_GPG_TestCase
     // }}}
     // {{{ testHomedirFileException_NoWrite()
 
-    /**
-     * @expectedException Crypt_GPG_FileException
-     * @expectedExceptionMessage is not writable
-     */
     public function testHomedirFileException_NoWrite()
     {
+        $this->expectException('Crypt_GPG_FileException');
+        $this->expectExceptionMessage('is not writable');
         if (posix_getuid() === 0) {
             $this->markTestSkipped('Root can write to any homedir.');
         }
@@ -164,22 +152,18 @@ class GeneralTestCase extends Crypt_GPG_TestCase
     // }}}
     // {{{ testBinaryPEARException()
 
-    /**
-     * @expectedException PEAR_Exception
-     */
     public function testBinaryPEARException()
     {
+        $this->expectException('PEAR_Exception');
         new Crypt_GPG(array('binary' => './non-existent-binary'));
     }
 
     // }}}
     // {{{ testGPGBinaryPEARException()
 
-    /**
-     * @expectedException PEAR_Exception
-     */
     public function testGPGBinaryPEARException()
     {
+        $this->expectException('PEAR_Exception');
         new Crypt_GPG(array('gpgBinary' => './non-existent-binary'));
     }
 
diff --git a/Crypt_GPG-1.6.4/tests/ImportKeyTest.php b/Crypt_GPG-1.6.4/tests/ImportKeyTest.php
index 53bea24..2a5ec22 100644
--- a/Crypt_GPG-1.6.4/tests/ImportKeyTest.php
+++ b/Crypt_GPG-1.6.4/tests/ImportKeyTest.php
@@ -343,12 +343,11 @@ TEXT;
     // {{{ testImportKeyNoDataException_invalid()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group string
      */
     public function testImportKeyNoDataException_invalid()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $keyData = 'Invalid OpenPGP data.';
         $this->gpg->importKey($keyData);
     }
@@ -357,12 +356,11 @@ TEXT;
     // {{{ testImportKeyNoDataException_empty()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group string
      */
     public function testImportKeyNoDataException_empty()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $keyData = '';
         $this->gpg->importKey($keyData);
     }
@@ -489,12 +487,11 @@ TEXT;
     // {{{ testImportKeyFileFileException()
 
     /**
-     * @expectedException Crypt_GPG_FileException
-     *
      * @group file
      */
     public function testImportKeyFileFileException()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // input file does not exist
         $filename =
             $this->getDataFilename('testImportKeyFileFileException.asc');
@@ -506,12 +503,11 @@ TEXT;
     // {{{ testImportKeyFileNoDataException()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group file
      */
     public function testImportKeyFileNoDataException()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $filename = $this->getDataFilename('testFileEmpty.plain');
         $this->gpg->importKeyFile($filename);
     }
diff --git a/Crypt_GPG-1.6.4/tests/KeyGeneratorTest.php b/Crypt_GPG-1.6.4/tests/KeyGeneratorTest.php
index ab08b8f..8091dfa 100644
--- a/Crypt_GPG-1.6.4/tests/KeyGeneratorTest.php
+++ b/Crypt_GPG-1.6.4/tests/KeyGeneratorTest.php
@@ -193,10 +193,13 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
         $expectedDate = 0;
         $this->generator->setExpirationDate(0);
 
-        $this->assertAttributeEquals(
+        $class = new \ReflectionObject($this->generator);
+        $prop_expirationDate = $class->getProperty('expirationDate');
+        $prop_expirationDate->setAccessible(true);
+
+        $this->assertEquals(
             $expectedDate,
-            'expirationDate',
-            $this->generator,
+            $prop_expirationDate->getValue($this->generator),
             'Setting expiration date to zero failed.'
         );
     }
@@ -212,10 +215,13 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
         $expectedDate = 2000000000;
         $this->generator->setExpirationDate(2000000000);
 
-        $this->assertAttributeEquals(
+        $class = new \ReflectionObject($this->generator);
+        $prop_expirationDate = $class->getProperty('expirationDate');
+        $prop_expirationDate->setAccessible(true);
+
+        $this->assertEquals(
             $expectedDate,
-            'expirationDate',
-            $this->generator,
+            $prop_expirationDate->getValue($this->generator),
             'Setting expiration date by integer failed.'
         );
     }
@@ -233,10 +239,13 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
         $expectedDate = 2000000000;
         $this->generator->setExpirationDate('2033-05-18T03:33:20');
 
-        $this->assertAttributeEquals(
+        $class = new \ReflectionObject($this->generator);
+        $prop_expirationDate = $class->getProperty('expirationDate');
+        $prop_expirationDate->setAccessible(true);
+
+        $this->assertEquals(
             $expectedDate,
-            'expirationDate',
-            $this->generator,
+            $prop_expirationDate->getValue($this->generator),
             'Setting expiration date by string failed.'
         );
     }
@@ -246,10 +255,10 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group mutators
-     * @expectedException InvalidArgumentException
      */
     public function testSetExpirationDate_invalid_format()
     {
+        $this->expectException('InvalidArgumentException');
         date_default_timezone_set('UTC');
 
         $this->generator->setExpirationDate('this is not a date');
@@ -260,10 +269,10 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group mutators
-     * @expectedException InvalidArgumentException
      */
     public function testSetExpirationDate_too_early_date()
     {
+        $this->expectException('InvalidArgumentException');
         $this->generator->setExpirationDate(1301088055);
     }
 
@@ -272,10 +281,10 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group mutators
-     * @expectedException InvalidArgumentException
      */
     public function testSetExpirationDate_today()
     {
+        $this->expectException('InvalidArgumentException');
         $this->generator->setExpirationDate(time());
     }
 
@@ -284,10 +293,10 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group mutators
-     * @expectedException InvalidArgumentException
      */
     public function testSetExpirationDate_too_late_date()
     {
+        $this->expectException('InvalidArgumentException');
         $this->generator->setExpirationDate(2147483648);
     }
 
@@ -302,10 +311,13 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
         $expectedPassphrase = 'test1';
         $this->generator->setPassphrase('test1');
 
-        $this->assertAttributeEquals(
+        $class = new \ReflectionObject($this->generator);
+        $prop_passphrase = $class->getProperty('passphrase');
+        $prop_passphrase->setAccessible(true);
+
+        $this->assertEquals(
             $expectedPassphrase,
-            'passphrase',
-            $this->generator,
+            $prop_passphrase->getValue($this->generator),
             'Setting passphrase failed.'
         );
     }
@@ -327,24 +339,29 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
             Crypt_GPG_SubKey::ALGORITHM_ELGAMAL_ENC_SGN
         );
 
-        $this->assertAttributeEquals(
+        $class = new \ReflectionObject($this->generator);
+        $prop_keyAlgorithm = $class->getProperty('keyAlgorithm');
+        $prop_keySize = $class->getProperty('keySize');
+        $prop_keyUsage = $class->getProperty('keyUsage');
+        $prop_keyAlgorithm->setAccessible(true);
+        $prop_keySize->setAccessible(true);
+        $prop_keyUsage->setAccessible(true);
+
+        $this->assertEquals(
             $expectedAlgorithm,
-            'keyAlgorithm',
-            $this->generator,
+            $prop_keyAlgorithm->getValue($this->generator),
             'Setting key algorithm failed.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedSize,
-            'keySize',
-            $this->generator,
+            $prop_keySize->getValue($this->generator),
             'Setting key algorithm changed key size.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedUsage,
-            'keyUsage',
-            $this->generator,
+            $prop_keyUsage->getValue($this->generator),
             'Setting key algorithm changed key usage.'
         );
     }
@@ -367,24 +384,29 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
             512
         );
 
-        $this->assertAttributeEquals(
+        $class = new \ReflectionObject($this->generator);
+        $prop_keyAlgorithm = $class->getProperty('keyAlgorithm');
+        $prop_keySize = $class->getProperty('keySize');
+        $prop_keyUsage = $class->getProperty('keyUsage');
+        $prop_keyAlgorithm->setAccessible(true);
+        $prop_keySize->setAccessible(true);
+        $prop_keyUsage->setAccessible(true);
+
+        $this->assertEquals(
             $expectedAlgorithm,
-            'keyAlgorithm',
-            $this->generator,
+            $prop_keyAlgorithm->getValue($this->generator),
             'Setting key algorithm failed.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedSize,
-            'keySize',
-            $this->generator,
+            $prop_keySize->getValue($this->generator),
             'Setting key size failed.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedUsage,
-            'keyUsage',
-            $this->generator,
+            $prop_keyUsage->getValue($this->generator),
             'Setting key algorithm and size changed key usage.'
         );
     }
@@ -411,24 +433,29 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
             | Crypt_GPG_SubKey::USAGE_ENCRYPT
         );
 
-        $this->assertAttributeEquals(
+        $class = new \ReflectionObject($this->generator);
+        $prop_keyAlgorithm = $class->getProperty('keyAlgorithm');
+        $prop_keySize = $class->getProperty('keySize');
+        $prop_keyUsage = $class->getProperty('keyUsage');
+        $prop_keyAlgorithm->setAccessible(true);
+        $prop_keySize->setAccessible(true);
+        $prop_keyUsage->setAccessible(true);
+
+        $this->assertEquals(
             $expectedAlgorithm,
-            'keyAlgorithm',
-            $this->generator,
+            $prop_keyAlgorithm->getValue($this->generator),
             'Setting key algorithm failed.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedSize,
-            'keySize',
-            $this->generator,
+            $prop_keySize->getValue($this->generator),
             'Setting key size failed.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedUsage,
-            'keyUsage',
-            $this->generator,
+            $prop_keyUsage->getValue($this->generator),
             'Setting key usage failed.'
         );
     }
@@ -438,10 +465,10 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group mutators
-     * @expectedException Crypt_GPG_InvalidKeyParamsException
      */
     public function testSetKeyParams_invalid_algorithm()
     {
+        $this->expectException('Crypt_GPG_InvalidKeyParamsException');
         $this->generator->setKeyParams(Crypt_GPG_SubKey::ALGORITHM_ELGAMAL_ENC);
     }
 
@@ -450,10 +477,10 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group mutators
-     * @expectedException Crypt_GPG_InvalidKeyParamsException
      */
     public function testSetKeyParams_invalid_dsa_usage()
     {
+        $this->expectException('Crypt_GPG_InvalidKeyParamsException');
         $this->generator->setKeyParams(
             Crypt_GPG_SubKey::ALGORITHM_DSA,
             2048,
@@ -477,24 +504,29 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
             Crypt_GPG_SubKey::ALGORITHM_ELGAMAL_ENC_SGN
         );
 
-        $this->assertAttributeEquals(
+        $class = new \ReflectionObject($this->generator);
+        $prop_subKeyAlgorithm = $class->getProperty('subKeyAlgorithm');
+        $prop_subKeySize = $class->getProperty('subKeySize');
+        $prop_subKeyUsage = $class->getProperty('subKeyUsage');
+        $prop_subKeyAlgorithm->setAccessible(true);
+        $prop_subKeySize->setAccessible(true);
+        $prop_subKeyUsage->setAccessible(true);
+
+        $this->assertEquals(
             $expectedAlgorithm,
-            'subKeyAlgorithm',
-            $this->generator,
+            $prop_subKeyAlgorithm->getValue($this->generator),
             'Setting sub-key algorithm failed.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedSize,
-            'subKeySize',
-            $this->generator,
+            $prop_subKeySize->getValue($this->generator),
             'Setting sub-key algorithm changed key size.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedUsage,
-            'subKeyUsage',
-            $this->generator,
+            $prop_subKeyUsage->getValue($this->generator),
             'Setting sub-key algorithm changed key usage.'
         );
     }
@@ -516,24 +548,29 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
             1024
         );
 
-        $this->assertAttributeEquals(
+        $class = new \ReflectionObject($this->generator);
+        $prop_subKeyAlgorithm = $class->getProperty('subKeyAlgorithm');
+        $prop_subKeySize = $class->getProperty('subKeySize');
+        $prop_subKeyUsage = $class->getProperty('subKeyUsage');
+        $prop_subKeyAlgorithm->setAccessible(true);
+        $prop_subKeySize->setAccessible(true);
+        $prop_subKeyUsage->setAccessible(true);
+
+        $this->assertEquals(
             $expectedAlgorithm,
-            'subKeyAlgorithm',
-            $this->generator,
+            $prop_subKeyAlgorithm->getValue($this->generator),
             'Setting sub-key algorithm failed.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedSize,
-            'subKeySize',
-            $this->generator,
+            $prop_subKeySize->getValue($this->generator),
             'Setting sub-key size failed.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedUsage,
-            'subKeyUsage',
-            $this->generator,
+            $prop_subKeyUsage->getValue($this->generator),
             'Setting sub-key algorithm and size changed key usage.'
         );
     }
@@ -558,24 +595,29 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
             | Crypt_GPG_SubKey::USAGE_ENCRYPT
         );
 
-        $this->assertAttributeEquals(
+        $class = new \ReflectionObject($this->generator);
+        $prop_subKeyAlgorithm = $class->getProperty('subKeyAlgorithm');
+        $prop_subKeySize = $class->getProperty('subKeySize');
+        $prop_subKeyUsage = $class->getProperty('subKeyUsage');
+        $prop_subKeyAlgorithm->setAccessible(true);
+        $prop_subKeySize->setAccessible(true);
+        $prop_subKeyUsage->setAccessible(true);
+
+        $this->assertEquals(
             $expectedAlgorithm,
-            'subKeyAlgorithm',
-            $this->generator,
+            $prop_subKeyAlgorithm->getValue($this->generator),
             'Setting sub-key algorithm failed.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedSize,
-            'subKeySize',
-            $this->generator,
+            $prop_subKeySize->getValue($this->generator),
             'Setting sub-key size failed.'
         );
 
-        $this->assertAttributeEquals(
+        $this->assertEquals(
             $expectedUsage,
-            'subKeyUsage',
-            $this->generator,
+            $prop_subKeyUsage->getValue($this->generator),
             'Setting sub-key usage failed.'
         );
     }
@@ -585,10 +627,10 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group mutators
-     * @expectedException Crypt_GPG_InvalidKeyParamsException
      */
     public function testSetSubKeyParams_invalid_elgamal_usage()
     {
+        $this->expectException('Crypt_GPG_InvalidKeyParamsException');
         $this->generator->setSubKeyParams(
             Crypt_GPG_SubKey::ALGORITHM_ELGAMAL_ENC,
             2048,
@@ -601,10 +643,10 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group mutators
-     * @expectedException Crypt_GPG_InvalidKeyParamsException
      */
     public function testSetSubKeyParams_invalid_dsa_usage()
     {
+        $this->expectException('Crypt_GPG_InvalidKeyParamsException');
         $this->generator->setSubKeyParams(
             Crypt_GPG_SubKey::ALGORITHM_DSA,
             2048,
@@ -928,10 +970,10 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group generate-key
-     * @expectedException Crypt_GPG_InvalidKeyParamsException
      */
     public function testGenerateKeyWithInvalidPrimaryKeyAlgorithm()
     {
+        $this->expectException('Crypt_GPG_InvalidKeyParamsException');
         if (!$this->config['enable-key-generation']) {
             $this->markTestSkipped(
                 'Key generation tests are disabled. To run key generation '
@@ -954,10 +996,10 @@ class KeyGeneratorTestCase extends Crypt_GPG_TestCase
 
     /**
      * @group generate-key
-     * @expectedException Crypt_GPG_InvalidKeyParamsException
      */
     public function testGenerateKeyWithInvalidSubKeyAlgorithm()
     {
+        $this->expectException('Crypt_GPG_InvalidKeyParamsException');
         if (!$this->config['enable-key-generation']) {
             $this->markTestSkipped(
                 'Key generation tests are disabled. To run key generation '
diff --git a/Crypt_GPG-1.6.4/tests/SignTest.php b/Crypt_GPG-1.6.4/tests/SignTest.php
index bdaa65c..296e69d 100644
--- a/Crypt_GPG-1.6.4/tests/SignTest.php
+++ b/Crypt_GPG-1.6.4/tests/SignTest.php
@@ -67,12 +67,11 @@ class SignTestCase extends Crypt_GPG_TestCase
     // {{{ testSignKeyNotFoundException_invalid()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testSignKeyNotFoundException_invalid()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->addSignKey('non-existent-key@example.com');
         $this->gpg->sign($data);
@@ -82,12 +81,11 @@ class SignTestCase extends Crypt_GPG_TestCase
     // {{{ testSignKeyNotFoundException_none()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testSignKeyNotFoundException_none()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->sign($data);
     }
@@ -96,12 +94,11 @@ class SignTestCase extends Crypt_GPG_TestCase
     // {{{ testSignBadPassphraseException_missing()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group string
      */
     public function testSignBadPassphraseException_missing()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->addSignKey('first-keypair@example.com');
         $this->gpg->sign($data);
@@ -111,12 +108,11 @@ class SignTestCase extends Crypt_GPG_TestCase
     // {{{ testSignBadPassphraseException_bad()
 
     /**
-     * @expectedException Crypt_GPG_BadPassphraseException
-     *
      * @group string
      */
     public function testSignBadPassphraseException_bad()
     {
+        $this->expectException('Crypt_GPG_BadPassphraseException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         $this->gpg->addSignKey('first-keypair@example.com', 'incorrect');
         $this->gpg->sign($data);
@@ -557,12 +553,11 @@ class SignTestCase extends Crypt_GPG_TestCase
     // {{{ testSignFileFileException_input()
 
     /**
-     * @expectedException Crypt_GPG_FileException
-     *
      * @group file
      */
     public function testSignFileFileException_input()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // input file does not exist
         $inputFilename =
             $this->getDataFilename('testSignFileFileFileException_input.plain');
@@ -575,12 +570,11 @@ class SignTestCase extends Crypt_GPG_TestCase
     // {{{ testSignFileFileException_output()
 
     /**
-     * @expectedException Crypt_GPG_FileException
-     *
      * @group file
      */
     public function testSignFileFileException_output()
     {
+        $this->expectException('Crypt_GPG_FileException');
         // input file is encrypted with first-keypair@example.com
         // output file does not exist
         $inputFilename  = $this->getDataFilename('testFileMedium.plain');
diff --git a/Crypt_GPG-1.6.4/tests/VerifyTest.php b/Crypt_GPG-1.6.4/tests/VerifyTest.php
index 813c62d..fe72f25 100644
--- a/Crypt_GPG-1.6.4/tests/VerifyTest.php
+++ b/Crypt_GPG-1.6.4/tests/VerifyTest.php
@@ -61,12 +61,11 @@ class VerifyTestCase extends Crypt_GPG_TestCase
     // {{{ testVerifyNoDataException_invalid()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group string
      */
     public function testVerifyNoDataException_invalid()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $signedData = 'Invalid OpenPGP data.';
         $this->gpg->verify($signedData);
     }
@@ -75,12 +74,11 @@ class VerifyTestCase extends Crypt_GPG_TestCase
     // {{{ testVerifyNoDataException_empty()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group string
      */
     public function testVerifyNoDataException_empty()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $signedData = '';
         $this->gpg->verify($signedData);
     }
@@ -89,12 +87,11 @@ class VerifyTestCase extends Crypt_GPG_TestCase
     // {{{ testVerifyKeyNotFoundException()
 
     /**
-     * @expectedException Crypt_GPG_KeyNotFoundException
-     *
      * @group string
      */
     public function testVerifyKeyNotFoundException()
     {
+        $this->expectException('Crypt_GPG_KeyNotFoundException');
         $data = 'Hello, Alice! Goodbye, Bob!';
         // {{{ detached signature
         $detachedSignature = <<<TEXT
@@ -824,12 +821,11 @@ TEXT;
     // {{{ testVerifyFileFileException()
 
     /**
-     * @expectedException Crypt_GPG_FileException
-     *
      * @group file
      */
     public function testVerifyFileFileException()
     {
+        $this->expectException('Crypt_GPG_FileException');
         $filename = './non-existent/testVerifyFileFileException.asc';
         $this->gpg->verifyFile($filename);
     }
@@ -838,12 +834,11 @@ TEXT;
     // {{{ testVerifyFileNoDataException()
 
     /**
-     * @expectedException Crypt_GPG_NoDataException
-     *
      * @group file
      */
     public function testVerifyFileNoDataException()
     {
+        $this->expectException('Crypt_GPG_NoDataException');
         $filename = $this->getDataFilename('testFileEmpty.plain');
         $this->gpg->verifyFile($filename);
     }