diff --git a/external-sop/build.gradle b/external-sop/build.gradle
index 37bd8f3..bd45c71 100644
--- a/external-sop/build.gradle
+++ b/external-sop/build.gradle
@@ -20,6 +20,7 @@ dependencies {
     testImplementation "com.google.code.gson:gson:2.10.1"
 
     api project(":sop-java")
+    testImplementation(testFixtures(project(":sop-java")))
 
     api "org.slf4j:slf4j-api:$slf4jVersion"
     testImplementation "ch.qos.logback:logback-classic:$logbackVersion"
diff --git a/external-sop/src/test/java/sop/external/ExternalArmorDearmorRoundTripTest.java b/external-sop/src/test/java/sop/external/ExternalArmorDearmorRoundTripTest.java
index dec48f4..f1d29e6 100644
--- a/external-sop/src/test/java/sop/external/ExternalArmorDearmorRoundTripTest.java
+++ b/external-sop/src/test/java/sop/external/ExternalArmorDearmorRoundTripTest.java
@@ -8,28 +8,29 @@ import org.junit.jupiter.api.condition.EnabledIf;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import sop.SOP;
+import sop.testing.TestData;
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static sop.external.JUtils.arrayStartsWith;
-import static sop.external.JUtils.assertArrayStartsWith;
-import static sop.external.JUtils.assertAsciiArmorEquals;
+import static sop.testing.JUtils.arrayStartsWith;
+import static sop.testing.JUtils.assertArrayEndsWithIgnoreNewlines;
+import static sop.testing.JUtils.assertArrayStartsWith;
+import static sop.testing.JUtils.assertAsciiArmorEquals;
+import static sop.testing.TestData.BEGIN_PGP_MESSAGE;
+import static sop.testing.TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK;
+import static sop.testing.TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK;
+import static sop.testing.TestData.BEGIN_PGP_SIGNATURE;
+import static sop.testing.TestData.END_PGP_MESSAGE;
+import static sop.testing.TestData.END_PGP_PRIVATE_KEY_BLOCK;
+import static sop.testing.TestData.END_PGP_PUBLIC_KEY_BLOCK;
+import static sop.testing.TestData.END_PGP_SIGNATURE;
 
 @EnabledIf("sop.external.AbstractExternalSOPTest#hasBackends")
 public class ExternalArmorDearmorRoundTripTest extends AbstractExternalSOPTest {
 
-    private static final String BEGIN_PGP_PRIVATE_KEY_BLOCK = "-----BEGIN PGP PRIVATE KEY BLOCK-----\n";
-    private static final byte[] BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES = BEGIN_PGP_PRIVATE_KEY_BLOCK.getBytes(StandardCharsets.UTF_8);
-    private static final String BEGIN_PGP_PUBLIC_KEY_BLOCK = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n";
-    private static final byte[] BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES = BEGIN_PGP_PUBLIC_KEY_BLOCK.getBytes(StandardCharsets.UTF_8);
-    private static final String BEGIN_PGP_MESSAGE = "-----BEGIN PGP MESSAGE-----\n";
-    private static final byte[] BEGIN_PGP_MESSAGE_BYTES = BEGIN_PGP_MESSAGE.getBytes(StandardCharsets.UTF_8);
-    private static final String BEGIN_PGP_SIGNATURE = "-----BEGIN PGP SIGNATURE-----\n";
-    private static final byte[] BEGIN_PGP_SIGNATURE_BYTES = BEGIN_PGP_SIGNATURE.getBytes(StandardCharsets.UTF_8);
-
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void dearmorArmorAliceKey(SOP sop) throws IOException {
@@ -39,14 +40,16 @@ public class ExternalArmorDearmorRoundTripTest extends AbstractExternalSOPTest {
                 .data(aliceKey)
                 .getBytes();
 
-        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES));
+        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PRIVATE_KEY_BLOCK));
 
         byte[] armored = sop.armor()
                 .data(dearmored)
                 .getBytes();
 
-        assertArrayStartsWith(armored, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES);
-        assertAsciiArmorEquals(aliceKey, armored);
+        assertArrayStartsWith(armored, BEGIN_PGP_PRIVATE_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(armored, END_PGP_PRIVATE_KEY_BLOCK);
+
+        // assertAsciiArmorEquals(aliceKey, armored);
     }
 
     @ParameterizedTest
@@ -58,14 +61,16 @@ public class ExternalArmorDearmorRoundTripTest extends AbstractExternalSOPTest {
                 .data(aliceCert)
                 .getBytes();
 
-        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES));
+        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PUBLIC_KEY_BLOCK));
 
         byte[] armored = sop.armor()
                 .data(dearmored)
                 .getBytes();
 
-        assertArrayStartsWith(armored, BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES);
-        assertAsciiArmorEquals(aliceCert, armored);
+        assertArrayStartsWith(armored, BEGIN_PGP_PUBLIC_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(armored, END_PGP_PUBLIC_KEY_BLOCK);
+
+        // assertAsciiArmorEquals(aliceCert, armored);
     }
 
     @ParameterizedTest
@@ -77,14 +82,16 @@ public class ExternalArmorDearmorRoundTripTest extends AbstractExternalSOPTest {
                 .data(bobKey)
                 .getBytes();
 
-        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES));
+        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PRIVATE_KEY_BLOCK));
 
         byte[] armored = sop.armor()
                 .data(dearmored)
                 .getBytes();
 
-        assertArrayStartsWith(armored, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES);
-        assertAsciiArmorEquals(bobKey, armored);
+        assertArrayStartsWith(armored, BEGIN_PGP_PRIVATE_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(armored, END_PGP_PRIVATE_KEY_BLOCK);
+
+        // assertAsciiArmorEquals(bobKey, armored);
     }
 
     @ParameterizedTest
@@ -96,14 +103,16 @@ public class ExternalArmorDearmorRoundTripTest extends AbstractExternalSOPTest {
                 .data(bobCert)
                 .getBytes();
 
-        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES));
+        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PUBLIC_KEY_BLOCK));
 
         byte[] armored = sop.armor()
                 .data(dearmored)
                 .getBytes();
 
-        assertArrayStartsWith(armored, BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES);
-        assertAsciiArmorEquals(bobCert, armored);
+        assertArrayStartsWith(armored, BEGIN_PGP_PUBLIC_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(armored, END_PGP_PUBLIC_KEY_BLOCK);
+
+        // assertAsciiArmorEquals(bobCert, armored);
     }
 
     @ParameterizedTest
@@ -115,14 +124,16 @@ public class ExternalArmorDearmorRoundTripTest extends AbstractExternalSOPTest {
                 .data(carolKey)
                 .getBytes();
 
-        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES));
+        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PRIVATE_KEY_BLOCK));
 
         byte[] armored = sop.armor()
                 .data(dearmored)
                 .getBytes();
 
