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{

// https://github.com/tensorflow/tensorflow/blob/9bcefa44cd335c1db4a703a13da09f29ae1bbdb2/tensorflow/core/protobuf/saved_object_graph.proto#L60
// Additionally they are guaranteed to be children of the .signatures attribute
// of the root object, where the child object "name" is the signature_def key:

        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.

    /**
     * @return whether signatures are supported but not required
     * @throws SmbException
     */
    boolean isSigningOptional () throws SmbException;


    /**
     * @return whether signatures are enforced from either side
     * @throws SmbException
     */
    boolean isSigningEnforced () throws SmbException;

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

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

      },
      R"pbdoc(
        Converts a TensorFlow SavedModel into StableHLO bytecode.

        * input-path: The path to the input TensorFlow SavedModel.
        * exported-model-signatures: Comma-separated list of exported model
          signatures to convert.
        * tag_names: Comma-separated list of tags for loading SavedModel.
        * input-arg-shapes: A string representation of input argument shapes for