exportedKeyRing.exists()
        def keyrings = SecuritySupport.loadKeyRingFile(exportedKeyRing)
        keyrings.size() == 2
        keyrings.find { it.publicKey.keyID == SigningFixtures.validPublicKey.keyID }
        keyrings.find { it.publicKey.keyID == keyring.publicKey.keyID }

        and: "also generates an ascii armored keyring file"

        } else {
            throw new IllegalArgumentException("Unknown keyring format " + keyringFormat);
        }
    }

    private static Collection<PGPPublicKeyRing> uniqueKeyRings(Stream<PGPPublicKeyRing> keyRings) {
        SortedMap<Long, PGPPublicKeyRing> seenKeyIds = new TreeMap<>();
        keyRings.forEach(keyRing -> {
            Long keyId = keyRing.getPublicKey().getKeyID();

                            @Override
                            public void keyRing(PGPPublicKeyRing keyring) {
                                missing.set(false);
                                builder.keyRing(keyring);
                                Iterator<PGPPublicKey> pkIt = keyring.getPublicKeys();
                                while (pkIt.hasNext()) {

     "email": %q,
     "auth": %q
   }
}`, test.globURL, email, auth)

		keyring := &BasicDockerKeyring{}
		if cfg, err := ReadDockerConfigFileFromBytes([]byte(sampleDockerConfig)); err != nil {
			t.Errorf("Error processing json blob %q, %v", sampleDockerConfig, err)
		} else {
			keyring.Add(cfg)
		}

		creds, ok := keyring.Lookup(test.targetURL + "/foo/bar")
		if !ok {

        generator
    }

    private static class Holder {
        static final KeyRing VALID_KEYRING = new KeyRing("gradle")
        static final KeyRing INVALID_KEYRING = new KeyRing("invalid-key-ring")
    }

    private static class KeyRing {
        private final PgpSignatory signatory
        private final PGPPublicKey publicKey
        private final PGPSecretKey secretKey

        "<keyring-format>armored</keyring-format>" | DependencyVerificationConfiguration.KeyringFormat.ARMORED
        "<keyring-format>binary</keyring-format>"  | DependencyVerificationConfiguration.KeyringFormat.BINARY
        ""                                         | null
    }

    def "reasonable error message when invalid invalid keyring format given"() {
        when:

		obj.RadosUser = "admin"
	}
	if obj.Keyring == "" {
		obj.Keyring = "/etc/ceph/keyring"
	}
}

func SetDefaults_RBDPersistentVolumeSource(obj *v1.RBDPersistentVolumeSource) {
	if obj.RBDPool == "" {
		obj.RBDPool = "rbd"
	}
	if obj.RadosUser == "" {
		obj.RadosUser = "admin"
	}
	if obj.Keyring == "" {
		obj.Keyring = "/etc/ceph/keyring"
	}
}

			if r.RBDPool == "" {
				r.RBDPool = "rbd"
			}
			r.RadosUser = c.RandString()
			if r.RadosUser == "" {
				r.RadosUser = "admin"
			}
			r.Keyring = c.RandString()
			if r.Keyring == "" {
				r.Keyring = "/etc/ceph/keyring"
			}
		},
		func(r *core.RBDPersistentVolumeSource, c fuzz.Continue) {
			r.RBDPool = c.RandString()
			if r.RBDPool == "" {
				r.RBDPool = "rbd"
			}

			nil,
		},
		"default keyring secrets": {
			"ubuntu",
			[]v1.Secret{},
			credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{
				"index.docker.io/v1/": {Username: "built-in", Password: "password", Provider: nil},
			}),
			&runtimeapi.AuthConfig{Username: "built-in", Password: "password"},
		},
		"default keyring secrets unused": {
			"ubuntu",
			[]v1.Secret{},

    }

    def "can declare keyring format"() {
        when:
        builder.setKeyringFormat("armored")
        serialize()

        then:
        contents == """<?xml version="1.0" encoding="UTF-8"?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>false</verify-signatures>
      <keyring-format>armored</keyring-format>
   </configuration>