-        assertArrayStartsWith(armored, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES);
-        assertAsciiArmorEquals(carolKey, armored);
+        assertArrayStartsWith(armored, BEGIN_PGP_PRIVATE_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(armored, END_PGP_PRIVATE_KEY_BLOCK);
+
+        // assertAsciiArmorEquals(carolKey, armored);
     }
 
     @ParameterizedTest
@@ -134,14 +145,16 @@ public class ExternalArmorDearmorRoundTripTest extends AbstractExternalSOPTest {
                 .data(carolCert)
                 .getBytes();
 
-        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES));
+        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_PUBLIC_KEY_BLOCK));
 
         byte[] armored = sop.armor()
                 .data(dearmored)
                 .getBytes();
 
-        assertArrayStartsWith(armored, BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES);
-        assertAsciiArmorEquals(carolCert, armored);
+        assertArrayStartsWith(armored, BEGIN_PGP_PUBLIC_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(armored, END_PGP_PUBLIC_KEY_BLOCK);
+
+        // assertAsciiArmorEquals(carolCert, armored);
     }
 
     @ParameterizedTest
@@ -159,14 +172,16 @@ public class ExternalArmorDearmorRoundTripTest extends AbstractExternalSOPTest {
                 .data(message)
                 .getBytes();
 
-        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_MESSAGE_BYTES));
+        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_MESSAGE));
 
         byte[] armored = sop.armor()
                 .data(dearmored)
                 .getBytes();
 
-        assertArrayStartsWith(armored, BEGIN_PGP_MESSAGE_BYTES);
-        assertAsciiArmorEquals(message, armored);
+        assertArrayStartsWith(armored, BEGIN_PGP_MESSAGE);
+        assertArrayEndsWithIgnoreNewlines(armored, END_PGP_MESSAGE);
+
+        // assertAsciiArmorEquals(message, armored);
     }
 
     @ParameterizedTest
@@ -185,13 +200,15 @@ public class ExternalArmorDearmorRoundTripTest extends AbstractExternalSOPTest {
                 .data(signature)
                 .getBytes();
 
-        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_SIGNATURE_BYTES));
+        assertFalse(arrayStartsWith(dearmored, BEGIN_PGP_SIGNATURE));
 
         byte[] armored = sop.armor()
                 .data(dearmored)
                 .getBytes();
 
-        assertArrayStartsWith(armored, BEGIN_PGP_SIGNATURE_BYTES);
+        assertArrayStartsWith(armored, BEGIN_PGP_SIGNATURE);
+        assertArrayEndsWithIgnoreNewlines(armored, END_PGP_SIGNATURE);
+
         assertAsciiArmorEquals(signature, armored);
     }
 
