)

func TestFindPortByName(t *testing.T) {
	t.Parallel()
	type args struct {
		container *v1.Container
		portName  string
	}
	tests := []struct {
		name    string
		args    args
		want    int
		wantErr bool
	}{
		{
			name: "get port from exist port name",
			args: args{
				container: &v1.Container{
					Ports: []v1.ContainerPort{
						{
							Name:          "foo",
							ContainerPort: 8080,

            "create(String)": { container.create("b") },
            "create(String, Action)": { container.create("b", Actions.doNothing()) },
            "register(String)": { container.register("b") },
            "register(String, Action)": { container.register("b", Actions.doNothing()) },
            "NamedDomainObjectProvider.configure(Action)": { container.named("a").configure(Actions.doNothing()) }
        ]
    }

```sh
docker ps -a
```

`-a` flag makes sure you get all the containers (Created, Running, Exited). Then identify the `Container ID` from the output.

### Starting and Stopping Containers

To start a stopped container, you can use the [`docker start`](https://docs.docker.com/engine/reference/commandline/start/) command.

```sh
docker start <container_id>
```

		desc          string
		pod           *v1.Pod
		container     *v1.Container
		wantRunAsUser *int64
	}{
		{
			desc: "no securityContext in pod, no securityContext in container",
			pod: &v1.Pod{
				Spec: v1.PodSpec{},
			},
			container:     &v1.Container{},
			wantRunAsUser: nil,
		},
		{
			desc: "no runAsUser in pod, no runAsUser in container",
			pod: &v1.Pod{
				Spec: v1.PodSpec{

            "create(String, Class)": { container.create("b", container.type) },
            "create(String, Class, Action)": { container.create("b", container.type, Actions.doNothing()) },
            "register(String, Class)": { container.register("b", container.type) },
            "register(String, Class, Action)": { container.register("b", container.type, Actions.doNothing()) },
        ]
    }

		if *p.SecurityContext.RunAsUser == UserID {
			context.Report(gvk.Pod, message)
		}
	}
	for _, container := range p.Containers {
		if container.Name != util.IstioProxyName && container.Name != util.IstioOperator {
			if container.SecurityContext != nil && container.SecurityContext.RunAsUser != nil {
				if *container.SecurityContext.RunAsUser == UserID {
					context.Report(gvk.Pod, message)
				}
			}
		}
	}
}

		pod       *v1.Pod
		container *v1.Container
		path      string
		success   bool
	}{
		"basic":            {pod, &v1.Container{Name: "foo"}, "spec.containers{foo}", true},
		"basic2":           {pod, &v1.Container{Name: "baz"}, "spec.containers{baz}", true},
		"emptyName":        {pod, &v1.Container{Name: ""}, "spec.containers[2]", true},
		"basicSamePointer": {pod, &pod.Spec.Containers[0], "spec.containers{foo}", true},

        container.accessRules[0].kind == 0
        container.accessRules[0].pattern == 'id-accessible'
        container.accessRules[1].kind == 1
        container.accessRules[1].pattern == 'id-nonaccessible'
        container.accessRules[2].kind == 2
        container.accessRules[2].pattern == 'id-discouraged'
        container.accessRules[3].kind == 0
        container.accessRules[3].pattern == 'literal-accessible'

|<CONTAINER_BG_COLOR>   | container |
endlegend
!enddefinelong

' Elements
' ##################################

!define Container(e_alias, e_label, e_techn) rectangle "==e_label\n//<size:TECHN_FONT_SIZE>[e_techn]</size>//" <<container>> as e_alias
!define Container(e_alias, e_label, e_techn, e_descr) rectangle "==e_label\n//<size:TECHN_FONT_SIZE>[e_techn]</size>//\n\n e_descr" <<container>> as e_alias

' Boundaries

// shouldPullImage returns whether we should pull an image according to
// the presence and pull policy of the image.
func shouldPullImage(container *v1.Container, imagePresent bool) bool {
	if container.ImagePullPolicy == v1.PullNever {
		return false
	}

	if container.ImagePullPolicy == v1.PullAlways ||
		(container.ImagePullPolicy == v1.PullIfNotPresent && (!imagePresent)) {
		return true
	}

	return false
}