limitations under the License.
*/

package apiclient

import (
	"reflect"
	"testing"

	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
)

func TestGetControlPlaneComponents(t *testing.T) {
	testcases := []struct {
		name     string
		cfg      *kubeadmapi.ClusterConfiguration
		expected []controlPlaneComponent
	}{
		{
			name: "port values from config",
			cfg: &kubeadmapi.ClusterConfiguration{

	line := strings.Repeat("a", blockSize)
	testBytes := []byte(line + "\n" +
		line + "\n" +
		line + "\n" +
		line + "\n" +
		line[blockSize/2:]) // incomplete line

	file.Write(testBytes)
	testCases := []struct {
		name          string
		max           int64
		longerThanMax bool
		expected      string
	}{
		{
			name:          "the max is negative",
			max:           -1,
			longerThanMax: true,

			},
			expectedError: nil,
			machineInfo:   machineInfo,
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.description, func(t *testing.T) {
			res, err := getSystemReservedMemory(&testCase.machineInfo, testCase.nodeAllocatableReservation, testCase.systemReservedMemory)

			if !reflect.DeepEqual(res, testCase.expectedReserved) {

		select {
		case event := <-recorder.Events:
			return event
		default:
			return ""
		}
	}
)

func TestParseResolvConf(t *testing.T) {
	testCases := []struct {
		data        string
		nameservers []string
		searches    []string
		options     []string
		isErr       bool
	}{
		{"", []string{}, []string{}, []string{}, false},

                List<XCTestCaseElement> testCases = [
                    testCase(failingTestCaseName, FAILING_TEST, true),
                    passingTestCase(passingTestCaseName)
                ]
            }.withImport(libcModuleName),

            new XCTestSourceFileElement("SomeOtherTest") {
                List<XCTestCaseElement> testCases = [
                    passingTestCase(passingTestCaseName)

			equal: false,
		},
	}

	for i, testCase := range testCases {
		if compareThresholdValue(testCase.a, testCase.b) != testCase.equal ||
			compareThresholdValue(testCase.b, testCase.a) != testCase.equal {
			t.Errorf("Test case: %v failed", i)
		}
	}
}
func TestAddContainerFsThresholds(t *testing.T) {
	gracePeriod := time.Duration(1)
	testCases := []struct {
		description                   string

		}
	}

	toObjectNames := func(testCases []testCaseType) []ObjectToDelete {
		names := make([]ObjectToDelete, len(testCases))
		for i := range testCases {
			names[i] = ObjectToDelete{
				ObjectV: ObjectV{
					ObjectName: testCases[i].object,
				},
			}
		}
		return names
	}

	objectNames := toObjectNames(testCases)

	EncryptionProviderConfig     string
	CloudKMSIntegration          bool
}

func TestEncryptionProviderFlag(t *testing.T) {
	var (
		encryptionConfigFlag = "--encryption-provider-config"
	)

	testCases := []struct {
		desc                     string
		encryptionProviderConfig string
		wantFlag                 bool
	}{
		{
			desc:                     "ENCRYPTION_PROVIDER_CONFIG is set",

}

func TestGetPauseImage(t *testing.T) {
	testcases := []struct {
		name     string
		cfg      *kubeadmapi.ClusterConfiguration
		expected string
	}{
		{
			name: "pause image defined",
			cfg: &kubeadmapi.ClusterConfiguration{
				ImageRepository: "test.repo",
			},
			expected: "test.repo/pause:" + constants.PauseVersion,
		},
	}
	for _, tc := range testcases {
		t.Run(tc.name, func(t *testing.T) {

func TestValidateUnhealthyPodEvictionPolicyDisruptionBudgetSpec(t *testing.T) {
	c1 := intstr.FromString("10%")
	alwaysAllowPolicy := policy.AlwaysAllow
	invalidPolicy := policy.UnhealthyPodEvictionPolicyType("Invalid")

	testCases := []struct {
		name      string
		pdbSpec   policy.PodDisruptionBudgetSpec
		expectErr bool
	}{{
		name: "valid nil UnhealthyPodEvictionPolicy",
		pdbSpec: policy.PodDisruptionBudgetSpec{