description     string
		toleration      Toleration
		taint           Taint
		expectTolerated bool
	}{
		{
			description: "toleration and taint have the same key and effect, and operator is Exists, and taint has no value, expect tolerated",
			toleration: Toleration{
				Key:      "foo",
				Operator: TolerationOpExists,
				Effect:   TaintEffectNoSchedule,
			},
			taint: Taint{
				Key:    "foo",
				Effect: TaintEffectNoSchedule,

		},
		{
			taint: &Taint{
				Key: "foo",
			},
			expectedString: "foo",
		},
		{
			taint: &Taint{
				Key:   "foo",
				Value: "bar",
			},
			expectedString: "foo=bar:",
		},
	}

	for i, tc := range testCases {
		if tc.expectedString != tc.taint.ToString() {
			t.Errorf("[%v] expected taint %v converted to %s, got %s", i, tc.taint, tc.expectedString, tc.taint.ToString())
		}
	}
}

//     this combination means to match all taint values and all taint keys.
func (t *Toleration) ToleratesTaint(taint *Taint) bool {
	if len(t.Effect) > 0 && t.Effect != taint.Effect {
		return false
	}

	if len(t.Key) > 0 && t.Key != taint.Key {
		return false
	}

	// TODO: Use proper defaulting when Toleration becomes a field of PodSpec
	switch t.Operator {
	// empty operator means Equal
	case "", TolerationOpEqual:

	tests := []struct {
		name     string
		taint    *v1.Taint
		expected bool
	}{
		{
			name: "should include the taints with NoSchedule effect",
			taint: &v1.Taint{
				Effect: v1.TaintEffectNoSchedule,
			},
			expected: true,
		},
		{
			name: "should include the taints with NoExecute effect",
			taint: &v1.Taint{
				Effect: v1.TaintEffectNoExecute,
			},
			expected: true,
		},

		return
	}
	// We should not see any taint on the node(especially the Not-Ready taint with NoExecute effect).
	if taintutils.TaintExists(node3.Spec.Taints, NotReadyTaintTemplate) || len(node3.Spec.Taints) > 0 {
		t.Errorf("Found taint %v in %v, which should not be present", NotReadyTaintTemplate, node3.Spec.Taints)
	}
}

// TestApplyNoExecuteTaintsToNodesEnqueueTwice ensures we taint every node with NoExecute even if enqueued twice

			node: nodeWithTaints("nodeA", []v1.Taint{{Key: "foo", Value: "bar", Effect: "NoSchedule"}}),
			wantStatus: framework.NewStatus(framework.UnschedulableAndUnresolvable,
				"node(s) had untolerated taint {foo: bar}"),
		},
		{
			name: "The pod has a toleration that keys and values match the taint on the node, the effect of toleration is empty, " +
				"and the effect of taint is NoSchedule. Pod can be scheduled onto the node",

		markControlPlaneNode(n, taints)
	})
}

func taintExists(taint v1.Taint, taints []v1.Taint) bool {
	for _, t := range taints {
		if t == taint {
			return true
		}
	}

	return false
}

func markControlPlaneNode(n *v1.Node, taints []v1.Taint) {
	for _, label := range labelsToAdd {
		n.ObjectMeta.Labels[label] = ""
	}

	for _, nt := range n.Spec.Taints {

	// a new node may receive the taint with some delay causing pods to be
	// scheduled on a not-ready node. Node controller will remove the taint
	// when the node becomes ready.
	addNotReadyTaint(node)
	return nil
}

func addNotReadyTaint(node *api.Node) {
	notReadyTaint := api.Taint{
		Key:    v1.TaintNodeNotReady,
		Effect: api.TaintEffectNoSchedule,
	}
	for _, taint := range node.Spec.Taints {

			},
			existingTaints: []v1.Taint{kubeadmconstants.ControlPlaneTaint},
			newTaints:      []v1.Taint{kubeadmconstants.ControlPlaneTaint},
			expectedPatch:  `{}`,
		},
		{
			name: "has taint and no new taints wanted",
			existingLabels: []string{
				kubeadmconstants.LabelNodeRoleControlPlane,
				kubeadmconstants.LabelExcludeFromExternalLB,
			},
			existingTaints: []v1.Taint{
				{

		operation      admission.Operation
		options        runtime.Object
		expectedTaints []api.Taint
	}{
		{
			name:           "notReady taint is added on creation",
			node:           myNodeObj,
			operation:      admission.Create,
			options:        &metav1.CreateOptions{},
			expectedTaints: []api.Taint{notReadyTaint},
		},
		{
			name:           "already tainted node is not tainted again",