}

    def "parses configuration (metadata=#verifyMetadata, signatures=#verifySignatures)"() {
        when:
        parse """<?xml version="1.0" encoding="UTF-8"?>
<verification-metadata>
   <configuration>
      <verify-metadata>$verifyMetadata</verify-metadata>
      <verify-signatures>$verifySignatures</verify-signatures>
   </configuration>
</verification-metadata>
"""
        then:

        and:
        jar in signJar.dependsOn
        sourcesJar in signSourcesJar.dependsOn
        javadocJar in signJavadocJar.dependsOn

        and:
        signingTasks.every { it.singleSignature in configurations.signatures.artifacts }

        and:
        signingTasks.every { it.signatory == signing.signatory }
    }

    def "sign method return values"() {
        given:
        useJavadocAndSourceJars()

        when:

        symbol: KaFunctionLikeSymbol,
        signature: KaFunctionLikeSignature<*>,
        substitutor: KaSubstitutor,
        testServices: TestServices,
    ) {
        testServices.assertions.assertEquals(symbol.receiverType?.let(substitutor::substitute), signature.receiverType)
        testServices.assertions.assertEquals(symbol.returnType.let(substitutor::substitute), signature.returnType)

	if err != nil {
		t.Fatal(err)
	}
	_, err = asn1.Marshal(k.PublicKey)
	if err != nil {
		t.Fatal(err)
	}
}

func TestBoringVerify(t *testing.T) {
	// Check that signatures that lack leading zeroes don't verify.
	key := &PublicKey{

        output1.exists() && output2.exists()
        [input1, input2] == operation.filesToSign.files.toList()[0..1]
        [output1, output2] == operation.signatureFiles.files.toList()[0..1]
        [output1, output2] == operation.signatures*.file.toList()
    }

    def "sign multiple artifacts with defaults"() {
        when:
        def operation = signing.sign(input1Artifact, input2Artifact)
        
        then:

// Package stdmethods defines an Analyzer that checks for misspellings
// in the signatures of methods similar to well-known interfaces.
//
// # Analyzer stdmethods
//
// stdmethods: check signature of methods of well-known interfaces
//
// Sometimes a type may be intended to satisfy an interface but may fail to
// do so because of a mistake in its method signature.
// For example, the result of this WriteTo method should be (int64, error),

 */

package org.jetbrains.kotlin.analysis.api.signatures

import org.jetbrains.kotlin.analysis.api.symbols.KaFunctionLikeSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KaValueParameterSymbol
import org.jetbrains.kotlin.analysis.api.types.KaSubstitutor

/**
 * A signature of a function-like symbol. This includes functions, getters, setters, lambdas, etc.
 */

// the target interface T. This occurs when V and T contain methods with the same
// name but different signatures. Example:
//
//	var v interface {
//		Read()
//	}
//	_ = v.(io.Reader)
//
// The Read method in v has a different signature than the Read method in
// io.Reader, so this assertion cannot succeed.

	signature := calculateSignatureV2(stringToSign, cred.SecretKey)
	return signature
}

// compareSignatureV2 returns true if and only if both signatures
// are equal. The signatures are expected to be base64 encoded strings
// according to the AWS S3 signature V2 spec.
func compareSignatureV2(sig1, sig2 string) bool {
	// Decode signature string to binary byte-sequence representation is required

    @Override
    public File getSignatureFile() {
        return signatureFile;
    }

    @Override
    public void explainTo(TreeFormatter formatter) {
        formatter.append("artifact has signature file, but it contains no valid signatures");
    }