httpReq.URL.Opaque = cfg.urlPath

	// Use the host header as the host.
	httpReq.Host = cfg.hostHeader

	// Copy the headers.
	httpReq.Header = cfg.headers.Clone()
	writeForwardedHeaders(&outBuffer, requestID, cfg.headers)

	// Propagate previous response cookies if any
	if cfg.PropagateResponse != nil {
		cfg.PropagateResponse(httpReq, cfg.previousResponse)
	}
	// Get the transport.

	}
	cfg := r.Cfg()

	// Only clear etcd data when using local etcd.
	klog.V(1).Infoln("[reset] Checking for etcd config")
	etcdManifestPath := filepath.Join(kubeadmconstants.KubernetesDir, kubeadmconstants.ManifestsSubDirName, "etcd.yaml")
	etcdDataDir, err := getEtcdDataDir(etcdManifestPath, cfg)
	if err == nil {
		if cfg != nil {
			if !r.DryRun() {

)

func TestCorrectArgs(t *testing.T) {
	g := NewWithT(t)

	m1 := &v1alpha3.VirtualService{}

	testSchema := schemaWithValidateFn(func(cfg config.Config) (warnings validation.Warning, errs error) {
		g.Expect(cfg.Name).To(Equal("name"))
		g.Expect(cfg.Namespace).To(Equal("ns"))
		g.Expect(cfg.Spec).To(Equal(m1))
		return nil, nil
	})
	ctx := &fixtures.Context{
		Resources: []*resource.Instance{
			{

	if !ok {
		return nil, nil, errors.New("upload-config phase invoked with an invalid data struct")
	}
	cfg := data.Cfg()
	client, err := data.Client()
	if err != nil {
		return nil, nil, err
	}
	return cfg, client, err

func SetJoinDynamicDefaults(cfg *kubeadmapi.JoinConfiguration, skipCRIDetect bool) error {
	addControlPlaneTaint := false
	if cfg.ControlPlane != nil {
		addControlPlaneTaint = true
	}
	if err := SetNodeRegistrationDynamicDefaults(&cfg.NodeRegistration, addControlPlaneTaint, skipCRIDetect); err != nil {
		return err
	}

	return SetJoinControlPlaneDefaults(cfg.ControlPlane)
}

	return pod.ObjectMeta.Labels[s.Label] == s.Value
}

func newPodSelector(cfg echo.Config) podSelector {
	label := "app"
	if cfg.DeployAsVM {
		label = constants.TestVMLabel
	}
	return podSelector{
		Label: label,
		Value: cfg.Service,
	}
}

func serviceAccount(cfg echo.Config) string {
	if cfg.ServiceAccount {
		return cfg.Service
	}
	if cfg.DeployAsVM {
		return "default"
	}
	return ""
}

	}

	if kp.config.ClusterCIDR == "" && cfg.Networking.PodSubnet != "" {
		kp.config.ClusterCIDR = cfg.Networking.PodSubnet
	} else if cfg.Networking.PodSubnet != "" && kp.config.ClusterCIDR != cfg.Networking.PodSubnet {
		warnDefaultComponentConfigValue(kind, "clusterCIDR", cfg.Networking.PodSubnet, kp.config.ClusterCIDR)
	}

	if kp.config.ClientConnection.Kubeconfig == "" {

	m := make(Map)
	v := cfgValidator{m: m}

	for _, cfg := range cfgs {
		p, err := newProfile(ctx, cfg, r, recorderFact, opts...)
		if err != nil {
			return nil, fmt.Errorf("creating profile for scheduler name %s: %v", cfg.SchedulerName, err)
		}
		if err := v.validate(cfg, p); err != nil {
			return nil, err
		}
		m[cfg.SchedulerName] = p
	}
	return m, nil
}

// unless it's already set to a value different from the default.
func SetKubernetesVersion(cfg *kubeadmapiv1.ClusterConfiguration) {

	if cfg.KubernetesVersion != kubeadmapiv1.DefaultKubernetesVersion && cfg.KubernetesVersion != "" {
		return
	}
	cfg.KubernetesVersion = version.Get().String()

import (
	"errors"
)

func AddInpodMarkIPRule(cfg *Config) error {
	return errors.New("not implemented on this platform")
}

func DelInpodMarkIPRule(cfg *Config) error {
	return errors.New("not implemented on this platform")
}

func AddLoopbackRoutes(cfg *Config) error {
	return errors.New("not implemented on this platform")
}

func DelLoopbackRoutes(cfg *Config) error {