}{
		{
			desc: "Strip password from error message",
			in:   "http://user:password@dummy.faketld/",
			out:  `Get "http://user:***@dummy.faketld/": dummy impl`,
		},
		{
			desc: "Don't Strip password from domain name",
			in:   "http://user:password@password.faketld/",
			out:  `Get "http://user:***@password.faketld/": dummy impl`,
		},
		{
			desc: "Don't Strip password from path",

		}
		cmdArgs := args[1:]
		if !sameArgs(cmdArgs, expectedArgs) {
			t.Errorf("Wrong args for %s: got %v, expected %v", args[0], cmdArgs, expectedArgs)
		}
		return &exectesting.FakeCmd{
			Argv:                 args,
			CombinedOutputScript: []exectesting.FakeAction{output},
		}
	}
}

func fakeRunner(fakeCommands ...exectesting.FakeCommandAction) exec.Interface {
	return &exectesting.FakeExec{

				},
			},
		}
		services = append(services, service)
		fakeInformerFactory.Core().V1().Services().Informer().GetStore().Add(service)
	}
	var pods []*v1.Pod
	for i := 0; i < 5; i++ {
		pod := st.MakePod().Name(fmt.Sprintf("test-pod-%d", i)).
			Namespace("test").
			Label("app", fmt.Sprintf("test-%d", i)).
			Label("label", fmt.Sprintf("label-%d", i)).
			Obj()
		pods = append(pods, pod)
	}

	tests := []struct {

func TestCreatePodSandbox(t *testing.T) {
	ctx := context.Background()
	fakeRuntime, _, m, err := createTestRuntimeManager()
	require.NoError(t, err)
	pod := newTestPod()

	fakeOS := m.osInterface.(*containertest.FakeOS)
	fakeOS.MkdirAllFn = func(path string, perm os.FileMode) error {
		// Check pod logs root directory is created.
		assert.Equal(t, filepath.Join(testPodLogsDirectory, pod.Namespace+"_"+pod.Name+"_12345678"), path)

	}

	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	fakeOS := &kubecontainertest.FakeOS{}
	fakeOS.ReadDirFn = func(path string) ([]os.DirEntry, error) {
		var dirEntries []os.DirEntry
		mockDE := kubecontainertest.NewMockDirEntry(ctrl)
		switch path {

	for _, script := range scripts {
		fakeCmd := &testingexec.FakeCmd{}
		cmdAction := makeFakeCmd(fakeCmd, script.Cmd, script.Args...)
		outputAction := makeFakeOutput(script.Output, script.ReturnCode)
		fakeCmd.CombinedOutputScript = append(fakeCmd.CombinedOutputScript, outputAction)
		fe.CommandScript = append(fe.CommandScript, cmdAction)
	}
}

				t.Errorf("expected: %#v, got: %#v", test.expected, test.resource)
			}
		})
	}
}

func TestNewNodeInfo(t *testing.T) {
	nodeName := "test-node"
	pods := []*v1.Pod{
		st.MakePod().UID("test-1").Namespace("node_info_cache_test").Name("test-1").Node(nodeName).
			Containers([]v1.Container{st.MakeContainer().ResourceRequests(map[v1.ResourceName]string{
				v1.ResourceCPU:    "100m",

		runPreFilter        bool
	}{
		{
			name: "missing labels",
			pod: st.MakePod().NodeSelector(map[string]string{
				"foo": "bar",
			}).Obj(),
			wantStatus:   framework.NewStatus(framework.UnschedulableAndUnresolvable, ErrReasonPod),
			runPreFilter: true,
		},
		{
			name: "same labels",
			pod: st.MakePod().NodeSelector(map[string]string{
				"foo": "bar",
			}).Obj(),
			labels: map[string]string{

}, mounter volume.Mounter) []error {
	expecteds := scenario.expecteds
	allErrs := []error{}

	// Construct combined outputs from expected commands
	var fakeOutputs []fakeexec.FakeAction
	var fcmd fakeexec.FakeCmd
	for _, expected := range expecteds {
		expected := expected
		if expected.cmd[1] == "clone" {
			// Calculate the subdirectory clone would create (if any)

	pvcb.PersistentVolumeClaim.Status = v1.PersistentVolumeClaimStatus{
		Phase: phase,
	}
	return pvcb
}

type podBuilder struct {
	*v1.Pod
}

func makePod(name string) podBuilder {
	pb := podBuilder{Pod: &v1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: v1.NamespaceDefault,
		},
	}}
	pb.Pod.Spec.Volumes = make([]v1.Volume, 0)