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() {

		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
		}
	}

                value = get(mutableValues, keyName);
            } else {
                value = type.cast(mutableValues.get(keyName));
            }
            if (!optional && value == null) {
                if (missing == null) {
                    missing = new TreeSet<>();
                }
                missing.add(keyName);
            }
            mutableValues.remove(keyName);
            params[i] = value;
        }

        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) {

        }
        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 {

        expect(httpStub)
    }

    def stubMultipartUpload(String bucketName, String keyName, File file) {
        stubInitiateMultipartUpload(bucketName, keyName)
        stubUploadPart(bucketName, keyName, file)
        stubCompleteMultipartUpload(bucketName, keyName, file)
    }

    def stubInitiateMultipartUpload(String bucketName, String keyName) {
        def xml = new StreamingMarkupBuilder().bind {

        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",

                sign(jar)
            }
        """

        // Remove the 'signing.gnupg.keyName' entry from the gradle.properties file, so the default key is picked up
        Properties properties = new Properties()
        properties.load(propertiesFile.newInputStream())
        properties.remove("signing.gnupg.keyName")
        properties.store(propertiesFile.newOutputStream(), "")

        when:
        run "signJar", "-i"

// 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