},
		checks: []check{
			hasAttr("a", "b"),
			missingKey(""),
			hasAttr("c", "d"),
		},
	},
	{
		name:        "zero-time",
		explanation: withSource("a Handler should ignore a zero Record.Time"),
		f: func(l *slog.Logger) {
			l.Info("msg", "k", "v")
		},
		mod: func(r *slog.Record) { r.Time = time.Time{} },
		checks: []check{
			missingKey(slog.TimeKey),
		},
	},
	{
		name:        "WithAttrs",

            this.hasNoSignatures = hasNoSignatures;
        }

        void applyTo(SignatureVerificationResultBuilder builder) {
            if (missingKeys != null) {
                for (String missingKey : missingKeys) {
                    builder.missingKey(missingKey);
                }
            }
            if (trustedKeys != null) {
                for (PGPPublicKey trustedKey : trustedKeys) {

            }
            Map<String, SignatureVerificationFailure.SignatureError> errors = new HashMap<>();
            if (missingKeys != null) {
                for (String missingKey : missingKeys) {
                    errors.put(missingKey, error(null, SignatureVerificationFailure.FailureKind.MISSING_KEY));
                }
            }
            if (failedKeys != null) {

 * limitations under the License.
 */
package org.gradle.api.internal.artifacts.verification.signatures;

import org.bouncycastle.openpgp.PGPPublicKey;

public interface SignatureVerificationResultBuilder {
    void missingKey(String keyId);
    void verified(PGPPublicKey key, boolean trusted);
    void failed(PGPPublicKey pgpPublicKey);
    void ignored(String keyId);

    void noSignatures();

    public WriterSignatureVerificationResult(Set<String> ignoredKeys, PgpEntry entry) {
        this.ignoredKeys = ignoredKeys;
        this.entry = entry;
    }

    @Override
    public void missingKey(String keyId) {
        ignoredKeys.add(keyId);
        entry.missing();
    }

    @Override
    public void verified(PGPPublicKey key, boolean trusted) {
        String keyId = Fingerprint.of(key).toString();

//
// Known options:
//
// missingkey: Control the behavior during execution if a map is
// indexed with a key that is not present in the map.
//
//	"missingkey=default" or "missingkey=invalid"
//		The default behavior: Do nothing and continue execution.
//		If printed, the result of the index operation is the string
//		"<no value>".
//	"missingkey=zero"

    }

    @Override
    def cleanup() {
        keyServerFixture.stop()
    }

    protected void serveMissingKey(String keyId = SigningFixtures.validPublicKeyHexString) {
        keyServerFixture.missingKey(keyId)
    }

    protected void serveValidKey() {
        keyServerFixture.withDefaultSigningKey()
    }

    protected SimpleKeyRing newKeyRing(PGPPublicKey mustBeAfter = SigningFixtures.validPublicKey) {

                            throw UncheckedException.throwAsUncheckedException(e);
                        }
                    }
                });
                if (missing.get()) {
                    result.missingKey(longIdKey);
                }
            }
        }

        @Override
        public PublicKeyService getPublicKeyService() {
            return keyService;
        }

        @Override

		},
		{
			"MissingKeyOnNilMap",
			"{{.MissingKey}}",
			(*map[string]string)(nil),
			"nil pointer evaluating *map[string]string.MissingKey",
		},
		{
			"MissingKeyOnNilMapPtr",
			"{{.MissingKey}}",
			(*map[string]string)(nil),
			"nil pointer evaluating *map[string]string.MissingKey",
		},
		{
			"MissingKeyOnMapPtrToNil",
			"{{.MissingKey}}",
			&map[string]string{},
			"<nil>",

        then:
        1 * onChange.accept(key, newValue)

        where:
        key          | oldValue        | newValue
        'existing'   | 'existingValue' | 'changed'
        'missingKey' | null            | 'changed'
    }

    def "method put(#key, #newValue) updates map"() {
        given:
        def map = getMapUnderTestToWrite()

        when:
        map.put(key, newValue)