pgpainless / sop-java / #68

Committed 20 Jan 2026 09:05PM UTC coverage: 57.576% (-0.6%) from 58.151%

Build # #68

Build Type

push

other

Committed by

vanitasvitae

Commit Message

Fix missing parameter error in validate-userid command

Run Details

0 of 1 new or added line in 1 file covered. (0.0%)

159 existing lines in 5 files now uncovered.

2109 of 3663 relevant lines covered (57.58%)

0.58 hits per line

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

33.09

/sop-java-testfixtures/src/main/java/sop/testsuite/operation/InlineSignInlineVerifyTest.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.Disabled;
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.ByteArrayAndResult;
import sop.SOP;
import sop.Verification;
import sop.enums.InlineSignAs;
import sop.enums.SignatureMode;
import sop.exception.SOPGPException;
import sop.testsuite.JUtils;
import sop.testsuite.TestData;
import sop.testsuite.assertions.VerificationListAssert;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.List;
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 InlineSignInlineVerifyTest extends AbstractSOPTest {

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

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

        byte[] inlineSigned = assumeSupported(sop::inlineSign)
                .key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                .data(message)
                .getBytes();

        JUtils.assertArrayStartsWith(inlineSigned, TestData.BEGIN_PGP_MESSAGE);

        ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)
                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                .data(inlineSigned)
                .toByteArrayAndResult();

        assertArrayEquals(message, bytesAndResult.getBytes());

        List<Verification> verificationList = bytesAndResult.getResult();
        VerificationListAssert.assertThatVerificationList(verificationList)
                .isNotEmpty()
                .hasSingleItem()
                .issuedBy(TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);
    }

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

        byte[] inlineSigned = assumeSupported(sop::inlineSign)
                .key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                .noArmor()
                .data(message)
                .getBytes();

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

        ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)
                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                .data(inlineSigned)
                .toByteArrayAndResult();

        assertArrayEquals(message, bytesAndResult.getBytes());

        List<Verification> verificationList = bytesAndResult.getResult();
        VerificationListAssert.assertThatVerificationList(verificationList)
                .isNotEmpty()
                .hasSingleItem()
                .issuedBy(TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);
    }

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

        byte[] clearsigned = assumeSupported(sop::inlineSign)
                .key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))
                .mode(InlineSignAs.clearsigned)
                .data(message)
                .getBytes();

        JUtils.assertArrayStartsWith(clearsigned, TestData.BEGIN_PGP_SIGNED_MESSAGE);

        ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)
                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                .data(clearsigned)
                .toByteArrayAndResult();

        assertArrayEquals(message, bytesAndResult.getBytes(),
                "ASCII armored message does not appear to start with the 'BEGIN PGP SIGNED MESSAGE' header.");

        List<Verification> verificationList = bytesAndResult.getResult();
        VerificationListAssert.assertThatVerificationList(verificationList)
                .hasSingleItem()
                .issuedBy(TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT)
                .hasModeOrNull(SignatureMode.text);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void inlineVerifyCompareSignatureDate(SOP sop) throws IOException {
        byte[] message = TestData.ALICE_INLINE_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);
        Date signatureDate = TestData.ALICE_INLINE_SIGNED_MESSAGE_DATE;

        ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)
                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                .data(message)
                .toByteArrayAndResult();

        List<Verification> verificationList = bytesAndResult.getResult();
        VerificationListAssert.assertThatVerificationList(verificationList)
                .isNotEmpty()
                .hasSingleItem()
                .isCreatedAt(signatureDate)
                .issuedBy(TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void assertNotBeforeThrowsNoSignature(SOP sop) {
        byte[] message = TestData.ALICE_INLINE_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);
        Date signatureDate = TestData.ALICE_INLINE_SIGNED_MESSAGE_DATE;
        Date afterSignature = new Date(signatureDate.getTime() + 1000); // 1 sec before sig

        assertThrows(SOPGPException.NoSignature.class, () -> assumeSupported(sop::inlineVerify)
                .notBefore(afterSignature)
                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                .data(message)
                .toByteArrayAndResult());
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void assertNotAfterThrowsNoSignature(SOP sop) {
        byte[] message = TestData.ALICE_INLINE_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);
        Date signatureDate = TestData.ALICE_INLINE_SIGNED_MESSAGE_DATE;
        Date beforeSignature = new Date(signatureDate.getTime() - 1000); // 1 sec before sig

        assertThrows(SOPGPException.NoSignature.class, () -> assumeSupported(sop::inlineVerify)
                .notAfter(beforeSignature)
                .cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))
                .data(message)
                .toByteArrayAndResult());
    }

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

        byte[] inlineSigned = assumeSupported(sop::inlineSign)
                .key(TestData.BOB_KEY.getBytes(StandardCharsets.UTF_8))
                .data(message)
                .getBytes();

        JUtils.assertArrayStartsWith(inlineSigned, TestData.BEGIN_PGP_MESSAGE);

        ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)
                .cert(TestData.BOB_CERT.getBytes(StandardCharsets.UTF_8))
                .data(inlineSigned)
                .toByteArrayAndResult();

        assertArrayEquals(message, bytesAndResult.getBytes());

        List<Verification> verificationList = bytesAndResult.getResult();
        VerificationListAssert.assertThatVerificationList(verificationList)
                .isNotEmpty()
                .hasSingleItem()
                .issuedBy(TestData.BOB_SIGNING_FINGERPRINT, TestData.BOB_PRIMARY_FINGERPRINT);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    @Disabled("Carol is a deprecated ElGamal key")
    public void inlineSignVerifyCarol(SOP sop) throws IOException {
        byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);

        byte[] inlineSigned = assumeSupported(sop::inlineSign)
                .key(TestData.CAROL_KEY.getBytes(StandardCharsets.UTF_8))
                .data(message)
                .getBytes();

        JUtils.assertArrayStartsWith(inlineSigned, TestData.BEGIN_PGP_MESSAGE);

        ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)
                .cert(TestData.CAROL_CERT.getBytes(StandardCharsets.UTF_8))
                .data(inlineSigned)
                .toByteArrayAndResult();

        assertArrayEquals(message, bytesAndResult.getBytes());

        List<Verification> verificationList = bytesAndResult.getResult();
        VerificationListAssert.assertThatVerificationList(verificationList)
                .isNotEmpty()
                .hasSingleItem()
                .issuedBy(TestData.CAROL_SIGNING_FINGERPRINT, TestData.CAROL_PRIMARY_FINGERPRINT);
    }

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

        byte[] inlineSigned = assumeSupported(sop::inlineSign)
                .withKeyPassword(TestData.PASSWORD)
                .key(TestData.PASSWORD_PROTECTED_KEY.getBytes(StandardCharsets.UTF_8))
                .mode(InlineSignAs.binary)
                .data(message)
                .getBytes();

        ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)
                .cert(TestData.PASSWORD_PROTECTED_CERT.getBytes(StandardCharsets.UTF_8))
                .data(inlineSigned)
                .toByteArrayAndResult();

        List<Verification> verificationList = bytesAndResult.getResult();
        VerificationListAssert.assertThatVerificationList(verificationList)
                .hasSingleItem()
                .issuedBy(TestData.PASSWORD_PROTECTED_SIGNING_FINGERPRINT, TestData.PASSWORD_PROTECTED_PRIMARY_FINGERPRINT);
    }

}

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.Disabled;
9	import org.junit.jupiter.api.condition.EnabledIf;
10	import org.junit.jupiter.params.ParameterizedTest;
11	import org.junit.jupiter.params.provider.Arguments;
12	import org.junit.jupiter.params.provider.MethodSource;
13	import sop.ByteArrayAndResult;
14	import sop.SOP;
15	import sop.Verification;
16	import sop.enums.InlineSignAs;
17	import sop.enums.SignatureMode;
18	import sop.exception.SOPGPException;
19	import sop.testsuite.JUtils;
20	import sop.testsuite.TestData;
21	import sop.testsuite.assertions.VerificationListAssert;
22
23	import java.io.IOException;
24	import java.nio.charset.StandardCharsets;
25	import java.util.Date;
26	import java.util.List;
27	import java.util.stream.Stream;
28
29	import static org.junit.jupiter.api.Assertions.assertArrayEquals;
30	import static org.junit.jupiter.api.Assertions.assertThrows;
31
32	@EnabledIf("sop.testsuite.operation.AbstractSOPTest#hasBackends")
33	public class InlineSignInlineVerifyTest extends AbstractSOPTest {	1✔
34
35	static Stream<Arguments> provideInstances() {
36	return provideBackends();	1✔
37	}
38
39	@ParameterizedTest
40	@MethodSource("provideInstances")
41	public void inlineSignVerifyAlice(SOP sop) throws IOException {
42	byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);	1✔
43
44	byte[] inlineSigned = assumeSupported(sop::inlineSign)	1✔
45	.key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))	1✔
46	.data(message)	1✔
UNCOV 47	.getBytes();	×
48
UNCOV 49	JUtils.assertArrayStartsWith(inlineSigned, TestData.BEGIN_PGP_MESSAGE);	×
50
51	ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)	×
52	.cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))	×
53	.data(inlineSigned)	×
UNCOV 54	.toByteArrayAndResult();	×
55
UNCOV 56	assertArrayEquals(message, bytesAndResult.getBytes());	×
57
58	List<Verification> verificationList = bytesAndResult.getResult();	×
59	VerificationListAssert.assertThatVerificationList(verificationList)	×
60	.isNotEmpty()	×
61	.hasSingleItem()	×
62	.issuedBy(TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);	×
UNCOV 63	}	×
64
65	@ParameterizedTest
66	@MethodSource("provideInstances")
67	public void inlineSignVerifyAliceNoArmor(SOP sop) throws IOException {
68	byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);	1✔
69
70	byte[] inlineSigned = assumeSupported(sop::inlineSign)	1✔
71	.key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))	1✔
72	.noArmor()	1✔
73	.data(message)	1✔
UNCOV 74	.getBytes();	×
75
UNCOV 76	Assertions.assertFalse(JUtils.arrayStartsWith(inlineSigned, TestData.BEGIN_PGP_MESSAGE));	×
77
78	ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)	×
79	.cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))	×
80	.data(inlineSigned)	×
UNCOV 81	.toByteArrayAndResult();	×
82
UNCOV 83	assertArrayEquals(message, bytesAndResult.getBytes());	×
84
85	List<Verification> verificationList = bytesAndResult.getResult();	×
86	VerificationListAssert.assertThatVerificationList(verificationList)	×
87	.isNotEmpty()	×
88	.hasSingleItem()	×
89	.issuedBy(TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);	×
UNCOV 90	}	×
91
92	@ParameterizedTest
93	@MethodSource("provideInstances")
94	public void clearsignVerifyAlice(SOP sop) throws IOException {
95	byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);	1✔
96
97	byte[] clearsigned = assumeSupported(sop::inlineSign)	1✔
98	.key(TestData.ALICE_KEY.getBytes(StandardCharsets.UTF_8))	1✔
99	.mode(InlineSignAs.clearsigned)	1✔
100	.data(message)	1✔
UNCOV 101	.getBytes();	×
102
UNCOV 103	JUtils.assertArrayStartsWith(clearsigned, TestData.BEGIN_PGP_SIGNED_MESSAGE);	×
104
105	ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)	×
106	.cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))	×
107	.data(clearsigned)	×
UNCOV 108	.toByteArrayAndResult();	×
109
UNCOV 110	assertArrayEquals(message, bytesAndResult.getBytes(),	×
111	"ASCII armored message does not appear to start with the 'BEGIN PGP SIGNED MESSAGE' header.");
112
113	List<Verification> verificationList = bytesAndResult.getResult();	×
114	VerificationListAssert.assertThatVerificationList(verificationList)	×
115	.hasSingleItem()	×
116	.issuedBy(TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT)	×
117	.hasModeOrNull(SignatureMode.text);	×
UNCOV 118	}	×
119
120	@ParameterizedTest
121	@MethodSource("provideInstances")
122	public void inlineVerifyCompareSignatureDate(SOP sop) throws IOException {
123	byte[] message = TestData.ALICE_INLINE_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);	1✔
124	Date signatureDate = TestData.ALICE_INLINE_SIGNED_MESSAGE_DATE;	1✔
125
126	ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)	1✔
127	.cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))	1✔
128	.data(message)	1✔
UNCOV 129	.toByteArrayAndResult();	×
130
131	List<Verification> verificationList = bytesAndResult.getResult();	×
132	VerificationListAssert.assertThatVerificationList(verificationList)	×
133	.isNotEmpty()	×
134	.hasSingleItem()	×
135	.isCreatedAt(signatureDate)	×
136	.issuedBy(TestData.ALICE_SIGNING_FINGERPRINT, TestData.ALICE_PRIMARY_FINGERPRINT);	×
UNCOV 137	}	×
138
139	@ParameterizedTest
140	@MethodSource("provideInstances")
141	public void assertNotBeforeThrowsNoSignature(SOP sop) {
142	byte[] message = TestData.ALICE_INLINE_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);	1✔
143	Date signatureDate = TestData.ALICE_INLINE_SIGNED_MESSAGE_DATE;	1✔
144	Date afterSignature = new Date(signatureDate.getTime() + 1000); // 1 sec before sig	1✔
145
146	assertThrows(SOPGPException.NoSignature.class, () -> assumeSupported(sop::inlineVerify)	1✔
147	.notBefore(afterSignature)	1✔
148	.cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))	1✔
149	.data(message)	1✔
150	.toByteArrayAndResult());	×
UNCOV 151	}	×
152
153	@ParameterizedTest
154	@MethodSource("provideInstances")
155	public void assertNotAfterThrowsNoSignature(SOP sop) {
156	byte[] message = TestData.ALICE_INLINE_SIGNED_MESSAGE.getBytes(StandardCharsets.UTF_8);	1✔
157	Date signatureDate = TestData.ALICE_INLINE_SIGNED_MESSAGE_DATE;	1✔
158	Date beforeSignature = new Date(signatureDate.getTime() - 1000); // 1 sec before sig	1✔
159
160	assertThrows(SOPGPException.NoSignature.class, () -> assumeSupported(sop::inlineVerify)	1✔
161	.notAfter(beforeSignature)	1✔
162	.cert(TestData.ALICE_CERT.getBytes(StandardCharsets.UTF_8))	1✔
163	.data(message)	1✔
164	.toByteArrayAndResult());	×
UNCOV 165	}	×
166
167	@ParameterizedTest
168	@MethodSource("provideInstances")
169	public void inlineSignVerifyBob(SOP sop) throws IOException {
170	byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);	1✔
171
172	byte[] inlineSigned = assumeSupported(sop::inlineSign)	1✔
173	.key(TestData.BOB_KEY.getBytes(StandardCharsets.UTF_8))	1✔
174	.data(message)	1✔
UNCOV 175	.getBytes();	×
176
UNCOV 177	JUtils.assertArrayStartsWith(inlineSigned, TestData.BEGIN_PGP_MESSAGE);	×
178
179	ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)	×
180	.cert(TestData.BOB_CERT.getBytes(StandardCharsets.UTF_8))	×
181	.data(inlineSigned)	×
UNCOV 182	.toByteArrayAndResult();	×
183
UNCOV 184	assertArrayEquals(message, bytesAndResult.getBytes());	×
185
186	List<Verification> verificationList = bytesAndResult.getResult();	×
187	VerificationListAssert.assertThatVerificationList(verificationList)	×
188	.isNotEmpty()	×
189	.hasSingleItem()	×
190	.issuedBy(TestData.BOB_SIGNING_FINGERPRINT, TestData.BOB_PRIMARY_FINGERPRINT);	×
UNCOV 191	}	×
192
193	@ParameterizedTest
194	@MethodSource("provideInstances")
195	@Disabled("Carol is a deprecated ElGamal key")
196	public void inlineSignVerifyCarol(SOP sop) throws IOException {
UNCOV 197	byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);	×
198
UNCOV 199	byte[] inlineSigned = assumeSupported(sop::inlineSign)	×
200	.key(TestData.CAROL_KEY.getBytes(StandardCharsets.UTF_8))	×
UNCOV 201	.data(message)	×
202	.getBytes();	×
203
204	JUtils.assertArrayStartsWith(inlineSigned, TestData.BEGIN_PGP_MESSAGE);	×
205
206	ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)	×
207	.cert(TestData.CAROL_CERT.getBytes(StandardCharsets.UTF_8))	×
UNCOV 208	.data(inlineSigned)	×
209	.toByteArrayAndResult();	×
210
211	assertArrayEquals(message, bytesAndResult.getBytes());	×
212
213	List<Verification> verificationList = bytesAndResult.getResult();	×
214	VerificationListAssert.assertThatVerificationList(verificationList)	×
215	.isNotEmpty()	×
216	.hasSingleItem()	×
UNCOV 217	.issuedBy(TestData.CAROL_SIGNING_FINGERPRINT, TestData.CAROL_PRIMARY_FINGERPRINT);	×
UNCOV 218	}	×
219
220	@ParameterizedTest
221	@MethodSource("provideInstances")
222	public void inlineSignVerifyProtectedKey(SOP sop) throws IOException {
223	byte[] message = TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8);	1✔
224
225	byte[] inlineSigned = assumeSupported(sop::inlineSign)	1✔
226	.withKeyPassword(TestData.PASSWORD)	1✔
227	.key(TestData.PASSWORD_PROTECTED_KEY.getBytes(StandardCharsets.UTF_8))	1✔
228	.mode(InlineSignAs.binary)	1✔
229	.data(message)	1✔
230	.getBytes();	×
231
232	ByteArrayAndResult<List<Verification>> bytesAndResult = assumeSupported(sop::inlineVerify)	×
233	.cert(TestData.PASSWORD_PROTECTED_CERT.getBytes(StandardCharsets.UTF_8))	×
UNCOV 234	.data(inlineSigned)	×
235	.toByteArrayAndResult();	×
236
237	List<Verification> verificationList = bytesAndResult.getResult();	×
238	VerificationListAssert.assertThatVerificationList(verificationList)	×
239	.hasSingleItem()	×
UNCOV 240	.issuedBy(TestData.PASSWORD_PROTECTED_SIGNING_FINGERPRINT, TestData.PASSWORD_PROTECTED_PRIMARY_FINGERPRINT);	×
UNCOV 241	}	×
242
243	}

pgpainless / sop-java / #68

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