ctx, cancel := context.WithTimeout(ctx, g.callTimeout)
	defer cancel()

	request := &kmsapi.EncryptRequest{
		Plaintext: plaintext,
		Uid:       uid,
	}
	response, err := g.kmsClient.Encrypt(ctx, request)
	if err != nil {
		return nil, err
	}
	return &kmsservice.EncryptResponse{
		Ciphertext:  response.Ciphertext,

        }

        this.effectiveKeyringsFile = effectiveFile;
        if (effectiveFile.exists()) {
            this.keyService = new KeyringFilePublicKeyService(effectiveKeyringsFile);
        } else {
            this.keyService = null;
        }
    }

    public File getBinaryKeyringsFile() {
        return new File(keyringsRoot, VERIFICATION_KEYRING_GPG);
    }

        @interface MyQualifier {}

        interface MyService {}

        @Named
        @Priority(10)
        static class MyNamedServiceImpl implements MyService {}

        @MyQualifier
        static class MyQualifiedServiceImpl implements MyService {}

        @Named
        static class MyMojo {
            @Inject
            @MyQualifier
            MyService service;
        }
    }

    @Test

    }

    private static class DefaultSignatureVerificationService implements SignatureVerificationService {
        private final PublicKeyService keyService;

        public DefaultSignatureVerificationService(PublicKeyService keyService) {
            this.keyService = keyService;
        }

        @Override

        def provider = factory.provide(PasswordCredentials, 'myService')

        when:
        provider.get()

        then:
        def e = thrown(MissingValueException)
        e.message.contains("The following Gradle properties are missing for 'myService' credentials:")
        e.message.contains("- myServiceUsername")
        e.message.contains("- myServicePassword")
    }

    private final PublicKeyService keyService;
    private final File signatureFile;

    public SignatureVerificationFailure(File affectedFile, File signatureFile, Map<String, SignatureError> errors, PublicKeyService keyService) {
        super(affectedFile);
        this.errors = errors;
        this.keyService = keyService;
        this.signatureFile = signatureFile;
    }

    @Override

	explicitName bool
}

func findServiceTargetPort(servicePort *model.Port, k8sService *v1.Service) serviceTargetPort {
	for _, p := range k8sService.Spec.Ports {
		// TODO(@hzxuzhonghu): check protocol as well as port
		if p.Name == servicePort.Name || p.Port == int32(servicePort.Port) {

                }

                @Override
                public void apply(Settings project) {
                    def projectDir = project.rootDir
                    def vfsService = project.gradle.services.get(VirtualFileSystem)
                    def projectDirAsResultOfBuild = flowProviders.buildWorkResult.map { projectDir }
                    flowScope.always(
                        VfsAction.class,

apiVersion: v1
kind: Pod
metadata:
  name: mypod
  namespace: default
spec:
  containers:
  - name: mycontainer
    image: nginx
---
apiVersion: v1
metadata:
  name: myservice
  namespace: default
spec:
  selector:

apiVersion: v1
kind: Pod
metadata:
  name: mypod
  namespace: default
spec:
  containers:
  - name: mycontainer
    image: nginx
---
apiVersion: v1
kind: Service
metadata:
  name: myservice
  namespace: default
spec:
  selector:
    app: MyApp
  ports:
  - protocol: TCP
    port: 80