diff --git a/external-sop/src/test/java/sop/external/ExternalDecryptWithSessionKeyTest.java b/external-sop/src/test/java/sop/external/ExternalDecryptWithSessionKeyTest.java
index 8a7ff56..b75ec04 100644
--- a/external-sop/src/test/java/sop/external/ExternalDecryptWithSessionKeyTest.java
+++ b/external-sop/src/test/java/sop/external/ExternalDecryptWithSessionKeyTest.java
@@ -17,6 +17,8 @@ import java.nio.charset.StandardCharsets;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static sop.testing.TestData.ALICE_KEY;
+import static sop.testing.TestData.PLAINTEXT;
 
 @EnabledIf("sop.external.AbstractExternalSOPTest#hasBackends")
 public class ExternalDecryptWithSessionKeyTest extends AbstractExternalSOPTest {
@@ -35,13 +37,13 @@ public class ExternalDecryptWithSessionKeyTest extends AbstractExternalSOPTest {
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void testDecryptAndExtractSessionKey(SOP sop) throws IOException {
         ByteArrayAndResult<DecryptionResult> bytesAndResult = sop.decrypt()
-                .withKey(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .withKey(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .ciphertext(CIPHERTEXT.getBytes(StandardCharsets.UTF_8))
                 .toByteArrayAndResult();
 
         assertEquals(SESSION_KEY, bytesAndResult.getResult().getSessionKey().get().toString());
 
-        assertArrayEquals("Hello, World!\n".getBytes(StandardCharsets.UTF_8), bytesAndResult.getBytes());
+        assertArrayEquals(PLAINTEXT.getBytes(StandardCharsets.UTF_8), bytesAndResult.getBytes());
     }
 
     @ParameterizedTest
@@ -53,6 +55,6 @@ public class ExternalDecryptWithSessionKeyTest extends AbstractExternalSOPTest {
                 .toByteArrayAndResult()
                 .getBytes();
 
-        assertArrayEquals("Hello, World!\n".getBytes(StandardCharsets.UTF_8), decrypted);
+        assertArrayEquals(PLAINTEXT.getBytes(StandardCharsets.UTF_8), decrypted);
     }
 }
diff --git a/external-sop/src/test/java/sop/external/ExternalDetachedSignVerifyRoundTripTest.java b/external-sop/src/test/java/sop/external/ExternalDetachedSignVerifyRoundTripTest.java
index ddee99a..e08d7a9 100644
--- a/external-sop/src/test/java/sop/external/ExternalDetachedSignVerifyRoundTripTest.java
+++ b/external-sop/src/test/java/sop/external/ExternalDetachedSignVerifyRoundTripTest.java
@@ -19,127 +19,143 @@ import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static sop.external.JUtils.assertArrayStartsWith;
-import static sop.external.JUtils.assertSignedBy;
+import static sop.testing.JUtils.assertArrayStartsWith;
+import static sop.testing.JUtils.assertSignedBy;
+import static sop.testing.TestData.ALICE_CERT;
+import static sop.testing.TestData.ALICE_DETACHED_SIGNED_MESSAGE;
+import static sop.testing.TestData.ALICE_DETACHED_SIGNED_MESSAGE_DATE;
+import static sop.testing.TestData.ALICE_KEY;
+import static sop.testing.TestData.ALICE_PRIMARY_FINGERPRINT;
+import static sop.testing.TestData.ALICE_SIGNING_FINGERPRINT;
+import static sop.testing.TestData.BEGIN_PGP_SIGNATURE;
+import static sop.testing.TestData.BOB_CERT;
+import static sop.testing.TestData.BOB_KEY;
+import static sop.testing.TestData.BOB_PRIMARY_FINGERPRINT;
+import static sop.testing.TestData.BOB_SIGNING_FINGERPRINT;
+import static sop.testing.TestData.CAROL_CERT;
+import static sop.testing.TestData.CAROL_KEY;
+import static sop.testing.TestData.CAROL_PRIMARY_FINGERPRINT;
+import static sop.testing.TestData.CAROL_SIGNING_FINGERPRINT;
+import static sop.testing.TestData.PASSWORD;
+import static sop.testing.TestData.PASSWORD_PROTECTED_CERT;
+import static sop.testing.TestData.PASSWORD_PROTECTED_KEY;
+import static sop.testing.TestData.PLAINTEXT;
 
 @EnabledIf("sop.external.AbstractExternalSOPTest#hasBackends")
 public class ExternalDetachedSignVerifyRoundTripTest extends AbstractExternalSOPTest {
 
-    private static final String BEGIN_PGP_SIGNATURE = "-----BEGIN PGP SIGNATURE-----\n";
-    private static final byte[] BEGIN_PGP_SIGNATURE_BYTES = BEGIN_PGP_SIGNATURE.getBytes(StandardCharsets.UTF_8);
-
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void signVerifyWithAliceKey(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] signature = sop.detachedSign()
-                .key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .toByteArrayAndResult()
                 .getBytes();
 
         List<Verification> verificationList = sop.detachedVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .signatures(signature)
                 .data(message);
 
         assertFalse(verificationList.isEmpty());
-        assertSignedBy(verificationList, TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);
+        assertSignedBy(verificationList, ALICE_SIGNING_FINGERPRINT, ALICE_PRIMARY_FINGERPRINT);
     }
 
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void signVerifyTextModeWithAliceKey(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] signature = sop.detachedSign()
-                .key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .mode(SignAs.Text)
                 .data(message)
                 .toByteArrayAndResult()
                 .getBytes();
 
         List<Verification> verificationList = sop.detachedVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .signatures(signature)
                 .data(message);
 
         assertFalse(verificationList.isEmpty());
-        assertSignedBy(verificationList, TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);
+        assertSignedBy(verificationList, ALICE_SIGNING_FINGERPRINT, ALICE_PRIMARY_FINGERPRINT);
     }
 
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void verifyKnownMessageWithAliceCert(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
-        byte[] signature = TestData.ALICE_DETACHED_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] signature = ALICE_DETACHED_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);
 
         List<Verification> verificationList = sop.detachedVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .signatures(signature)
                 .data(message);
 
         assertFalse(verificationList.isEmpty());
-        assertSignedBy(verificationList, TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT, TestData.ALICE_DETACHED_SIGNED_MESSAGE_DATE);
+        assertSignedBy(verificationList, ALICE_SIGNING_FINGERPRINT, ALICE_PRIMARY_FINGERPRINT, ALICE_DETACHED_SIGNED_MESSAGE_DATE);
     }
 
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void signVerifyWithBobKey(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] signature = sop.detachedSign()
-                .key(TestData.BOB_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(BOB_KEY.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .toByteArrayAndResult()
                 .getBytes();
 
         List<Verification> verificationList = sop.detachedVerify()
-                .cert(TestData.BOB_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(BOB_CERT.getBytes(StandardCharsets.UTF_8))
                 .signatures(signature)
                 .data(message);
 
         assertFalse(verificationList.isEmpty());
-        assertSignedBy(verificationList, TestData.BOB_SIGNING_FINGERPRINT, TestData.BOB_PRIMARY_FINGERPRINT);
+        assertSignedBy(verificationList, BOB_SIGNING_FINGERPRINT, BOB_PRIMARY_FINGERPRINT);
     }
 
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void signVerifyWithCarolKey(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] signature = sop.detachedSign()
-                .key(TestData.CAROL_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(CAROL_KEY.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .toByteArrayAndResult()
                 .getBytes();
 
         List<Verification> verificationList = sop.detachedVerify()
-                .cert(TestData.CAROL_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(CAROL_CERT.getBytes(StandardCharsets.UTF_8))
                 .signatures(signature)
                 .data(message);
 
         assertFalse(verificationList.isEmpty());
-        assertSignedBy(verificationList, TestData.CAROL_SIGNING_FINGERPRINT, TestData.CAROL_PRIMARY_FINGERPRINT);
+        assertSignedBy(verificationList, CAROL_SIGNING_FINGERPRINT, CAROL_PRIMARY_FINGERPRINT);
     }
 
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void signVerifyWithEncryptedKey(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] signature = sop.detachedSign()
-                .key(TestData.PASSWORD_PROTECTED_KEY.getBytes(StandardCharsets.UTF_8))
-                .withKeyPassword(TestData.PASSWORD)
+                .key(PASSWORD_PROTECTED_KEY.getBytes(StandardCharsets.UTF_8))
+                .withKeyPassword(PASSWORD)
                 .data(message)
                 .toByteArrayAndResult()
                 .getBytes();
 
-        assertArrayStartsWith(signature, BEGIN_PGP_SIGNATURE_BYTES);
+        assertArrayStartsWith(signature, BEGIN_PGP_SIGNATURE);
 
         List<Verification> verificationList = sop.detachedVerify()
-                .cert(TestData.PASSWORD_PROTECTED_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(PASSWORD_PROTECTED_CERT.getBytes(StandardCharsets.UTF_8))
                 .signatures(signature)
                 .data(message);
 
@@ -149,10 +165,10 @@ public class ExternalDetachedSignVerifyRoundTripTest extends AbstractExternalSOP
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void signArmorVerifyWithBobKey(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] signature = sop.detachedSign()
-                .key(TestData.BOB_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(BOB_KEY.getBytes(StandardCharsets.UTF_8))
                 .noArmor()
                 .data(message)
                 .toByteArrayAndResult()
@@ -163,24 +179,23 @@ public class ExternalDetachedSignVerifyRoundTripTest extends AbstractExternalSOP
                 .getBytes();
 
         List<Verification> verificationList = sop.detachedVerify()
-                .cert(TestData.BOB_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(BOB_CERT.getBytes(StandardCharsets.UTF_8))
                 .signatures(armored)
                 .data(message);
 
         assertFalse(verificationList.isEmpty());
-        assertSignedBy(verificationList, TestData.BOB_SIGNING_FINGERPRINT, TestData.BOB_PRIMARY_FINGERPRINT);
+        assertSignedBy(verificationList, BOB_SIGNING_FINGERPRINT, BOB_PRIMARY_FINGERPRINT);
     }
 
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void verifyNotAfterThrowsNoSignature(SOP sop) {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
-        byte[] signature = TestData.ALICE_DETACHED_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);
-        Date signatureDate = TestData.ALICE_DETACHED_SIGNED_MESSAGE_DATE;
-        Date beforeSignature = new Date(signatureDate.getTime() - 1000); // 1 sec before sig
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] signature = ALICE_DETACHED_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);
+        Date beforeSignature = new Date(ALICE_DETACHED_SIGNED_MESSAGE_DATE.getTime() - 1000); // 1 sec before sig
 
         assertThrows(SOPGPException.NoSignature.class, () -> sop.detachedVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .notAfter(beforeSignature)
                 .signatures(signature)
                 .data(message));
@@ -189,13 +204,12 @@ public class ExternalDetachedSignVerifyRoundTripTest extends AbstractExternalSOP
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void verifyNotBeforeThrowsNoSignature(SOP sop) {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
-        byte[] signature = TestData.ALICE_DETACHED_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);
-        Date signatureDate = TestData.ALICE_DETACHED_SIGNED_MESSAGE_DATE;
-        Date afterSignature = new Date(signatureDate.getTime() + 1000); // 1 sec after sig
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] signature = ALICE_DETACHED_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);
+        Date afterSignature = new Date(ALICE_DETACHED_SIGNED_MESSAGE_DATE.getTime() + 1000); // 1 sec after sig
 
         assertThrows(SOPGPException.NoSignature.class, () -> sop.detachedVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .notBefore(afterSignature)
                 .signatures(signature)
                 .data(message));
@@ -207,8 +221,8 @@ public class ExternalDetachedSignVerifyRoundTripTest extends AbstractExternalSOP
     public void signVerifyWithEncryptedKeyWithoutPassphraseFails(SOP sop) {
         assertThrows(SOPGPException.KeyIsProtected.class, () ->
                 sop.detachedSign()
-                        .key(TestData.PASSWORD_PROTECTED_KEY.getBytes(StandardCharsets.UTF_8))
-                        .data(TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8))
+                        .key(PASSWORD_PROTECTED_KEY.getBytes(StandardCharsets.UTF_8))
+                        .data(PLAINTEXT.getBytes(StandardCharsets.UTF_8))
                         .toByteArrayAndResult()
                         .getBytes());
     }
@@ -217,19 +231,19 @@ public class ExternalDetachedSignVerifyRoundTripTest extends AbstractExternalSOP
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void signWithProtectedKeyAndMultiplePassphrasesTest(SOP sop)
             throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] signature = sop.sign()
