pgpainless / sop-java / #67

Committed 12 Jan 2026 01:04PM UTC coverage: 58.151% (+0.003%) from 58.148%

Build # #67

Build Type

push

other

Committed by

vanitasvitae

Commit Message

Add test for dearmoring malformed data

Coverage Stats

3 of 5 new or added lines in 1 file covered. (60.0%)

2126 of 3656 relevant lines covered (58.15%)

0.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.15

/sop-java-testfixtures/src/main/java/sop/testsuite/operation/ArmorDearmorTest.java

// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
//
// SPDX-License-Identifier: Apache-2.0

package sop.testsuite.operation;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.condition.EnabledIf;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import sop.SOP;
import sop.exception.SOPGPException;
import sop.testsuite.JUtils;
import sop.testsuite.TestData;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

@EnabledIf("sop.testsuite.operation.AbstractSOPTest#hasBackends")
public class ArmorDearmorTest extends AbstractSOPTest {

    static Stream<Arguments> provideInstances() {
        return AbstractSOPTest.provideBackends();
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void dearmorMalformedArmorHeaderLinesFails(SOP sop) {
        byte[] keyWithMalformedHeader = TestData.ALICE_KEY
                .replace("Comment: ", "Comment ") // missing colon renders armor header line malformed
                .getBytes(StandardCharsets.UTF_8);

        assertThrows(SOPGPException.BadData.class, () -> sop.dearmor().data(keyWithMalformedHeader).getBytes());
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void dearmorArmorAliceKey(SOP sop) throws IOException {
        byte[] aliceKey = TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8);

        byte[] dearmored = assumeSupported(sop::dearmor)
                .data(aliceKey)
                .getBytes();

        Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK));

        byte[] armored = assumeSupported(sop::armor)
                .data(dearmored)
                .getBytes();

        JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PRIVATE_KEY_BLOCK);

        // assertAsciiArmorEquals(aliceKey, armored);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void dearmorArmorAliceCert(SOP sop) throws IOException {
        byte[] aliceCert = TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8);

        byte[] dearmored = assumeSupported(sop::dearmor)
                .data(aliceCert)
                .getBytes();

        Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK));

        byte[] armored = assumeSupported(sop::armor)
                .data(dearmored)
                .getBytes();

        JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PUBLIC_KEY_BLOCK);

        // assertAsciiArmorEquals(aliceCert, armored);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void dearmorArmorBobKey(SOP sop) throws IOException {
        byte[] bobKey = TestData.BOB_KEY.getBytes(StandardCharsets.UTF_8);

        byte[] dearmored = assumeSupported(sop::dearmor)
                .data(bobKey)
                .getBytes();

        Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK));

        byte[] armored = assumeSupported(sop::armor)
                .data(dearmored)
                .getBytes();

        JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PRIVATE_KEY_BLOCK);

        // assertAsciiArmorEquals(bobKey, armored);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void dearmorArmorBobCert(SOP sop) throws IOException {
        byte[] bobCert = TestData.BOB_CERT.getBytes(StandardCharsets.UTF_8);

        byte[] dearmored = assumeSupported(sop::dearmor)
                .data(bobCert)
                .getBytes();

        Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK));

        byte[] armored = assumeSupported(sop::armor)
                .data(dearmored)
                .getBytes();

        JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PUBLIC_KEY_BLOCK);

        // assertAsciiArmorEquals(bobCert, armored);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void dearmorArmorCarolKey(SOP sop) throws IOException {
        byte[] carolKey = TestData.CAROL_KEY.getBytes(StandardCharsets.UTF_8);

        byte[] dearmored = assumeSupported(sop::dearmor)
                .data(carolKey)
                .getBytes();

        Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK));

        byte[] armored = assumeSupported(sop::armor)
                .data(dearmored)
                .getBytes();

        JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PRIVATE_KEY_BLOCK);

        // assertAsciiArmorEquals(carolKey, armored);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void dearmorArmorCarolCert(SOP sop) throws IOException {
        byte[] carolCert = TestData.CAROL_CERT.getBytes(StandardCharsets.UTF_8);

        byte[] dearmored = assumeSupported(sop::dearmor)
                .data(carolCert)
                .getBytes();

        Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK));

        byte[] armored = assumeSupported(sop::armor)
                .data(dearmored)
                .getBytes();

        JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PUBLIC_KEY_BLOCK);

        // assertAsciiArmorEquals(carolCert, armored);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void dearmorArmorMessage(SOP sop) throws IOException {
        byte[] message = ("-----BEGIN PGP MESSAGE-----\n" +
                "\n" +
                "wV4DR2b2udXyHrYSAQdAMZy9Iqb1IxszjI3v+TsfK//0lnJ9PKHDqVAB5ohp+RMw\n" +
                "8fmuL3phS9uISFT/DrizC8ALJhMqw5R+lLB/RvTTA/qS6tN5dRyL+YLFU3/N0CRF\n" +
                "0j8BtQEsMmRo60LzUq/OBI0dFjwFq1efpfOGkpRYkuIzndCjBEgnLUkrHzUc1uD9\n" +
                "CePQFpprprnGEzpE3flQLUc=\n" +
                "=ZiFR\n" +
                "-----END PGP MESSAGE-----\n").getBytes(StandardCharsets.UTF_8);
        byte[] dearmored = assumeSupported(sop::dearmor)
                .data(message)
                .getBytes();

        Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_MESSAGE));

        byte[] armored = assumeSupported(sop::armor)
                .data(dearmored)
                .getBytes();

        JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_MESSAGE);
        JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_MESSAGE);

        // assertAsciiArmorEquals(message, armored);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void dearmorArmorSignature(SOP sop) throws IOException {
        byte[] signature = ("-----BEGIN PGP SIGNATURE-----\n" +
                "\n" +
                "wr0EABYKAG8FgmPBdRAJEPIxVQxPR+OORxQAAAAAAB4AIHNhbHRAbm90YXRpb25z\n" +
                "LnNlcXVvaWEtcGdwLm9yZ2un17fF3C46Adgzp0mU4RG8Txy/T/zOBcBw/NYaLGrQ\n" +
                "FiEE64W7X6M6deFelE5j8jFVDE9H444AAMiEAP9LBQWLo4oP5IrFZPuSUQSPsUxB\n" +
                "c+Qu1raXDKzS/8Q9IAD+LnHIjRHcqNPobNHXF/saXIYXeZR+LJKszTJozzwqdQE=\n" +
                "=GHvQ\n" +
                "-----END PGP SIGNATURE-----\n").getBytes(StandardCharsets.UTF_8);

        byte[] dearmored = assumeSupported(sop::dearmor)
                .data(signature)
                .getBytes();

        Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_SIGNATURE));

        byte[] armored = assumeSupported(sop::armor)
                .data(dearmored)
                .getBytes();

        JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_SIGNATURE);
        JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_SIGNATURE);

        JUtils.assertAsciiArmorEquals(signature, armored);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void testDearmoringTwiceIsIdempotent(SOP sop) throws IOException {
        byte[] dearmored = assumeSupported(sop::dearmor)
                .data(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                .getBytes();

        byte[] dearmoredAgain = assumeSupported(sop::dearmor)
                .data(dearmored)
                .getBytes();

        assertArrayEquals(dearmored, dearmoredAgain);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void testArmoringTwiceIsIdempotent(SOP sop) throws IOException {
        byte[] armored = ("-----BEGIN PGP SIGNATURE-----\n" +
                "\n" +
                "wr0EABYKAG8FgmPBdRAJEPIxVQxPR+OORxQAAAAAAB4AIHNhbHRAbm90YXRpb25z\n" +
                "LnNlcXVvaWEtcGdwLm9yZ2un17fF3C46Adgzp0mU4RG8Txy/T/zOBcBw/NYaLGrQ\n" +
                "FiEE64W7X6M6deFelE5j8jFVDE9H444AAMiEAP9LBQWLo4oP5IrFZPuSUQSPsUxB\n" +
                "c+Qu1raXDKzS/8Q9IAD+LnHIjRHcqNPobNHXF/saXIYXeZR+LJKszTJozzwqdQE=\n" +
                "=GHvQ\n" +
                "-----END PGP SIGNATURE-----\n").getBytes(StandardCharsets.UTF_8);

        byte[] armoredAgain = assumeSupported(sop::armor)
                .data(armored)
                .getBytes();

        JUtils.assertAsciiArmorEquals(armored, armoredAgain);
    }

}

1	// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
2	//
3	// SPDX-License-Identifier: Apache-2.0
4
5	package sop.testsuite.operation;
6
7	import org.junit.jupiter.api.Assertions;
8	import org.junit.jupiter.api.condition.EnabledIf;
9	import org.junit.jupiter.params.ParameterizedTest;
10	import org.junit.jupiter.params.provider.Arguments;
11	import org.junit.jupiter.params.provider.MethodSource;
12	import sop.SOP;
13	import sop.exception.SOPGPException;
14	import sop.testsuite.JUtils;
15	import sop.testsuite.TestData;
16
17	import java.io.IOException;
18	import java.nio.charset.StandardCharsets;
19	import java.util.stream.Stream;
20
21	import static org.junit.jupiter.api.Assertions.assertArrayEquals;
22	import static org.junit.jupiter.api.Assertions.assertThrows;
23
24	@EnabledIf("sop.testsuite.operation.AbstractSOPTest#hasBackends")
25	public class ArmorDearmorTest extends AbstractSOPTest {	1✔
26
27	static Stream<Arguments> provideInstances() {
28	return AbstractSOPTest.provideBackends();	1✔
29	}
30
31	@ParameterizedTest
32	@MethodSource("provideInstances")
33	public void dearmorMalformedArmorHeaderLinesFails(SOP sop) {
34	byte[] keyWithMalformedHeader = TestData.ALICE_KEY	1✔
35	.replace("Comment: ", "Comment ") // missing colon renders armor header line malformed	1✔
36	.getBytes(StandardCharsets.UTF_8);	1✔
37
NEW 38	assertThrows(SOPGPException.BadData.class, () -> sop.dearmor().data(keyWithMalformedHeader).getBytes());	×
NEW 39	}	×
40
41	@ParameterizedTest
42	@MethodSource("provideInstances")
43	public void dearmorArmorAliceKey(SOP sop) throws IOException {
44	byte[] aliceKey = TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8);	1✔
45
46	byte[] dearmored = assumeSupported(sop::dearmor)	1✔
47	.data(aliceKey)	1✔
48	.getBytes();	1✔
49
50	Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK));	1✔
51
52	byte[] armored = assumeSupported(sop::armor)	1✔
53	.data(dearmored)	1✔
54	.getBytes();	1✔
55
56	JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);	1✔
57	JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PRIVATE_KEY_BLOCK);	1✔
58
59	// assertAsciiArmorEquals(aliceKey, armored);
60	}	1✔
61
62	@ParameterizedTest
63	@MethodSource("provideInstances")
64	public void dearmorArmorAliceCert(SOP sop) throws IOException {
65	byte[] aliceCert = TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8);	1✔
66
67	byte[] dearmored = assumeSupported(sop::dearmor)	1✔
68	.data(aliceCert)	1✔
69	.getBytes();	1✔
70
71	Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK));	1✔
72
73	byte[] armored = assumeSupported(sop::armor)	1✔
74	.data(dearmored)	1✔
75	.getBytes();	1✔
76
77	JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK);	1✔
78	JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PUBLIC_KEY_BLOCK);	1✔
79
80	// assertAsciiArmorEquals(aliceCert, armored);
81	}	1✔
82
83	@ParameterizedTest
84	@MethodSource("provideInstances")
85	public void dearmorArmorBobKey(SOP sop) throws IOException {
86	byte[] bobKey = TestData.BOB_KEY.getBytes(StandardCharsets.UTF_8);	1✔
87
88	byte[] dearmored = assumeSupported(sop::dearmor)	1✔
89	.data(bobKey)	1✔
90	.getBytes();	1✔
91
92	Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK));	1✔
93
94	byte[] armored = assumeSupported(sop::armor)	1✔
95	.data(dearmored)	1✔
96	.getBytes();	1✔
97
98	JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);	1✔
99	JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PRIVATE_KEY_BLOCK);	1✔
100
101	// assertAsciiArmorEquals(bobKey, armored);
102	}	1✔
103
104	@ParameterizedTest
105	@MethodSource("provideInstances")
106	public void dearmorArmorBobCert(SOP sop) throws IOException {
107	byte[] bobCert = TestData.BOB_CERT.getBytes(StandardCharsets.UTF_8);	1✔
108
109	byte[] dearmored = assumeSupported(sop::dearmor)	1✔
110	.data(bobCert)	1✔
111	.getBytes();	1✔
112
113	Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK));	1✔
114
115	byte[] armored = assumeSupported(sop::armor)	1✔
116	.data(dearmored)	1✔
117	.getBytes();	1✔
118
119	JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK);	1✔
120	JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PUBLIC_KEY_BLOCK);	1✔
121
122	// assertAsciiArmorEquals(bobCert, armored);
123	}	1✔
124
125	@ParameterizedTest
126	@MethodSource("provideInstances")
127	public void dearmorArmorCarolKey(SOP sop) throws IOException {
128	byte[] carolKey = TestData.CAROL_KEY.getBytes(StandardCharsets.UTF_8);	1✔
129
130	byte[] dearmored = assumeSupported(sop::dearmor)	1✔
131	.data(carolKey)	1✔
132	.getBytes();	1✔
133
134	Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK));	1✔
135
136	byte[] armored = assumeSupported(sop::armor)	1✔
137	.data(dearmored)	1✔
138	.getBytes();	1✔
139
140	JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);	1✔
141	JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PRIVATE_KEY_BLOCK);	1✔
142
143	// assertAsciiArmorEquals(carolKey, armored);
144	}	1✔
145
146	@ParameterizedTest
147	@MethodSource("provideInstances")
148	public void dearmorArmorCarolCert(SOP sop) throws IOException {
149	byte[] carolCert = TestData.CAROL_CERT.getBytes(StandardCharsets.UTF_8);	1✔
150
151	byte[] dearmored = assumeSupported(sop::dearmor)	1✔
152	.data(carolCert)	1✔
153	.getBytes();	1✔
154
155	Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK));	1✔
156
157	byte[] armored = assumeSupported(sop::armor)	1✔
158	.data(dearmored)	1✔
159	.getBytes();	1✔
160
161	JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PUBLIC_KEY_BLOCK);	1✔
162	JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_PUBLIC_KEY_BLOCK);	1✔
163
164	// assertAsciiArmorEquals(carolCert, armored);
165	}	1✔
166
167	@ParameterizedTest
168	@MethodSource("provideInstances")
169	public void dearmorArmorMessage(SOP sop) throws IOException {
170	byte[] message = ("-----BEGIN PGP MESSAGE-----\n" +	1✔
171	"\n" +
172	"wV4DR2b2udXyHrYSAQdAMZy9Iqb1IxszjI3v+TsfK//0lnJ9PKHDqVAB5ohp+RMw\n" +
173	"8fmuL3phS9uISFT/DrizC8ALJhMqw5R+lLB/RvTTA/qS6tN5dRyL+YLFU3/N0CRF\n" +
174	"0j8BtQEsMmRo60LzUq/OBI0dFjwFq1efpfOGkpRYkuIzndCjBEgnLUkrHzUc1uD9\n" +
175	"CePQFpprprnGEzpE3flQLUc=\n" +
176	"=ZiFR\n" +
177	"-----END PGP MESSAGE-----\n").getBytes(StandardCharsets.UTF_8);	1✔
178	byte[] dearmored = assumeSupported(sop::dearmor)	1✔
179	.data(message)	1✔
180	.getBytes();	×
181
182	Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_MESSAGE));	×
183
184	byte[] armored = assumeSupported(sop::armor)	×
185	.data(dearmored)	×
186	.getBytes();	×
187
188	JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_MESSAGE);	×
189	JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_MESSAGE);	×
190
191	// assertAsciiArmorEquals(message, armored);
192	}	×
193
194	@ParameterizedTest
195	@MethodSource("provideInstances")
196	public void dearmorArmorSignature(SOP sop) throws IOException {
197	byte[] signature = ("-----BEGIN PGP SIGNATURE-----\n" +	1✔
198	"\n" +
199	"wr0EABYKAG8FgmPBdRAJEPIxVQxPR+OORxQAAAAAAB4AIHNhbHRAbm90YXRpb25z\n" +
200	"LnNlcXVvaWEtcGdwLm9yZ2un17fF3C46Adgzp0mU4RG8Txy/T/zOBcBw/NYaLGrQ\n" +
201	"FiEE64W7X6M6deFelE5j8jFVDE9H444AAMiEAP9LBQWLo4oP5IrFZPuSUQSPsUxB\n" +
202	"c+Qu1raXDKzS/8Q9IAD+LnHIjRHcqNPobNHXF/saXIYXeZR+LJKszTJozzwqdQE=\n" +
203	"=GHvQ\n" +
204	"-----END PGP SIGNATURE-----\n").getBytes(StandardCharsets.UTF_8);	1✔
205
206	byte[] dearmored = assumeSupported(sop::dearmor)	1✔
207	.data(signature)	1✔
208	.getBytes();	1✔
209
210	Assertions.assertFalse(JUtils.arrayStartsWith(dearmored, TestData.BEGIN_PGP_SIGNATURE));	1✔
211
212	byte[] armored = assumeSupported(sop::armor)	1✔
213	.data(dearmored)	1✔
214	.getBytes();	1✔
215
216	JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_SIGNATURE);	1✔
217	JUtils.assertArrayEndsWithIgnoreNewlines(armored, TestData.END_PGP_SIGNATURE);	1✔
218
219	JUtils.assertAsciiArmorEquals(signature, armored);	1✔
220	}	1✔
221
222	@ParameterizedTest
223	@MethodSource("provideInstances")
224	public void testDearmoringTwiceIsIdempotent(SOP sop) throws IOException {
225	byte[] dearmored = assumeSupported(sop::dearmor)	1✔
226	.data(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))	1✔
227	.getBytes();	1✔
228
229	byte[] dearmoredAgain = assumeSupported(sop::dearmor)	1✔
230	.data(dearmored)	1✔
231	.getBytes();	1✔
232
233	assertArrayEquals(dearmored, dearmoredAgain);	1✔
234	}	1✔
235
236	@ParameterizedTest
237	@MethodSource("provideInstances")
238	public void testArmoringTwiceIsIdempotent(SOP sop) throws IOException {
239	byte[] armored = ("-----BEGIN PGP SIGNATURE-----\n" +	1✔
240	"\n" +
241	"wr0EABYKAG8FgmPBdRAJEPIxVQxPR+OORxQAAAAAAB4AIHNhbHRAbm90YXRpb25z\n" +
242	"LnNlcXVvaWEtcGdwLm9yZ2un17fF3C46Adgzp0mU4RG8Txy/T/zOBcBw/NYaLGrQ\n" +
243	"FiEE64W7X6M6deFelE5j8jFVDE9H444AAMiEAP9LBQWLo4oP5IrFZPuSUQSPsUxB\n" +
244	"c+Qu1raXDKzS/8Q9IAD+LnHIjRHcqNPobNHXF/saXIYXeZR+LJKszTJozzwqdQE=\n" +
245	"=GHvQ\n" +
246	"-----END PGP SIGNATURE-----\n").getBytes(StandardCharsets.UTF_8);	1✔
247
248	byte[] armoredAgain = assumeSupported(sop::armor)	1✔
249	.data(armored)	1✔
250	.getBytes();	1✔
251
252	JUtils.assertAsciiArmorEquals(armored, armoredAgain);	1✔
253	}	1✔
254
255	}

pgpainless / sop-java / #67

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous