}
        if (optionsFile != null) {
            args.add("--options");
            args.add(optionsFile.getAbsolutePath());
        }
        if (keyName != null) {
            args.add("--local-user");
            args.add(keyName);
        }
        if (passphrase != null) {
            if (useLegacyGpg) {
                args.add("--no-use-agent");
            } else {

		rsa = 0
		ecdsa = 0
		lastTest = thisTest
	}

	keyName := ""
	switch keyType {
	case kubeadmapi.EncryptionAlgorithmECDSAP256:
		ecdsa++
		keyName = fmt.Sprintf("%d.ecdsa", ecdsa)
	default:
		rsa++
		keyName = fmt.Sprintf("%d.rsa", rsa)
	}

	if len(keyName) > 0 {
		privKey, err := pkiutil.TryLoadKeyFromDisk(fixtureDir, keyName)
		if err == nil {
			return privKey, nil
		}
	}

        Object optionsFile = project.findProperty(buildQualifiedProperty(propertyPrefix, "optionsFile"));
        Object keyName = project.findProperty(buildQualifiedProperty(propertyPrefix, "keyName"));
        Object passphrase = project.findProperty(buildQualifiedProperty(propertyPrefix, "passphrase"));
        GnupgSettings settings = new GnupgSettings();
        if (executable != null) {

        this.optionsFile = optionsFile;
    }

    public File getOptionsFile() {
        return optionsFile;
    }

    public void setKeyName(String keyName) {
        this.keyName = keyName;
    }

    public String getKeyName() {
        return keyName;
    }

    public void setPassphrase(String passphrase) {
        this.passphrase = passphrase;
    }

    public String getPassphrase() {

## For the release team

The `relnote` tool, at `golang.org/x/build/cmd/relnote`, operates on the files
in `doc/next`.

As a release cycle nears completion, run `relnote todo` to get a list of
unfinished release note work.

To prepare the release notes for a release, run `relnote generate`.
That will merge the `.md` files in `next` into a single file.

        for (int i = 0; i < params.length; i++) {
            String keyName = keyNames[i];
            boolean optional = optionals[i];
            Class<?> type = parameterTypes[i];
            Object value;
            if (type == String.class) {
                value = get(mutableValues, keyName);
            } else {
                value = type.cast(mutableValues.get(keyName));
            }
            if (!optional && value == null) {

        val keyTransformation = mappingConversionForKeys.convertExpression(keyName, context.increaseIndent())
        val valueTransformation = mappingConversionForValues.convertExpression(valueName, context.increaseIndent())
        return buildString {
            appendLine("$expression.mapKeys { ($keyName, _) ->")
            appendLine(keyTransformation.withIndent(context.increaseIndent()))

func TestCertOrKeyNameToSecretName(t *testing.T) {
	tests := []struct {
		keyName            string
		expectedSecretName string
	}{
		{
			keyName:            "apiserver-kubelet-client.crt",
			expectedSecretName: "apiserver-kubelet-client.crt",
		},
		{
			keyName:            "etcd/ca.crt",
			expectedSecretName: "etcd-ca.crt",
		},
		{
			keyName:            "etcd/healthcheck-client.crt",

// license that can be found in the LICENSE file.

package main

import (
	"flag"
	"internal/testenv"
	"io/fs"
	"os"
	"path/filepath"
	"testing"

	"golang.org/x/build/relnote"
)

var flagCheck = flag.Bool("check", false, "run API release note checks")

// Check that each file in api/next has corresponding release note files in doc/next.
func TestCheckAPIFragments(t *testing.T) {

// tag::user-properties[]
signing.gnupg.executable=gpg
signing.gnupg.useLegacyGpg=true
signing.gnupg.homeDir=gnupg-home
signing.gnupg.optionsFile=gnupg-home/gpg.conf
signing.gnupg.keyName=24875D73
signing.gnupg.passphrase=gradle