// Such test is sufficient to detect e.g. missing kubelet dependencies that are not added in
// pkg/kubemark/hollow_kubelet.go.
func TestHollowNode(t *testing.T) {
	// temp dir
	tmpDir, err := os.MkdirTemp("", "hollow-node")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tmpDir)

	// https server
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {

	}

	if _, ok := certTree[selfSigned]; !ok {
		t.Error("Expected selfSigned to be present in tree, but missing")
	}
}

func TestCreateCertificateChain(t *testing.T) {
	dir, err := os.MkdirTemp("", t.Name())
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(dir)

	ic := &kubeadmapi.InitConfiguration{
		NodeRegistration: kubeadmapi.NodeRegistrationOptions{
			Name: "test-node",
		},

	if runtime.GOOS == "wasip1" {
		t.Skip("no support for file permissions on " + runtime.GOOS)
	}
	t.Parallel()

	// We don't want to use CreateTemp directly, since that opens a file for us as 0600.
	tempDir, err := MkdirTemp("", t.Name())
	if err != nil {
		t.Fatal(err)
	}
	defer RemoveAll(tempDir)
	filename := filepath.Join(tempDir, "blurp.txt")

	shmorp := []byte("shmorp")
	florp := []byte("florp")

  make -C "${KUBE_ROOT}" WHAT="cmd/kube-controller-manager"

  # Start controller manager
  kube::log::status 'Generate kubeconfig for controller-manager'
  local config
  config="$(mktemp controller-manager.kubeconfig.XXXXX)"
  cat <<EOF > "$config"
kind: Config
users:
- name: controller-manager
  user:
    token: admin-token
clusters:
- cluster:

	}

	pod := v1.Pod{
		Spec: v1.PodSpec{
			HostNetwork: true,
		},
	}

	fhu := hostutil.NewFakeHostUtil(nil)
	fsp := &subpath.FakeSubpath{}
	podDir, err := os.MkdirTemp("", "test-rotate-logs")
	require.NoError(t, err)
	defer os.RemoveAll(podDir)
	mounts, _, err := makeMounts(&pod, podDir, &container, "fakepodname", "", []string{""}, podVolumes, fhu, fsp, nil, false)
	require.NoError(t, err)

	defer f.Unlock()
	f.events = append(f.events, "deregister "+pluginName)
}

func (f *fakePluginHandler) Reset() {
	f.Lock()
	defer f.Unlock()
	f.events = nil
}

func init() {
	d, err := os.MkdirTemp("", "plugin_manager_test")
	if err != nil {
		panic(fmt.Sprintf("Could not create a temp directory: %s", d))
	}

	socketDir = d
}

func cleanup(t *testing.T) {
	require.NoError(t, os.RemoveAll(socketDir))

			return true
		}

		if mountPath == "" {
			klog.ErrorS(errors.New("mount path is empty, falling back to /tmp"), "")
		}

		mountPath, err = os.MkdirTemp(mountPath, "tmpfs-noswap-test-")
		if err != nil {
			klog.InfoS("error creating dir to test if tmpfs noswap is enabled. Assuming not supported", "mount path", mountPath, "error", err)
			return false
		}

								{MountPath: "foo/../../dir/skip", Name: "vol10"},
							},
						},
					},
				},
			},
		},
	}
	for _, test := range tc {
		dir, err := os.MkdirTemp("", "TestMakeNestedMountpoints.")
		if err != nil {
			t.Errorf("Unexpected error trying to create temp directory: %v", err)
			return
		}
		defer os.RemoveAll(dir)

		rootdir := filepath.Join(dir, "vol")

			}
		}
		if len(errors) == 0 {
			t.Fatalf("cannot find ERROR HERE")
		}
		expect(t, file, errors)
	})
}

func expect(t *testing.T, file string, errors []*regexp.Regexp) {
	dir, err := os.MkdirTemp("", filepath.Base(t.Name()))
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(dir)

	dst := filepath.Join(dir, strings.TrimSuffix(file, ".go"))

		},
	}

	for name, test := range tests {
		t.Run(name, func(t *testing.T) {
			t.Logf("Running test: %s", name)

			// Create a temporary directory for our fake config dir:
			tmpDir, err := os.MkdirTemp("", "kubeadm-reset-test")
			if err != nil {
				t.Errorf("Unable to create temporary directory: %s", err)
			}

			for _, createDir := range test.setupDirs {