if err != nil {
					return err
				}
				pod, err := kubeClient.Kube().CoreV1().Pods(podNs).Get(context.TODO(), podName, metav1.GetOptions{})
				if err != nil {
					return err
				}
				ns, err := kubeClient.Kube().CoreV1().Namespaces().Get(context.TODO(), podNs, metav1.GetOptions{})
				if err != nil {
					return err
				}
				podLabels = pod.GetLabels()
				nsLabels = ns.GetLabels()
			} else {

					ObjectMeta: metav1.ObjectMeta{
						Name: IstioNamespace,
					},
				}, metav1.CreateOptions{}); err != nil {
					_, err := cs.Kube().CoreV1().Namespaces().Get(context.TODO(), IstioNamespace, metav1.GetOptions{})
					if err == nil {
						log.Info("istio namespace already exist")
					} else {
						t.Errorf("failed to create istio namespace: %v", err)
					}
				}
				iopCRFile = filepath.Join(workDir, "iop_cr.yaml")

	if service == "" {
		return
	}

	cs := t.AllClusters()
	for _, c := range cs {
		oldSvc, err := c.Kube().CoreV1().Services(ns.Name()).Get(t.Context(), service, metav1.GetOptions{})
		if err != nil {
			t.Fatalf("error getting svc %s, err %v", service, err)
		}
		oldLabels := oldSvc.ObjectMeta.GetLabels()
		if oldLabels == nil {
			oldLabels = make(map[string]string, 1)
		}

                outputFileProperties.add(new DefaultOutputFileProperty(propertyName, files, type));
            }
        });
        return new DefaultTestTaskProperties(
            task.getOptions() instanceof JUnitPlatformOptions,
            task.getForkEvery(),
            task.getDryRun().get(),
            collectFilters(task),
            collectForkOptions(task),

	if len(needToReport) != 0 {
		t.Fatalf("len(asw.GetVolumesToReportAttached()) Expected: <0> Actual: <%v>", len(needToReport))
	}

	node, err := fakeKubeClient.CoreV1().Nodes().Get(ctx, "testnode-1", metav1.GetOptions{})
	if err != nil {
		t.Fatalf("Nodes().Get failed. Expected: <no error> Actual: <%v>", err)
	}
	if len(node.Status.VolumesAttached) != 1 {

	t.Helper()
	retry.UntilSuccessOrFail(t, func() error {
		got, err := client.Dynamic().Resource(mcs.ServiceExportGVR).Namespace(ns).Get(context.TODO(), name, metav1.GetOptions{})

		if err != nil && !strings.Contains(err.Error(), "not found") {
			return fmt.Errorf("unexpected error %v", err)
		}
		isPresent := got != nil
		if isPresent != shouldBePresent {

public interface ScaladocParameters extends WorkParameters {
    RegularFileProperty getOptionsFile();

    ConfigurableFileCollection getClasspath();

    DirectoryProperty getOutputDirectory();

    ListProperty<String> getOptions();

    ConfigurableFileCollection getSources();

    Property<Boolean> getIsScala3();

		if ip == "" {
			return nil, false, fmt.Errorf("no Host IP available on the remote service node yet")
		}

		svc, err := cluster.Kube().CoreV1().Services(ns).Get(context.TODO(), svcName, metav1.GetOptions{})
		if err != nil {
			return nil, false, err
		}

		if len(svc.Spec.Ports) == 0 {
			return nil, false, fmt.Errorf("no ports found in service: %s/%s", ns, svcName)
		}

		var nodePort int32

	var endpoints *corev1.Endpoints
	err := retry.UntilSuccess(func() error {
		s, err := a.CoreV1().Services(ns).Get(context.TODO(), name, metav1.GetOptions{})
		if err != nil {
			return err
		}

		eps, err := a.CoreV1().Endpoints(ns).Get(context.TODO(), name, metav1.GetOptions{})
		if err != nil {
			return err
		}
		if len(eps.Subsets) == 0 {
			return fmt.Errorf("%s/%v endpoint not ready: no subsets", ns, name)

	// we don't destroy it here explicitly.
}

// Get retrieves the object from the storage. It is required to support Patch.
func (r *StatusREST) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
	return r.store.Get(ctx, name, options)
}

// Update alters the status subset of an object.