-                .key(TestData.PASSWORD_PROTECTED_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(PASSWORD_PROTECTED_KEY.getBytes(StandardCharsets.UTF_8))
                 .withKeyPassword("wrong")
-                .withKeyPassword(TestData.PASSWORD) // correct
+                .withKeyPassword(PASSWORD) // correct
                 .withKeyPassword("wrong2")
                 .data(message)
                 .toByteArrayAndResult()
                 .getBytes();
 
         assertFalse(sop.verify()
-                .cert(TestData.PASSWORD_PROTECTED_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(PASSWORD_PROTECTED_CERT.getBytes(StandardCharsets.UTF_8))
                 .signatures(signature)
                 .data(message)
                 .isEmpty());
@@ -238,11 +252,11 @@ public class ExternalDetachedSignVerifyRoundTripTest extends AbstractExternalSOP
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void verifyMissingCertCausesMissingArg(SOP sop) {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         assertThrows(SOPGPException.MissingArg.class, () ->
                 sop.verify()
-                        .signatures(TestData.ALICE_DETACHED_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8))
+                        .signatures(ALICE_DETACHED_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8))
                         .data(message));
     }
 
diff --git a/external-sop/src/test/java/sop/external/ExternalEncryptDecryptRoundTripTest.java b/external-sop/src/test/java/sop/external/ExternalEncryptDecryptRoundTripTest.java
index 4692f21..fa5f2a8 100644
--- a/external-sop/src/test/java/sop/external/ExternalEncryptDecryptRoundTripTest.java
+++ b/external-sop/src/test/java/sop/external/ExternalEncryptDecryptRoundTripTest.java
@@ -25,7 +25,16 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static sop.testing.JUtils.assertSignedBy;
+import static sop.testing.TestData.ALICE_CERT;
+import static sop.testing.TestData.ALICE_KEY;
+import static sop.testing.TestData.ALICE_PRIMARY_FINGERPRINT;
+import static sop.testing.TestData.ALICE_SIGNING_FINGERPRINT;
+import static sop.testing.TestData.BOB_CERT;
+import static sop.testing.TestData.BOB_KEY;
+import static sop.testing.TestData.CAROL_CERT;
+import static sop.testing.TestData.CAROL_KEY;
+import static sop.testing.TestData.PLAINTEXT;
 
 @EnabledIf("sop.external.AbstractExternalSOPTest#hasBackends")
 public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest {
@@ -33,7 +42,7 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void encryptDecryptRoundTripPasswordTest(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
         byte[] ciphertext = sop.encrypt()
                 .withPassword("sw0rdf1sh")
                 .plaintext(message)
@@ -51,14 +60,14 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void encryptDecryptRoundTripAliceTest(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
         byte[] ciphertext = sop.encrypt()
-                .withCert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .withCert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .plaintext(message)
                 .getBytes();
 
         ByteArrayAndResult<DecryptionResult> bytesAndResult = sop.decrypt()
-                .withKey(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .withKey(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .ciphertext(ciphertext)
                 .toByteArrayAndResult();
 
@@ -72,14 +81,14 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void encryptDecryptRoundTripBobTest(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
         byte[] ciphertext = sop.encrypt()
-                .withCert(TestData.BOB_CERT.getBytes(StandardCharsets.UTF_8))
+                .withCert(BOB_CERT.getBytes(StandardCharsets.UTF_8))
                 .plaintext(message)
                 .getBytes();
 
         byte[] plaintext = sop.decrypt()
-                .withKey(TestData.BOB_KEY.getBytes(StandardCharsets.UTF_8))
+                .withKey(BOB_KEY.getBytes(StandardCharsets.UTF_8))
                 .ciphertext(ciphertext)
                 .toByteArrayAndResult()
                 .getBytes();
@@ -90,14 +99,14 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void encryptDecryptRoundTripCarolTest(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
         byte[] ciphertext = sop.encrypt()
-                .withCert(TestData.CAROL_CERT.getBytes(StandardCharsets.UTF_8))
+                .withCert(CAROL_CERT.getBytes(StandardCharsets.UTF_8))
                 .plaintext(message)
                 .getBytes();
 
         byte[] plaintext = sop.decrypt()
-                .withKey(TestData.CAROL_KEY.getBytes(StandardCharsets.UTF_8))
+                .withKey(CAROL_KEY.getBytes(StandardCharsets.UTF_8))
                 .ciphertext(ciphertext)
                 .toByteArrayAndResult()
                 .getBytes();
@@ -108,9 +117,9 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void encryptNoArmorThenArmorThenDecryptRoundTrip(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
         byte[] ciphertext = sop.encrypt()
-                .withCert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .withCert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .noArmor()
                 .plaintext(message)
                 .getBytes();
@@ -120,7 +129,7 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
                 .getBytes();
 
         ByteArrayAndResult<DecryptionResult> bytesAndResult = sop.decrypt()
-                .withKey(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .withKey(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .ciphertext(armored)
                 .toByteArrayAndResult();
 
@@ -131,16 +140,16 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void encryptSignDecryptVerifyRoundTripAliceTest(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
         byte[] ciphertext = sop.encrypt()
-                .withCert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
-                .signWith(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .withCert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .signWith(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .plaintext(message)
                 .getBytes();
 
         ByteArrayAndResult<DecryptionResult> bytesAndResult = sop.decrypt()
-                .withKey(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
-                .verifyWithCert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .withKey(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .verifyWithCert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .ciphertext(ciphertext)
                 .toByteArrayAndResult();
 
@@ -151,23 +160,23 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
         assertNotNull(result.getSessionKey().get());
         List<Verification> verificationList = result.getVerifications();
         assertEquals(1, verificationList.size());
-        assertTrue(verificationList.get(0).toString().contains("EB85BB5FA33A75E15E944E63F231550C4F47E38E EB85BB5FA33A75E15E944E63F231550C4F47E38E"));
+        assertSignedBy(verificationList, ALICE_SIGNING_FINGERPRINT, ALICE_PRIMARY_FINGERPRINT);
     }
 
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void encryptSignAsTextDecryptVerifyRoundTripAliceTest(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
         byte[] ciphertext = sop.encrypt()
-                .withCert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
-                .signWith(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .withCert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .signWith(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .mode(EncryptAs.Text)
                 .plaintext(message)
                 .getBytes();
 
         ByteArrayAndResult<DecryptionResult> bytesAndResult = sop.decrypt()
-                .withKey(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
-                .verifyWithCert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .withKey(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .verifyWithCert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .ciphertext(ciphertext)
                 .toByteArrayAndResult();
 
@@ -178,7 +187,7 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
         assertNotNull(result.getSessionKey().get());
         List<Verification> verificationList = result.getVerifications();
         assertEquals(1, verificationList.size());
-        assertTrue(verificationList.get(0).toString().contains("EB85BB5FA33A75E15E944E63F231550C4F47E38E EB85BB5FA33A75E15E944E63F231550C4F47E38E"));
+        assertSignedBy(verificationList, ALICE_SIGNING_FINGERPRINT, ALICE_PRIMARY_FINGERPRINT);
     }
 
     @ParameterizedTest
@@ -234,8 +243,8 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
 
         assertThrows(SOPGPException.NoSignature.class, () -> {
             ByteArrayAndResult<DecryptionResult> bytesAndResult = sop.decrypt()
-                    .withKey(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
-                    .verifyWithCert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                    .withKey(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                    .verifyWithCert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                     .verifyNotAfter(beforeSignature)
                     .ciphertext(message)
                     .toByteArrayAndResult();
@@ -267,8 +276,8 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
 
         assertThrows(SOPGPException.NoSignature.class, () -> {
             ByteArrayAndResult<DecryptionResult> bytesAndResult = sop.decrypt()
-                    .withKey(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
-                    .verifyWithCert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                    .withKey(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                    .verifyWithCert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                     .verifyNotBefore(afterSignature)
                     .ciphertext(message)
                     .toByteArrayAndResult();
@@ -282,7 +291,7 @@ public class ExternalEncryptDecryptRoundTripTest extends AbstractExternalSOPTest
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void missingArgsTest(SOP sop) {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         assertThrows(SOPGPException.MissingArg.class, () -> sop.encrypt()
                 .plaintext(message)
diff --git a/external-sop/src/test/java/sop/external/ExternalExtractCertTest.java b/external-sop/src/test/java/sop/external/ExternalExtractCertTest.java
index 19866ee..53d7e6d 100644
--- a/external-sop/src/test/java/sop/external/ExternalExtractCertTest.java
+++ b/external-sop/src/test/java/sop/external/ExternalExtractCertTest.java
@@ -8,22 +8,23 @@ import org.junit.jupiter.api.condition.EnabledIf;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import sop.SOP;
+import sop.testing.TestData;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static sop.external.JUtils.arrayStartsWith;
-import static sop.external.JUtils.assertArrayStartsWith;
-import static sop.external.JUtils.assertAsciiArmorEquals;
+import static sop.testing.JUtils.arrayStartsWith;
+import static sop.testing.JUtils.assertArrayEndsWithIgnoreNewlines;
+import static sop.testing.JUtils.assertArrayStartsWith;
+import static sop.testing.JUtils.assertAsciiArmorEquals;
+import static sop.testing.TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK;
+import static sop.testing.TestData.END_PGP_PUBLIC_KEY_BLOCK;
 
 @EnabledIf("sop.external.AbstractExternalSOPTest#hasBackends")
 public class ExternalExtractCertTest extends AbstractExternalSOPTest {
 
-    private static final String BEGIN_PGP_PUBLIC_KEY_BLOCK = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n";
-    private static final byte[] BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES = BEGIN_PGP_PUBLIC_KEY_BLOCK.getBytes(StandardCharsets.UTF_8);
-
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void extractArmoredCertFromArmoredKeyTest(SOP sop) throws IOException {
@@ -33,7 +34,8 @@ public class ExternalExtractCertTest extends AbstractExternalSOPTest {
                 .getInputStream();
 
         byte[] cert = sop.extractCert().key(keyIn).getBytes();
-        assertArrayStartsWith(cert, BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES);
+        assertArrayStartsWith(cert, BEGIN_PGP_PUBLIC_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(cert, END_PGP_PUBLIC_KEY_BLOCK);
     }
 
     @ParameterizedTest
@@ -76,7 +78,7 @@ public class ExternalExtractCertTest extends AbstractExternalSOPTest {
                 .key(keyIn)
                 .getBytes();
 
-        assertFalse(arrayStartsWith(cert, BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES));
+        assertFalse(arrayStartsWith(cert, BEGIN_PGP_PUBLIC_KEY_BLOCK));
     }
 
     @ParameterizedTest
@@ -92,7 +94,8 @@ public class ExternalExtractCertTest extends AbstractExternalSOPTest {
                 .key(keyIn)
                 .getBytes();
 
-        assertArrayStartsWith(cert, BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES);
+        assertArrayStartsWith(cert, BEGIN_PGP_PUBLIC_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(cert, END_PGP_PUBLIC_KEY_BLOCK);
     }
 
     @ParameterizedTest
@@ -109,6 +112,6 @@ public class ExternalExtractCertTest extends AbstractExternalSOPTest {
                 .key(keyIn)
                 .getBytes();
 
-        assertFalse(arrayStartsWith(cert, BEGIN_PGP_PUBLIC_KEY_BLOCK_BYTES));
+        assertFalse(arrayStartsWith(cert, BEGIN_PGP_PUBLIC_KEY_BLOCK));
     }
 }
diff --git a/external-sop/src/test/java/sop/external/ExternalGenerateKeyTest.java b/external-sop/src/test/java/sop/external/ExternalGenerateKeyTest.java
index 2525014..606efab 100644
--- a/external-sop/src/test/java/sop/external/ExternalGenerateKeyTest.java
+++ b/external-sop/src/test/java/sop/external/ExternalGenerateKeyTest.java
@@ -8,21 +8,19 @@ import org.junit.jupiter.api.condition.EnabledIf;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import sop.SOP;
+import sop.testing.JUtils;
 
 import java.io.IOException;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static sop.external.JUtils.assertArrayStartsWith;
+import static sop.testing.JUtils.assertArrayEndsWithIgnoreNewlines;
+import static sop.testing.JUtils.assertArrayStartsWith;
+import static sop.testing.TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK;
+import static sop.testing.TestData.END_PGP_PRIVATE_KEY_BLOCK;
 
 @EnabledIf("sop.external.AbstractExternalSOPTest#hasBackends")
 public class ExternalGenerateKeyTest extends AbstractExternalSOPTest {
 
-    private static final Charset UTF8 = StandardCharsets.UTF_8;
-    private static final String BEGIN_PGP_PRIVATE_KEY_BLOCK = "-----BEGIN PGP PRIVATE KEY BLOCK-----\n";
-    byte[] BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES = BEGIN_PGP_PRIVATE_KEY_BLOCK.getBytes(UTF8);
-
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void generateKeyTest(SOP sop) throws IOException {
@@ -31,7 +29,8 @@ public class ExternalGenerateKeyTest extends AbstractExternalSOPTest {
                 .generate()
                 .getBytes();
 
-        assertArrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES);
+        assertArrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(key, END_PGP_PRIVATE_KEY_BLOCK);
     }
 
     @ParameterizedTest
@@ -43,7 +42,7 @@ public class ExternalGenerateKeyTest extends AbstractExternalSOPTest {
                 .generate()
                 .getBytes();
 
-        assertFalse(JUtils.arrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES));
+        assertFalse(JUtils.arrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK));
     }
 
     @ParameterizedTest
@@ -55,7 +54,8 @@ public class ExternalGenerateKeyTest extends AbstractExternalSOPTest {
                 .generate()
                 .getBytes();
 
-        assertArrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES);
+        assertArrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(key, END_PGP_PRIVATE_KEY_BLOCK);
     }
 
     @ParameterizedTest
@@ -65,7 +65,8 @@ public class ExternalGenerateKeyTest extends AbstractExternalSOPTest {
                 .generate()
                 .getBytes();
 
-        assertArrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES);
+        assertArrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(key, END_PGP_PRIVATE_KEY_BLOCK);
     }
 
     @ParameterizedTest
@@ -77,7 +78,8 @@ public class ExternalGenerateKeyTest extends AbstractExternalSOPTest {
                 .generate()
                 .getBytes();
 
-        assertArrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES);
+        assertArrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(key, END_PGP_PRIVATE_KEY_BLOCK);
     }
 
     @ParameterizedTest
@@ -90,6 +92,7 @@ public class ExternalGenerateKeyTest extends AbstractExternalSOPTest {
                 .generate()
                 .getBytes();
 
-        assertArrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK_BYTES);
+        assertArrayStartsWith(key, BEGIN_PGP_PRIVATE_KEY_BLOCK);
+        assertArrayEndsWithIgnoreNewlines(key, END_PGP_PRIVATE_KEY_BLOCK);
     }
 }
diff --git a/external-sop/src/test/java/sop/external/ExternalInlineSignDetachVerifyRoundTripTest.java b/external-sop/src/test/java/sop/external/ExternalInlineSignDetachVerifyRoundTripTest.java
index bc77534..23ba7fd 100644
--- a/external-sop/src/test/java/sop/external/ExternalInlineSignDetachVerifyRoundTripTest.java
+++ b/external-sop/src/test/java/sop/external/ExternalInlineSignDetachVerifyRoundTripTest.java
@@ -18,21 +18,23 @@ import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static sop.external.JUtils.arrayStartsWith;
-import static sop.external.JUtils.assertArrayStartsWith;
+import static sop.testing.JUtils.arrayStartsWith;
+import static sop.testing.JUtils.assertArrayStartsWith;
+import static sop.testing.TestData.ALICE_CERT;
+import static sop.testing.TestData.ALICE_KEY;
+import static sop.testing.TestData.BEGIN_PGP_SIGNATURE;
+import static sop.testing.TestData.PLAINTEXT;
 
 @EnabledIf("sop.external.AbstractExternalSOPTest#hasBackends")
 public class ExternalInlineSignDetachVerifyRoundTripTest extends AbstractExternalSOPTest {
 
-    private static final byte[] BEGIN_PGP_SIGNATURE = "-----BEGIN PGP SIGNATURE-----\n".getBytes(StandardCharsets.UTF_8);
-
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void inlineSignThenDetachThenDetachedVerifyTest(SOP sop) throws IOException {
-        byte[] message = "Hello, World!\n".getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] inlineSigned = sop.inlineSign()
-                .key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .getBytes();
 
@@ -47,7 +49,7 @@ public class ExternalInlineSignDetachVerifyRoundTripTest extends AbstractExterna
                 .getBytes();
 
         List<Verification> verifications = sop.detachedVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .signatures(signatures)
                 .data(plaintext);
 
@@ -60,7 +62,7 @@ public class ExternalInlineSignDetachVerifyRoundTripTest extends AbstractExterna
         byte[] message = "Hello, World!\n".getBytes(StandardCharsets.UTF_8);
 
         byte[] inlineSigned = sop.inlineSign()
-                .key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .getBytes();
 
@@ -82,7 +84,7 @@ public class ExternalInlineSignDetachVerifyRoundTripTest extends AbstractExterna
         assertArrayStartsWith(armored, BEGIN_PGP_SIGNATURE);
 
         List<Verification> verifications = sop.detachedVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .signatures(armored)
                 .data(plaintext);
 
diff --git a/external-sop/src/test/java/sop/external/ExternalInlineSignVerifyTest.java b/external-sop/src/test/java/sop/external/ExternalInlineSignVerifyTest.java
index 22916d6..5d1012f 100644
--- a/external-sop/src/test/java/sop/external/ExternalInlineSignVerifyTest.java
+++ b/external-sop/src/test/java/sop/external/ExternalInlineSignVerifyTest.java
@@ -12,6 +12,8 @@ import sop.SOP;
 import sop.Verification;
 import sop.enums.InlineSignAs;
 import sop.exception.SOPGPException;
+import sop.testing.JUtils;
+import sop.testing.TestData;
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
@@ -21,82 +23,84 @@ import java.util.List;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static sop.external.JUtils.assertSignedBy;
+import static sop.testing.JUtils.assertSignedBy;
+import static sop.testing.TestData.ALICE_CERT;
+import static sop.testing.TestData.ALICE_KEY;
+import static sop.testing.TestData.ALICE_PRIMARY_FINGERPRINT;
+import static sop.testing.TestData.ALICE_SIGNING_FINGERPRINT;
+import static sop.testing.TestData.BEGIN_PGP_MESSAGE;
+import static sop.testing.TestData.BEGIN_PGP_SIGNED_MESSAGE;
+import static sop.testing.TestData.PLAINTEXT;
 
 @EnabledIf("sop.external.AbstractExternalSOPTest#hasBackends")
 public class ExternalInlineSignVerifyTest extends AbstractExternalSOPTest {
 
-    private static final String BEGIN_PGP_MESSAGE = "-----BEGIN PGP MESSAGE-----\n";
-    private static final byte[] BEGIN_PGP_MESSAGE_BYTES = BEGIN_PGP_MESSAGE.getBytes(StandardCharsets.UTF_8);
-    private static final String BEGIN_PGP_SIGNED_MESSAGE = "-----BEGIN PGP SIGNED MESSAGE-----\n";
-    private static final byte[] BEGIN_PGP_SIGNED_MESSAGE_BYTES = BEGIN_PGP_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);
-
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void inlineSignVerifyAlice(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] inlineSigned = sop.inlineSign()
-                .key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .getBytes();
 
-        JUtils.assertArrayStartsWith(inlineSigned, BEGIN_PGP_MESSAGE_BYTES);
+        JUtils.assertArrayStartsWith(inlineSigned, BEGIN_PGP_MESSAGE);
 
         ByteArrayAndResult<List<Verification>> bytesAndResult = sop.inlineVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .data(inlineSigned)
                 .toByteArrayAndResult();
 
         assertArrayEquals(message, bytesAndResult.getBytes());
         List<Verification> verificationList = bytesAndResult.getResult();
-        assertSignedBy(verificationList, TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);
+        assertSignedBy(verificationList, ALICE_SIGNING_FINGERPRINT, ALICE_PRIMARY_FINGERPRINT);
     }
 
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void inlineSignVerifyAliceNoArmor(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] inlineSigned = sop.inlineSign()
-                .key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .noArmor()
                 .data(message)
                 .getBytes();
 
-        assertFalse(JUtils.arrayStartsWith(inlineSigned, BEGIN_PGP_MESSAGE_BYTES));
+        assertFalse(JUtils.arrayStartsWith(inlineSigned, BEGIN_PGP_MESSAGE));
 
         ByteArrayAndResult<List<Verification>> bytesAndResult = sop.inlineVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .data(inlineSigned)
                 .toByteArrayAndResult();
 
         assertArrayEquals(message, bytesAndResult.getBytes());
         List<Verification> verificationList = bytesAndResult.getResult();
-        assertSignedBy(verificationList, TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);
+        assertSignedBy(verificationList, ALICE_SIGNING_FINGERPRINT, ALICE_PRIMARY_FINGERPRINT);
     }
 
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void clearsignVerifyAlice(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] clearsigned = sop.inlineSign()
-                .key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
+                .key(ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                 .mode(InlineSignAs.clearsigned)
                 .data(message)
                 .getBytes();
 
-        JUtils.assertArrayStartsWith(clearsigned, BEGIN_PGP_SIGNED_MESSAGE_BYTES);
+        JUtils.assertArrayStartsWith(clearsigned, BEGIN_PGP_SIGNED_MESSAGE);
 
         ByteArrayAndResult<List<Verification>> bytesAndResult = sop.inlineVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .data(clearsigned)
                 .toByteArrayAndResult();
 
         assertArrayEquals(message, bytesAndResult.getBytes());
         List<Verification> verificationList = bytesAndResult.getResult();
-        assertSignedBy(verificationList, TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);
+        assertSignedBy(verificationList, ALICE_SIGNING_FINGERPRINT, ALICE_PRIMARY_FINGERPRINT);
     }
 
     @ParameterizedTest
@@ -106,11 +110,11 @@ public class ExternalInlineSignVerifyTest extends AbstractExternalSOPTest {
         Date signatureDate = TestData.ALICE_INLINE_SIGNED_MESSAGE_DATE;
 
         ByteArrayAndResult<List<Verification>> bytesAndResult = sop.inlineVerify()
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .toByteArrayAndResult();
         List<Verification> verificationList = bytesAndResult.getResult();
-        assertSignedBy(verificationList, TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT, signatureDate);
+        assertSignedBy(verificationList, ALICE_SIGNING_FINGERPRINT, ALICE_PRIMARY_FINGERPRINT, signatureDate);
     }
 
     @ParameterizedTest
@@ -122,7 +126,7 @@ public class ExternalInlineSignVerifyTest extends AbstractExternalSOPTest {
 
         assertThrows(SOPGPException.NoSignature.class, () -> sop.inlineVerify()
                 .notBefore(afterSignature)
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .toByteArrayAndResult());
     }
@@ -136,7 +140,7 @@ public class ExternalInlineSignVerifyTest extends AbstractExternalSOPTest {
 
         assertThrows(SOPGPException.NoSignature.class, () -> sop.inlineVerify()
                 .notAfter(beforeSignature)
-                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
+                .cert(ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .toByteArrayAndResult());
     }
@@ -144,14 +148,14 @@ public class ExternalInlineSignVerifyTest extends AbstractExternalSOPTest {
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void inlineSignVerifyBob(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] inlineSigned = sop.inlineSign()
                 .key(TestData.BOB_KEY.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .getBytes();
 
-        JUtils.assertArrayStartsWith(inlineSigned, BEGIN_PGP_MESSAGE_BYTES);
+        JUtils.assertArrayStartsWith(inlineSigned, BEGIN_PGP_MESSAGE);
 
         ByteArrayAndResult<List<Verification>> bytesAndResult = sop.inlineVerify()
                 .cert(TestData.BOB_CERT.getBytes(StandardCharsets.UTF_8))
@@ -166,14 +170,14 @@ public class ExternalInlineSignVerifyTest extends AbstractExternalSOPTest {
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void inlineSignVerifyCarol(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] inlineSigned = sop.inlineSign()
                 .key(TestData.CAROL_KEY.getBytes(StandardCharsets.UTF_8))
                 .data(message)
                 .getBytes();
 
-        JUtils.assertArrayStartsWith(inlineSigned, BEGIN_PGP_MESSAGE_BYTES);
+        JUtils.assertArrayStartsWith(inlineSigned, BEGIN_PGP_MESSAGE);
 
         ByteArrayAndResult<List<Verification>> bytesAndResult = sop.inlineVerify()
                 .cert(TestData.CAROL_CERT.getBytes(StandardCharsets.UTF_8))
@@ -188,7 +192,7 @@ public class ExternalInlineSignVerifyTest extends AbstractExternalSOPTest {
     @ParameterizedTest
     @MethodSource("sop.external.AbstractExternalSOPTest#provideBackends")
     public void inlineSignVerifyProtectedKey(SOP sop) throws IOException {
-        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);
+        byte[] message = PLAINTEXT.getBytes(StandardCharsets.UTF_8);
 
         byte[] inlineSigned = sop.inlineSign()
                 .withKeyPassword(TestData.PASSWORD)
diff --git a/sop-java/build.gradle b/sop-java/build.gradle
index ff0f293..0211189 100644
--- a/sop-java/build.gradle
+++ b/sop-java/build.gradle
@@ -4,6 +4,7 @@
 
 plugins {
     id 'java-library'
+    id 'java-test-fixtures'
 }
 
 group 'org.pgpainless'
@@ -15,6 +16,7 @@ repositories {
 dependencies {
     testImplementation "org.junit.jupiter:junit-jupiter-api:$junitVersion"
     testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:$junitVersion"
+    testFixturesImplementation "org.junit.jupiter:junit-jupiter-api:$junitVersion"
 }
 
 test {
diff --git a/external-sop/src/test/java/sop/external/JUtils.java b/sop-java/src/testFixtures/java/sop/testing/JUtils.java
similarity index 82%
rename from external-sop/src/test/java/sop/external/JUtils.java
rename to sop-java/src/testFixtures/java/sop/testing/JUtils.java
index 0b15142..99f5a5f 100644
--- a/external-sop/src/test/java/sop/external/JUtils.java
+++ b/sop-java/src/testFixtures/java/sop/testing/JUtils.java
@@ -2,7 +2,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-package sop.external;
+package sop.testing;
 
 import sop.Verification;
 import sop.util.UTCUtil;
@@ -86,6 +86,47 @@ public class JUtils {
         }
     }
 
+    public static boolean arrayEndsWith(byte[] array, byte[] end) {
+        return arrayEndsWith(array, end, 0);
+    }
+
+    public static boolean arrayEndsWith(byte[] array, byte[] end, int offset) {
+        if (end.length + offset > array.length) {
+            return false;
+        }
+
+        for (int i = 0; i < end.length; i++) {
+            int arrOff = array.length - end.length - offset;
+            if (end[i] != array[arrOff + i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void assertArrayEndsWith(byte[] array, byte[] end) {
+        assertArrayEndsWith(array, end, 0);
+    }
+
+    public static void assertArrayEndsWith(byte[] array, byte[] end, int offset) {
+        if (!arrayEndsWith(array, end, offset)) {
+            byte[] actual = new byte[Math.min(end.length, array.length - offset)];
+            System.arraycopy(array, array.length - actual.length, actual, 0, actual.length);
+            fail("Array does not end with the expected bytes.\n" +
+                    "Expected: <" + Arrays.toString(end) + ">\n" +
+                    "Actual: <" + Arrays.toString(actual) + ">");
+        }
+    }
+
+    public static void assertArrayEndsWithIgnoreNewlines(byte[] array, byte[] end) {
+        int offset = 0;
+        while (offset < array.length && array[array.length - 1 - offset] == (byte) 10) {
+            offset++;
+        }
+
+        assertArrayEndsWith(array, end, offset);
+    }
+
     /**
      * Assert equality of the given two ascii armored byte arrays, ignoring armor header lines.
      *
diff --git a/external-sop/src/test/java/sop/external/TestData.java b/sop-java/src/testFixtures/java/sop/testing/TestData.java
similarity index 96%
rename from external-sop/src/test/java/sop/external/TestData.java
rename to sop-java/src/testFixtures/java/sop/testing/TestData.java
index 640c70f..f573eef 100644
--- a/external-sop/src/test/java/sop/external/TestData.java
+++ b/sop-java/src/testFixtures/java/sop/testing/TestData.java
@@ -2,10 +2,11 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-package sop.external;
+package sop.testing;
 
 import sop.util.UTCUtil;
 
+import java.nio.charset.StandardCharsets;
 import java.util.Date;
 
 public class TestData {
@@ -409,4 +410,15 @@ public class TestData {
     public static final String PASSWORD = "sw0rdf1sh";
     public static final String PASSWORD_PROTECTED_PRIMARY_FINGERPRINT = "FC63688A5E698C2940AF70297C622B00D4592657";
     public static final String PASSWORD_PROTECTED_SIGNING_FINGERPRINT = "D8F1CBC2613350D1A766D35F68862FB90F07165B";
+
+
+    public static final byte[] BEGIN_PGP_PRIVATE_KEY_BLOCK = "-----BEGIN PGP PRIVATE KEY BLOCK-----\n".getBytes(StandardCharsets.UTF_8);
+    public static final byte[] END_PGP_PRIVATE_KEY_BLOCK = "-----END PGP PRIVATE KEY BLOCK-----".getBytes(StandardCharsets.UTF_8);
+    public static final byte[] BEGIN_PGP_PUBLIC_KEY_BLOCK = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n".getBytes(StandardCharsets.UTF_8);
+    public static final byte[] END_PGP_PUBLIC_KEY_BLOCK = "-----END PGP PUBLIC KEY BLOCK-----".getBytes(StandardCharsets.UTF_8);
+    public static final byte[] BEGIN_PGP_MESSAGE = "-----BEGIN PGP MESSAGE-----\n".getBytes(StandardCharsets.UTF_8);
+    public static final byte[] END_PGP_MESSAGE = "-----END PGP MESSAGE-----".getBytes(StandardCharsets.UTF_8);
+    public static final byte[] BEGIN_PGP_SIGNATURE = "-----BEGIN PGP SIGNATURE-----\n".getBytes(StandardCharsets.UTF_8);
+    public static final byte[] END_PGP_SIGNATURE = "-----END PGP SIGNATURE-----".getBytes(StandardCharsets.UTF_8);
+    public static final byte[] BEGIN_PGP_SIGNED_MESSAGE = "-----BEGIN PGP SIGNED MESSAGE-----\n".getBytes(StandardCharsets.UTF_8);
 }
diff --git a/sop-java/src/testFixtures/java/sop/testing/package-info.java b/sop-java/src/testFixtures/java/sop/testing/package-info.java
new file mode 100644
index 0000000..1d4527a
--- /dev/null
+++ b/sop-java/src/testFixtures/java/sop/testing/package-info.java
@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: 2021 Paul Schaub <vanitasvitae@fsfe.org>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Stateless OpenPGP Interface for Java.
+ */
+package sop.testing;