diff --git a/pkg/apis/pipeline/v1alpha1/pull_request_resource_test.go b/pkg/apis/pipeline/v1alpha1/pull_request_resource_test.go
index 1b91b1a03d2..db042d2ff3c 100644
--- a/pkg/apis/pipeline/v1alpha1/pull_request_resource_test.go
+++ b/pkg/apis/pipeline/v1alpha1/pull_request_resource_test.go
@@ -64,53 +64,50 @@ type testcase struct {
 }
 
 func containerTestCases(mode string) []testcase {
-	return []testcase{
-		{
-			in: &v1alpha1.PullRequestResource{
-				Name:           "nocreds",
-				DestinationDir: "/workspace",
-				URL:            "https://example.com",
-			},
-			out: []corev1.Container{{
-				Name:       "pr-source-nocreds-9l9zj",
-				Image:      "override-with-pr:latest",
-				WorkingDir: v1alpha1.WorkspaceDir,
-				Command:    []string{"/ko-app/pullrequest-init"},
-				Args:       []string{"-url", "https://example.com", "-path", "/workspace", "-mode", mode},
-				Env:        []corev1.EnvVar{},
+	return []testcase{{
+		in: &v1alpha1.PullRequestResource{
+			Name:           "nocreds",
+			DestinationDir: "/workspace",
+			URL:            "https://example.com",
+		},
+		out: []corev1.Container{{
+			Name:       "pr-source-nocreds-9l9zj",
+			Image:      "override-with-pr:latest",
+			WorkingDir: v1alpha1.WorkspaceDir,
+			Command:    []string{"/ko-app/pullrequest-init"},
+			Args:       []string{"-url", "https://example.com", "-path", "/workspace", "-mode", mode},
+			Env:        []corev1.EnvVar{},
+		}},
+	}, {
+		in: &v1alpha1.PullRequestResource{
+			Name:           "creds",
+			DestinationDir: "/workspace",
+			URL:            "https://example.com",
+			Secrets: []v1alpha1.SecretParam{{
+				FieldName:  "githubToken",
+				SecretName: "github-creds",
+				SecretKey:  "token",
 			}},
 		},
-		{
-			in: &v1alpha1.PullRequestResource{
-				Name:           "creds",
-				DestinationDir: "/workspace",
-				URL:            "https://example.com",
-				Secrets: []v1alpha1.SecretParam{{
-					FieldName:  "githubToken",
-					SecretName: "github-creds",
-					SecretKey:  "token",
-				}},
-			},
-			out: []corev1.Container{{
-				Name:       "pr-source-creds-mz4c7",
-				Image:      "override-with-pr:latest",
-				WorkingDir: v1alpha1.WorkspaceDir,
-				Command:    []string{"/ko-app/pullrequest-init"},
-				Args:       []string{"-url", "https://example.com", "-path", "/workspace", "-mode", mode},
-				Env: []corev1.EnvVar{{
-					Name: "GITHUBTOKEN",
-					ValueFrom: &corev1.EnvVarSource{
-						SecretKeyRef: &corev1.SecretKeySelector{
-							LocalObjectReference: corev1.LocalObjectReference{
-								Name: "github-creds",
-							},
-							Key: "token",
+		out: []corev1.Container{{
+			Name:       "pr-source-creds-mz4c7",
+			Image:      "override-with-pr:latest",
+			WorkingDir: v1alpha1.WorkspaceDir,
+			Command:    []string{"/ko-app/pullrequest-init"},
+			Args:       []string{"-url", "https://example.com", "-path", "/workspace", "-mode", mode},
+			Env: []corev1.EnvVar{{
+				Name: "GITHUBTOKEN",
+				ValueFrom: &corev1.EnvVarSource{
+					SecretKeyRef: &corev1.SecretKeySelector{
+						LocalObjectReference: corev1.LocalObjectReference{
+							Name: "github-creds",
 						},
+						Key: "token",
 					},
-				}},
+				},
 			}},
-		},
-	}
+		}},
+	}}
 }
 
 func TestPullRequest_GetDownloadContainerSpec(t *testing.T) {
diff --git a/pkg/apis/pipeline/v1alpha1/result_types_test.go b/pkg/apis/pipeline/v1alpha1/result_types_test.go
index f9d76904d12..e678d2f2ed1 100644
--- a/pkg/apis/pipeline/v1alpha1/result_types_test.go
+++ b/pkg/apis/pipeline/v1alpha1/result_types_test.go
@@ -41,40 +41,35 @@ func TestValidate_Invalid(t *testing.T) {
 		name    string
 		results *v1alpha1.Results
 		want    *apis.FieldError
-	}{
-		{
-			name: "invalid task type result",
-			results: &v1alpha1.Results{
-				URL:  "http://www.google.com",
-				Type: "wrongtype",
-			},
-			want: apis.ErrInvalidValue("wrongtype", "spec.results.Type"),
+	}{{
+		name: "invalid task type result",
+		results: &v1alpha1.Results{
+			URL:  "http://www.google.com",
+			Type: "wrongtype",
 		},
-		{
-			name: "invalid task type results missing url",
-			results: &v1alpha1.Results{
-				Type: v1alpha1.ResultTargetTypeGCS,
-				URL:  "",
-			},
-			want: apis.ErrMissingField("spec.results.URL"),
+		want: apis.ErrInvalidValue("wrongtype", "spec.results.Type"),
+	}, {
+		name: "invalid task type results missing url",
+		results: &v1alpha1.Results{
+			Type: v1alpha1.ResultTargetTypeGCS,
+			URL:  "",
 		},
-		{
-			name: "invalid task type results bad url",
-			results: &v1alpha1.Results{
-				Type: v1alpha1.ResultTargetTypeGCS,
-				URL:  "badurl",
-			},
-			want: apis.ErrInvalidValue("badurl", "spec.results.URL"),
+		want: apis.ErrMissingField("spec.results.URL"),
+	}, {
+		name: "invalid task type results bad url",
+		results: &v1alpha1.Results{
+			Type: v1alpha1.ResultTargetTypeGCS,
+			URL:  "badurl",
 		},
-		{
-			name: "invalid task type results type",
-			results: &v1alpha1.Results{
-				Type: "badtype",
-				URL:  "http://www.google.com",
-			},
-			want: apis.ErrInvalidValue("badtype", "spec.results.Type"),
+		want: apis.ErrInvalidValue("badurl", "spec.results.URL"),
+	}, {
+		name: "invalid task type results type",
+		results: &v1alpha1.Results{
+			Type: "badtype",
+			URL:  "http://www.google.com",
 		},
-	}
+		want: apis.ErrInvalidValue("badtype", "spec.results.Type"),
+	}}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			path := "spec.results"
diff --git a/pkg/apis/pipeline/v1alpha1/taskrun_validation_test.go b/pkg/apis/pipeline/v1alpha1/taskrun_validation_test.go
index e89e88897cb..eb77cb4efbe 100644
--- a/pkg/apis/pipeline/v1alpha1/taskrun_validation_test.go
+++ b/pkg/apis/pipeline/v1alpha1/taskrun_validation_test.go
@@ -35,21 +35,18 @@ func TestTaskRun_Invalidate(t *testing.T) {
 		name string
 		task *v1alpha1.TaskRun
 		want *apis.FieldError
-	}{
-		{
-			name: "invalid taskspec",
-			task: tb.TaskRun("taskmetaname", "default"),
-			want: apis.ErrMissingField("spec"),
+	}{{
+		name: "invalid taskspec",
+		task: tb.TaskRun("taskmetaname", "default"),
+		want: apis.ErrMissingField("spec"),
+	}, {
+		name: "invalid taskrun metadata",
+		task: tb.TaskRun("task.name", "default"),
+		want: &apis.FieldError{
+			Message: "Invalid resource name: special character . must not be present",
+			Paths:   []string{"metadata.name"},
 		},
-		{
-			name: "invalid taskrun metadata",
-			task: tb.TaskRun("task.name", "default"),
-			want: &apis.FieldError{
-				Message: "Invalid resource name: special character . must not be present",
-				Paths:   []string{"metadata.name"},
-			},
-		},
-	}
+	}}
 
 	for _, ts := range tests {
 		t.Run(ts.name, func(t *testing.T) {
@@ -75,61 +72,55 @@ func TestTaskRunSpec_Invalidate(t *testing.T) {
 		name    string
 		spec    v1alpha1.TaskRunSpec
 		wantErr *apis.FieldError
-	}{
-		{
-			name:    "invalid taskspec",
-			spec:    v1alpha1.TaskRunSpec{},
-			wantErr: apis.ErrMissingField("spec"),
+	}{{
+		name:    "invalid taskspec",
+		spec:    v1alpha1.TaskRunSpec{},
+		wantErr: apis.ErrMissingField("spec"),
+	}, {
+		name: "invalid taskref name",
+		spec: v1alpha1.TaskRunSpec{
+			TaskRef: &v1alpha1.TaskRef{},
 		},
-		{
-			name: "invalid taskref name",
-			spec: v1alpha1.TaskRunSpec{
-				TaskRef: &v1alpha1.TaskRef{},
+		wantErr: apis.ErrMissingField("spec.taskref.name, spec.taskspec"),
+	}, {
+		name: "invalid taskref and taskspec together",
+		spec: v1alpha1.TaskRunSpec{
+			TaskRef: &v1alpha1.TaskRef{
+				Name: "taskrefname",
 			},
-			wantErr: apis.ErrMissingField("spec.taskref.name, spec.taskspec"),
-		},
-		{
-			name: "invalid taskref and taskspec together",
-			spec: v1alpha1.TaskRunSpec{
-				TaskRef: &v1alpha1.TaskRef{
-					Name: "taskrefname",
-				},
-				TaskSpec: &v1alpha1.TaskSpec{
-					Steps: []corev1.Container{{
-						Name:  "mystep",
-						Image: "myimage",
-					}},
-				},
+			TaskSpec: &v1alpha1.TaskSpec{
+				Steps: []corev1.Container{{
+					Name:  "mystep",
+					Image: "myimage",
+				}},
 			},
-			wantErr: apis.ErrDisallowedFields("spec.taskspec", "spec.taskref"),
 		},
-		{
-			name: "negative pipeline timeout",
-			spec: v1alpha1.TaskRunSpec{
-				TaskRef: &v1alpha1.TaskRef{
-					Name: "taskrefname",
-				},
-				Timeout: &metav1.Duration{Duration: -48 * time.Hour},
+		wantErr: apis.ErrDisallowedFields("spec.taskspec", "spec.taskref"),
+	}, {
+		name: "negative pipeline timeout",
+		spec: v1alpha1.TaskRunSpec{
+			TaskRef: &v1alpha1.TaskRef{
+				Name: "taskrefname",
 			},
-			wantErr: apis.ErrInvalidValue("-48h0m0s should be >= 0", "spec.timeout"),
+			Timeout: &metav1.Duration{Duration: -48 * time.Hour},
 		},
-		{
-			name: "invalid taskspec",
-			spec: v1alpha1.TaskRunSpec{
-				TaskSpec: &v1alpha1.TaskSpec{
-					Steps: []corev1.Container{{
-						Name:  "invalid-name-with-$weird-char*/%",
-						Image: "myimage",
-					}},
-				},
-			},
-			wantErr: &apis.FieldError{
-				Message: `invalid value "invalid-name-with-$weird-char*/%"`,
-				Paths:   []string{"taskspec.steps.name"},
-				Details: "Task step name must be a valid DNS Label, For more info refer to https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
+		wantErr: apis.ErrInvalidValue("-48h0m0s should be >= 0", "spec.timeout"),
+	}, {
+		name: "invalid taskspec",
+		spec: v1alpha1.TaskRunSpec{
+			TaskSpec: &v1alpha1.TaskSpec{
+				Steps: []corev1.Container{{
+					Name:  "invalid-name-with-$weird-char*/%",
+					Image: "myimage",
+				}},
 			},
 		},
-	}
+		wantErr: &apis.FieldError{
+			Message: `invalid value "invalid-name-with-$weird-char*/%"`,
+			Paths:   []string{"taskspec.steps.name"},
+			Details: "Task step name must be a valid DNS Label, For more info refer to https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
+		},
+	}}
 
 	for _, ts := range tests {
 		t.Run(ts.name, func(t *testing.T) {
@@ -145,31 +136,28 @@ func TestTaskRunSpec_Validate(t *testing.T) {
 	tests := []struct {
 		name string
 		spec v1alpha1.TaskRunSpec
-	}{
-		{
-			name: "taskspec without a taskRef",
-			spec: v1alpha1.TaskRunSpec{
-				TaskSpec: &v1alpha1.TaskSpec{
-					Steps: []corev1.Container{{
-						Name:  "mystep",
-						Image: "myimage",
-					}},
-				},
+	}{{
+		name: "taskspec without a taskRef",
+		spec: v1alpha1.TaskRunSpec{
+			TaskSpec: &v1alpha1.TaskSpec{
+				Steps: []corev1.Container{{
+					Name:  "mystep",
+					Image: "myimage",
+				}},
 			},
 		},
-		{
-			name: "no timeout",
-			spec: v1alpha1.TaskRunSpec{
-				Timeout: &metav1.Duration{Duration: 0},
-				TaskSpec: &v1alpha1.TaskSpec{
-					Steps: []corev1.Container{{
-						Name:  "mystep",
-						Image: "myimage",
-					}},
-				},
+	}, {
+		name: "no timeout",
+		spec: v1alpha1.TaskRunSpec{
+			Timeout: &metav1.Duration{Duration: 0},
+			TaskSpec: &v1alpha1.TaskSpec{
+				Steps: []corev1.Container{{
+					Name:  "mystep",
+					Image: "myimage",
+				}},
 			},
 		},
-	}
+	}}
 
 	for _, ts := range tests {
 		t.Run(ts.name, func(t *testing.T) {
@@ -203,77 +191,74 @@ func TestInput_Invalidate(t *testing.T) {
 		name    string
 		inputs  v1alpha1.TaskRunInputs
 		wantErr *apis.FieldError
-	}{
-		{
-			name: "duplicate task inputs",
-			inputs: v1alpha1.TaskRunInputs{
-				Resources: []v1alpha1.TaskResourceBinding{{
-					ResourceRef: v1alpha1.PipelineResourceRef{
-						Name: "testresource1",
-					},
-					Name: "workspace",
-				}, {
-					ResourceRef: v1alpha1.PipelineResourceRef{
-						Name: "testresource2",
-					},
-					Name: "workspace",
-				}},
-			},
-			wantErr: apis.ErrMultipleOneOf("spec.Inputs.Resources.Name"),
+	}{{
+		name: "duplicate task inputs",
+		inputs: v1alpha1.TaskRunInputs{
+			Resources: []v1alpha1.TaskResourceBinding{{
+				ResourceRef: v1alpha1.PipelineResourceRef{
+					Name: "testresource1",
+				},
+				Name: "workspace",
+			}, {
+				ResourceRef: v1alpha1.PipelineResourceRef{
+					Name: "testresource2",
+				},
+				Name: "workspace",
+			}},
 		},
-		{
-			name: "invalid task input params",
-			inputs: v1alpha1.TaskRunInputs{
-				Resources: []v1alpha1.TaskResourceBinding{{
-					ResourceRef: v1alpha1.PipelineResourceRef{
-						Name: "testresource",
-					},
-					Name: "resource",
-				}},
-				Params: []v1alpha1.Param{{
-					Name:  "name",
-					Value: "value",
-				}, {
-					Name:  "name",
-					Value: "value",
-				}},
-			},
-			wantErr: apis.ErrMultipleOneOf("spec.inputs.params"),
-		}, {
-			name: "duplicate resource ref and resource spec",
-			inputs: v1alpha1.TaskRunInputs{
-				Resources: []v1alpha1.TaskResourceBinding{{
-					ResourceRef: v1alpha1.PipelineResourceRef{
-						Name: "testresource",
-					},
-					ResourceSpec: &v1alpha1.PipelineResourceSpec{
-						Type: v1alpha1.PipelineResourceTypeGit,
-					},
-					Name: "resource-dup",
-				}},
-			},
-			wantErr: apis.ErrDisallowedFields("spec.Inputs.Resources.Name.ResourceRef", "spec.Inputs.Resources.Name.ResourceSpec"),
-		}, {
-			name: "invalid resource spec",
-			inputs: v1alpha1.TaskRunInputs{
-				Resources: []v1alpha1.TaskResourceBinding{{
-					ResourceSpec: &v1alpha1.PipelineResourceSpec{
-						Type: "non-existent",
-					},
-					Name: "resource-inv",
-				}},
-			},
-			wantErr: apis.ErrInvalidValue("spec.type", "non-existent"),
-		}, {
-			name: "no resource ref and resource spec",
-			inputs: v1alpha1.TaskRunInputs{
-				Resources: []v1alpha1.TaskResourceBinding{{
-					Name: "resource",
-				}},
-			},
-			wantErr: apis.ErrMissingField("spec.Inputs.Resources.Name.ResourceRef", "spec.Inputs.Resources.Name.ResourceSpec"),
+		wantErr: apis.ErrMultipleOneOf("spec.Inputs.Resources.Name"),
+	}, {
+		name: "invalid task input params",
+		inputs: v1alpha1.TaskRunInputs{
+			Resources: []v1alpha1.TaskResourceBinding{{
+				ResourceRef: v1alpha1.PipelineResourceRef{
+					Name: "testresource",
+				},
+				Name: "resource",
+			}},
+			Params: []v1alpha1.Param{{
+				Name:  "name",
+				Value: "value",
+			}, {
+				Name:  "name",
+				Value: "value",
+			}},
 		},
-	}
+		wantErr: apis.ErrMultipleOneOf("spec.inputs.params"),
+	}, {
+		name: "duplicate resource ref and resource spec",
+		inputs: v1alpha1.TaskRunInputs{
+			Resources: []v1alpha1.TaskResourceBinding{{
+				ResourceRef: v1alpha1.PipelineResourceRef{
+					Name: "testresource",
+				},
+				ResourceSpec: &v1alpha1.PipelineResourceSpec{
+					Type: v1alpha1.PipelineResourceTypeGit,
+				},
+				Name: "resource-dup",
+			}},
+		},
+		wantErr: apis.ErrDisallowedFields("spec.Inputs.Resources.Name.ResourceRef", "spec.Inputs.Resources.Name.ResourceSpec"),
+	}, {
+		name: "invalid resource spec",
+		inputs: v1alpha1.TaskRunInputs{
+			Resources: []v1alpha1.TaskResourceBinding{{
+				ResourceSpec: &v1alpha1.PipelineResourceSpec{
+					Type: "non-existent",
+				},
+				Name: "resource-inv",
+			}},
+		},
+		wantErr: apis.ErrInvalidValue("spec.type", "non-existent"),
+	}, {
+		name: "no resource ref and resource spec",
+		inputs: v1alpha1.TaskRunInputs{
+			Resources: []v1alpha1.TaskResourceBinding{{
+				Name: "resource",
+			}},
+		},
+		wantErr: apis.ErrMissingField("spec.Inputs.Resources.Name.ResourceRef", "spec.Inputs.Resources.Name.ResourceSpec"),
+	}}
 	for _, ts := range tests {
 		t.Run(ts.name, func(t *testing.T) {
 			err := ts.inputs.Validate(context.Background(), "spec.Inputs")
@@ -302,33 +287,31 @@ func TestOutput_Invalidate(t *testing.T) {
 		name    string
 		outputs v1alpha1.TaskRunOutputs
 		wantErr *apis.FieldError
-	}{
-		{
-			name: "duplicated task outputs",
-			outputs: v1alpha1.TaskRunOutputs{
-				Resources: []v1alpha1.TaskResourceBinding{{
-					ResourceRef: v1alpha1.PipelineResourceRef{
-						Name: "testresource1",
-					},
-					Name: "workspace",
-				}, {
-					ResourceRef: v1alpha1.PipelineResourceRef{
-						Name: "testresource2",
-					},
-					Name: "workspace",
-				}},
-			},
-			wantErr: apis.ErrMultipleOneOf("spec.Outputs.Resources.Name"),
-		}, {
-			name: "no output resource with resource spec nor resource ref",
-			outputs: v1alpha1.TaskRunOutputs{
-				Resources: []v1alpha1.TaskResourceBinding{{
-					Name: "workspace",
-				}},
-			},
-			wantErr: apis.ErrMissingField("spec.Outputs.Resources.Name.ResourceSpec", "spec.Outputs.Resources.Name.ResourceRef"),
+	}{{
+		name: "duplicated task outputs",
+		outputs: v1alpha1.TaskRunOutputs{
+			Resources: []v1alpha1.TaskResourceBinding{{
+				ResourceRef: v1alpha1.PipelineResourceRef{
+					Name: "testresource1",
+				},
+				Name: "workspace",
+			}, {
+				ResourceRef: v1alpha1.PipelineResourceRef{
+					Name: "testresource2",
+				},
+				Name: "workspace",
+			}},
 		},
-	}
+		wantErr: apis.ErrMultipleOneOf("spec.Outputs.Resources.Name"),
+	}, {
+		name: "no output resource with resource spec nor resource ref",
+		outputs: v1alpha1.TaskRunOutputs{
+			Resources: []v1alpha1.TaskResourceBinding{{
+				Name: "workspace",
+			}},
+		},
+		wantErr: apis.ErrMissingField("spec.Outputs.Resources.Name.ResourceSpec", "spec.Outputs.Resources.Name.ResourceRef"),
+	}}
 	for _, ts := range tests {
 		t.Run(ts.name, func(t *testing.T) {
 			err := ts.outputs.Validate(context.Background(), "spec.Outputs")
diff --git a/pkg/artifacts/artifact_storage_test.go b/pkg/artifacts/artifact_storage_test.go
index 1e72c187161..268c91f2366 100644
--- a/pkg/artifacts/artifact_storage_test.go
+++ b/pkg/artifacts/artifact_storage_test.go
@@ -497,8 +497,7 @@ func TestGetArtifactStorageWithPvcConfigMap(t *testing.T) {
 		expectedArtifactStorage: &v1alpha1.ArtifactPVC{
 			Name: "pipelineruntest",
 		},
-	},
-	} {
+	}} {
 		t.Run(c.desc, func(t *testing.T) {
 			fakekubeclient := fakek8s.NewSimpleClientset(c.configMap)
 
diff --git a/pkg/reconciler/event_test.go b/pkg/reconciler/event_test.go
index 439efe1bf92..053f7c21203 100644
--- a/pkg/reconciler/event_test.go
+++ b/pkg/reconciler/event_test.go
@@ -15,62 +15,56 @@ func Test_EmitEvent(t *testing.T) {
 		before      *apis.Condition
 		after       *apis.Condition
 		expectEvent bool
-	}{
-		{
-			name: "unknown to true",
-			before: &apis.Condition{
-				Type:   apis.ConditionSucceeded,
-				Status: corev1.ConditionUnknown,
-			},
-			after: &apis.Condition{
-				Type:   apis.ConditionSucceeded,
-				Status: corev1.ConditionTrue,
-			},
-			expectEvent: true,
+	}{{
+		name: "unknown to true",
+		before: &apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionUnknown,
 		},
-		{
-			name: "true to true",
-			before: &apis.Condition{
-				Type:   apis.ConditionSucceeded,
-				Status: corev1.ConditionTrue,
-			},
-			after: &apis.Condition{
-				Type:   apis.ConditionSucceeded,
-				Status: corev1.ConditionTrue,
-			},
-			expectEvent: false,
+		after: &apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionTrue,
 		},
-		{
-			name: "false to false",
-			before: &apis.Condition{
-				Type:   apis.ConditionSucceeded,
-				Status: corev1.ConditionFalse,
-			},
-			after: &apis.Condition{
-				Type:   apis.ConditionSucceeded,
-				Status: corev1.ConditionFalse,
-			},
-			expectEvent: false,
+		expectEvent: true,
+	}, {
+		name: "true to true",
+		before: &apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionTrue,
 		},
-		{
-			name:  "true to nil",
-			after: nil,
-			before: &apis.Condition{
-				Type:   apis.ConditionSucceeded,
-				Status: corev1.ConditionTrue,
-			},
-			expectEvent: true,
+		after: &apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionTrue,
 		},
-		{
-			name:   "nil to true",
-			before: nil,
-			after: &apis.Condition{
-				Type:   apis.ConditionSucceeded,
-				Status: corev1.ConditionTrue,
-			},
-			expectEvent: true,
+		expectEvent: false,
+	}, {
+		name: "false to false",
+		before: &apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionFalse,
 		},
-	}
+		after: &apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionFalse,
+		},
+		expectEvent: false,
+	}, {
+		name:  "true to nil",
+		after: nil,
+		before: &apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionTrue,
+		},
+		expectEvent: true,
+	}, {
+		name:   "nil to true",
+		before: nil,
+		after: &apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionTrue,
+		},
+		expectEvent: true,
+	}}
 
 	for _, ts := range testcases {
 		fr := record.NewFakeRecorder(1)
diff --git a/pkg/reconciler/v1alpha1/pipelinerun/resources/apply_test.go b/pkg/reconciler/v1alpha1/pipelinerun/resources/apply_test.go
index ceeee1d850c..f491ba489a7 100644
--- a/pkg/reconciler/v1alpha1/pipelinerun/resources/apply_test.go
+++ b/pkg/reconciler/v1alpha1/pipelinerun/resources/apply_test.go
@@ -27,49 +27,46 @@ func TestApplyParameters(t *testing.T) {
 		original *v1alpha1.Pipeline
 		run      *v1alpha1.PipelineRun
 		expected *v1alpha1.Pipeline
-	}{
-		{
-			name: "single parameter",
-			original: tb.Pipeline("test-pipeline", "foo",
-				tb.PipelineSpec(
-					tb.PipelineParam("first-param", tb.PipelineParamDefault("default-value")),
-					tb.PipelineParam("second-param"),
-					tb.PipelineTask("first-task-1", "first-task",
-						tb.PipelineTaskParam("first-task-first-param", "${params.first-param}"),
-						tb.PipelineTaskParam("first-task-second-param", "${params.second-param}"),
-						tb.PipelineTaskParam("first-task-third-param", "static value"),
-					))),
-			run: tb.PipelineRun("test-pipeline-run", "foo",
-				tb.PipelineRunSpec("test-pipeline",
-					tb.PipelineRunParam("second-param", "second-value"))),
-			expected: tb.Pipeline("test-pipeline", "foo",
-				tb.PipelineSpec(
-					tb.PipelineParam("first-param", tb.PipelineParamDefault("default-value")),
-					tb.PipelineParam("second-param"),
-					tb.PipelineTask("first-task-1", "first-task",
-						tb.PipelineTaskParam("first-task-first-param", "default-value"),
-						tb.PipelineTaskParam("first-task-second-param", "second-value"),
-						tb.PipelineTaskParam("first-task-third-param", "static value"),
-					))),
-		},
-		{
-			name: "pipeline parameter nested inside task parameter",
-			original: tb.Pipeline("test-pipeline", "foo",
-				tb.PipelineSpec(
-					tb.PipelineParam("first-param", tb.PipelineParamDefault("default-value")),
-					tb.PipelineTask("first-task-1", "first-task",
-						tb.PipelineTaskParam("first-task-first-param", "${input.workspace.${params.first-param}}"),
-					))),
-			run: tb.PipelineRun("test-pipeline-run", "foo",
-				tb.PipelineRunSpec("test-pipeline")),
-			expected: tb.Pipeline("test-pipeline", "foo",
-				tb.PipelineSpec(
-					tb.PipelineParam("first-param", tb.PipelineParamDefault("default-value")),
-					tb.PipelineTask("first-task-1", "first-task",
-						tb.PipelineTaskParam("first-task-first-param", "${input.workspace.default-value}"),
-					))),
-		},
-	}
+	}{{
+		name: "single parameter",
+		original: tb.Pipeline("test-pipeline", "foo",
+			tb.PipelineSpec(
+				tb.PipelineParam("first-param", tb.PipelineParamDefault("default-value")),
+				tb.PipelineParam("second-param"),
+				tb.PipelineTask("first-task-1", "first-task",
+					tb.PipelineTaskParam("first-task-first-param", "${params.first-param}"),
+					tb.PipelineTaskParam("first-task-second-param", "${params.second-param}"),
+					tb.PipelineTaskParam("first-task-third-param", "static value"),
+				))),
+		run: tb.PipelineRun("test-pipeline-run", "foo",
+			tb.PipelineRunSpec("test-pipeline",
+				tb.PipelineRunParam("second-param", "second-value"))),
+		expected: tb.Pipeline("test-pipeline", "foo",
+			tb.PipelineSpec(
+				tb.PipelineParam("first-param", tb.PipelineParamDefault("default-value")),
+				tb.PipelineParam("second-param"),
+				tb.PipelineTask("first-task-1", "first-task",
+					tb.PipelineTaskParam("first-task-first-param", "default-value"),
+					tb.PipelineTaskParam("first-task-second-param", "second-value"),
+					tb.PipelineTaskParam("first-task-third-param", "static value"),
+				))),
+	}, {
+		name: "pipeline parameter nested inside task parameter",
+		original: tb.Pipeline("test-pipeline", "foo",
+			tb.PipelineSpec(
+				tb.PipelineParam("first-param", tb.PipelineParamDefault("default-value")),
+				tb.PipelineTask("first-task-1", "first-task",
+					tb.PipelineTaskParam("first-task-first-param", "${input.workspace.${params.first-param}}"),
+				))),
+		run: tb.PipelineRun("test-pipeline-run", "foo",
+			tb.PipelineRunSpec("test-pipeline")),
+		expected: tb.Pipeline("test-pipeline", "foo",
+			tb.PipelineSpec(
+				tb.PipelineParam("first-param", tb.PipelineParamDefault("default-value")),
+				tb.PipelineTask("first-task-1", "first-task",
+					tb.PipelineTaskParam("first-task-first-param", "${input.workspace.default-value}"),
+				))),
+	}}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got := ApplyParameters(tt.original, tt.run)
diff --git a/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution_test.go b/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution_test.go
index 7e8f31138aa..36f8a3a1720 100644
--- a/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution_test.go
+++ b/pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution_test.go
@@ -263,171 +263,149 @@ func TestGetNextTasks(t *testing.T) {
 		state        PipelineRunState
 		candidates   map[string]v1alpha1.PipelineTask
 		expectedNext []*ResolvedPipelineRunTask
-	}{
-		{
-			name:         "no-tasks-started-no-candidates",
-			state:        noneStartedState,
-			candidates:   map[string]v1alpha1.PipelineTask{},
-			expectedNext: []*ResolvedPipelineRunTask{},
-		},
-		{
-			name:  "no-tasks-started-one-candidate",
-			state: noneStartedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask1": pts[0],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{noneStartedState[0]},
-		},
-		{
-			name:  "no-tasks-started-other-candidate",
-			state: noneStartedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask2": pts[1],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{noneStartedState[1]},
-		},
-		{
-			name:  "no-tasks-started-both-candidates",
-			state: noneStartedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask1": pts[0],
-				"mytask2": pts[1],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{noneStartedState[0], noneStartedState[1]},
-		},
-		{
-			name:         "one-task-started-no-candidates",
-			state:        oneStartedState,
-			candidates:   map[string]v1alpha1.PipelineTask{},
-			expectedNext: []*ResolvedPipelineRunTask{},
-		},
-		{
-			name:  "one-task-started-one-candidate",
-			state: oneStartedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask1": pts[0],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+	}{{
+		name:         "no-tasks-started-no-candidates",
+		state:        noneStartedState,
+		candidates:   map[string]v1alpha1.PipelineTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "no-tasks-started-one-candidate",
+		state: noneStartedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask1": pts[0],
 		},
-		{
-			name:  "one-task-started-other-candidate",
-			state: oneStartedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask2": pts[1],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{oneStartedState[1]},
+		expectedNext: []*ResolvedPipelineRunTask{noneStartedState[0]},
+	}, {
+		name:  "no-tasks-started-other-candidate",
+		state: noneStartedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask2": pts[1],
 		},
-		{
-			name:  "one-task-started-both-candidates",
-			state: oneStartedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask1": pts[0],
-				"mytask2": pts[1],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{oneStartedState[1]},
+		expectedNext: []*ResolvedPipelineRunTask{noneStartedState[1]},
+	}, {
+		name:  "no-tasks-started-both-candidates",
+		state: noneStartedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask1": pts[0],
+			"mytask2": pts[1],
 		},
-		{
-			name:         "one-task-finished-no-candidates",
-			state:        oneFinishedState,
-			candidates:   map[string]v1alpha1.PipelineTask{},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{noneStartedState[0], noneStartedState[1]},
+	}, {
+		name:         "one-task-started-no-candidates",
+		state:        oneStartedState,
+		candidates:   map[string]v1alpha1.PipelineTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "one-task-started-one-candidate",
+		state: oneStartedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask1": pts[0],
 		},
-		{
-			name:  "one-task-finished-one-candidate",
-			state: oneFinishedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask1": pts[0],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "one-task-started-other-candidate",
+		state: oneStartedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask2": pts[1],
 		},
-		{
-			name:  "one-task-finished-other-candidate",
-			state: oneFinishedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask2": pts[1],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{oneFinishedState[1]},
+		expectedNext: []*ResolvedPipelineRunTask{oneStartedState[1]},
+	}, {
+		name:  "one-task-started-both-candidates",
+		state: oneStartedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask1": pts[0],
+			"mytask2": pts[1],
 		},
-		{
-			name:  "one-task-finished-both-candidate",
-			state: oneFinishedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask1": pts[0],
-				"mytask2": pts[1],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{oneFinishedState[1]},
+		expectedNext: []*ResolvedPipelineRunTask{oneStartedState[1]},
+	}, {
+		name:         "one-task-finished-no-candidates",
+		state:        oneFinishedState,
+		candidates:   map[string]v1alpha1.PipelineTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "one-task-finished-one-candidate",
+		state: oneFinishedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask1": pts[0],
 		},
-		{
-			name:         "one-task-failed-no-candidates",
-			state:        oneFailedState,
-			candidates:   map[string]v1alpha1.PipelineTask{},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "one-task-finished-other-candidate",
+		state: oneFinishedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask2": pts[1],
 		},
-		{
-			name:  "one-task-failed-one-candidate",
-			state: oneFailedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask1": pts[0],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{oneFinishedState[1]},
+	}, {
+		name:  "one-task-finished-both-candidate",
+		state: oneFinishedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask1": pts[0],
+			"mytask2": pts[1],
 		},
-		{
-			name:  "one-task-failed-other-candidate",
-			state: oneFailedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask2": pts[1],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{oneFailedState[1]},
+		expectedNext: []*ResolvedPipelineRunTask{oneFinishedState[1]},
+	}, {
+		name:         "one-task-failed-no-candidates",
+		state:        oneFailedState,
+		candidates:   map[string]v1alpha1.PipelineTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "one-task-failed-one-candidate",
+		state: oneFailedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask1": pts[0],
 		},
-		{
-			name:  "one-task-failed-both-candidates",
-			state: oneFailedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask1": pts[0],
-				"mytask2": pts[1],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{oneFailedState[1]},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "one-task-failed-other-candidate",
+		state: oneFailedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask2": pts[1],
 		},
-		{
-			name:         "all-finished-no-candidates",
-			state:        allFinishedState,
-			candidates:   map[string]v1alpha1.PipelineTask{},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{oneFailedState[1]},
+	}, {
+		name:  "one-task-failed-both-candidates",
+		state: oneFailedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask1": pts[0],
+			"mytask2": pts[1],
 		},
-		{
-			name:  "all-finished-one-candidate",
-			state: allFinishedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask1": pts[0],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{oneFailedState[1]},
+	}, {
+		name:         "all-finished-no-candidates",
+		state:        allFinishedState,
+		candidates:   map[string]v1alpha1.PipelineTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "all-finished-one-candidate",
+		state: allFinishedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask1": pts[0],
 		},
-		{
-			name:  "all-finished-other-candidate",
-			state: allFinishedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask2": pts[1],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "all-finished-other-candidate",
+		state: allFinishedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask2": pts[1],
 		},
-		{
-			name:  "all-finished-both-candidates",
-			state: allFinishedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask1": pts[0],
-				"mytask2": pts[1],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "all-finished-both-candidates",
+		state: allFinishedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask1": pts[0],
+			"mytask2": pts[1],
 		},
-		{
-			name:  "one-cancelled-one-candidate",
-			state: taskCancelled,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask5": pts[4],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "one-cancelled-one-candidate",
+		state: taskCancelled,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask5": pts[4],
 		},
-	}
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}}
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
 			next := tc.state.GetNextTasks(tc.candidates)
@@ -499,56 +477,49 @@ func TestGetNextTaskWithRetries(t *testing.T) {
 		state        PipelineRunState
 		candidates   map[string]v1alpha1.PipelineTask
 		expectedNext []*ResolvedPipelineRunTask
-	}{
-		{
-			name:  "tasks-cancelled-no-candidates",
-			state: taskCancelledByStatusState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask5": pts[4],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+	}{{
+		name:  "tasks-cancelled-no-candidates",
+		state: taskCancelledByStatusState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask5": pts[4],
 		},
-		{
-			name:  "tasks-cancelled-bySpec-no-candidates",
-			state: taskCancelledBySpecState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask5": pts[4],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "tasks-cancelled-bySpec-no-candidates",
+		state: taskCancelledBySpecState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask5": pts[4],
 		},
-		{
-			name:  "tasks-running-no-candidates",
-			state: taskRunningState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask5": pts[4],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "tasks-running-no-candidates",
+		state: taskRunningState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask5": pts[4],
 		},
-		{
-			name:  "tasks-succeeded-bySpec-no-candidates",
-			state: taskSucceededState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask5": pts[4],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "tasks-succeeded-bySpec-no-candidates",
+		state: taskSucceededState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask5": pts[4],
 		},
-		{
-			name:  "tasks-retried-no-candidates",
-			state: taskRetriedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask5": pts[3],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "tasks-retried-no-candidates",
+		state: taskRetriedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask5": pts[3],
 		},
-		{
-			name:  "tasks-retried-one-candidates",
-			state: taskExpectedState,
-			candidates: map[string]v1alpha1.PipelineTask{
-				"mytask5": pts[3],
-			},
-			expectedNext: []*ResolvedPipelineRunTask{taskExpectedState[0]},
+		expectedNext: []*ResolvedPipelineRunTask{},
+	}, {
+		name:  "tasks-retried-one-candidates",
+		state: taskExpectedState,
+		candidates: map[string]v1alpha1.PipelineTask{
+			"mytask5": pts[3],
 		},
-	}
+		expectedNext: []*ResolvedPipelineRunTask{taskExpectedState[0]},
+	}}
 
 	// iterate over *state* to get from candidate and check if TaskRun is there.
 	// Cancelled TaskRun should have a TaskRun cancelled and with a retry but should not retry.
@@ -641,56 +612,47 @@ func TestIsDone(t *testing.T) {
 		state      PipelineRunState
 		expected   bool
 		ptExpected []bool
-	}{
-		{
-			name:       "tasks-cancelled-no-candidates",
-			state:      taskCancelledByStatusState,
-			expected:   false,
-			ptExpected: []bool{false},
-		},
-		{
-			name:       "tasks-cancelled-bySpec-no-candidates",
-			state:      taskCancelledBySpecState,
-			expected:   false,
-			ptExpected: []bool{false},
-		},
-		{
-			name:       "tasks-running-no-candidates",
-			state:      taskRunningState,
-			expected:   false,
-			ptExpected: []bool{false},
-		},
-		{
-			name:       "tasks-succeeded-bySpec-no-candidates",
-			state:      taskSucceededState,
-			expected:   true,
-			ptExpected: []bool{true},
-		},
-		{
-			name:       "tasks-retried-no-candidates",
-			state:      taskRetriedState,
-			expected:   false,
-			ptExpected: []bool{false},
-		},
-		{
-			name:       "tasks-retried-one-candidates",
-			state:      taskExpectedState,
-			expected:   false,
-			ptExpected: []bool{false},
-		},
-		{
-			name:       "no-pipelineTask",
-			state:      noPipelineTaskState,
-			expected:   false,
-			ptExpected: []bool{false},
-		},
-		{
-			name:       "No-taskrun",
-			state:      noTaskRunState,
-			expected:   false,
-			ptExpected: []bool{false},
-		},
-	}
+	}{{
+		name:       "tasks-cancelled-no-candidates",
+		state:      taskCancelledByStatusState,
+		expected:   false,
+		ptExpected: []bool{false},
+	}, {
+		name:       "tasks-cancelled-bySpec-no-candidates",
+		state:      taskCancelledBySpecState,
+		expected:   false,
+		ptExpected: []bool{false},
+	}, {
+		name:       "tasks-running-no-candidates",
+		state:      taskRunningState,
+		expected:   false,
+		ptExpected: []bool{false},
+	}, {
+		name:       "tasks-succeeded-bySpec-no-candidates",
+		state:      taskSucceededState,
+		expected:   true,
+		ptExpected: []bool{true},
+	}, {
+		name:       "tasks-retried-no-candidates",
+		state:      taskRetriedState,
+		expected:   false,
+		ptExpected: []bool{false},
+	}, {
+		name:       "tasks-retried-one-candidates",
+		state:      taskExpectedState,
+		expected:   false,
+		ptExpected: []bool{false},
+	}, {
+		name:       "no-pipelineTask",
+		state:      noPipelineTaskState,
+		expected:   false,
+		ptExpected: []bool{false},
+	}, {
+		name:       "No-taskrun",
+		state:      noTaskRunState,
+		expected:   false,
+		ptExpected: []bool{false},
+	}}
 
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
@@ -715,33 +677,27 @@ func TestSuccessfulPipelineTaskNames(t *testing.T) {
 		name          string
 		state         PipelineRunState
 		expectedNames []string
-	}{
-		{
-			name:          "no-tasks-started",
-			state:         noneStartedState,
-			expectedNames: []string{},
-		},
-		{
-			name:          "one-task-started",
-			state:         oneStartedState,
-			expectedNames: []string{},
-		},
-		{
-			name:          "one-task-finished",
-			state:         oneFinishedState,
-			expectedNames: []string{"mytask1"},
-		},
-		{
-			name:          "one-task-failed",
-			state:         oneFailedState,
-			expectedNames: []string{},
-		},
-		{
-			name:          "all-finished",
-			state:         allFinishedState,
-			expectedNames: []string{"mytask1", "mytask2"},
-		},
-	}
+	}{{
+		name:          "no-tasks-started",
+		state:         noneStartedState,
+		expectedNames: []string{},
+	}, {
+		name:          "one-task-started",
+		state:         oneStartedState,
+		expectedNames: []string{},
+	}, {
+		name:          "one-task-finished",
+		state:         oneFinishedState,
+		expectedNames: []string{"mytask1"},
+	}, {
+		name:          "one-task-failed",
+		state:         oneFailedState,
+		expectedNames: []string{},
+	}, {
+		name:          "all-finished",
+		state:         allFinishedState,
+		expectedNames: []string{"mytask1", "mytask2"},
+	}}
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
 			names := tc.state.SuccessfulPipelineTaskNames()
@@ -767,38 +723,31 @@ func TestGetPipelineConditionStatus(t *testing.T) {
 		name           string
 		state          []*ResolvedPipelineRunTask
 		expectedStatus corev1.ConditionStatus
-	}{
-		{
-			name:           "no-tasks-started",
-			state:          noneStartedState,
-			expectedStatus: corev1.ConditionUnknown,
-		},
-		{
-			name:           "one-task-started",
-			state:          oneStartedState,
-			expectedStatus: corev1.ConditionUnknown,
-		},
-		{
-			name:           "one-task-finished",
-			state:          oneFinishedState,
-			expectedStatus: corev1.ConditionUnknown,
-		},
-		{
-			name:           "one-task-failed",
-			state:          oneFailedState,
-			expectedStatus: corev1.ConditionFalse,
-		},
-		{
-			name:           "all-finished",
-			state:          allFinishedState,
-			expectedStatus: corev1.ConditionTrue,
-		},
-		{
-			name:           "one-retry-needed",
-			state:          taskRetriedState,
-			expectedStatus: corev1.ConditionUnknown,
-		},
-	}
+	}{{
+		name:           "no-tasks-started",
+		state:          noneStartedState,
+		expectedStatus: corev1.ConditionUnknown,
+	}, {
+		name:           "one-task-started",
+		state:          oneStartedState,
+		expectedStatus: corev1.ConditionUnknown,
+	}, {
+		name:           "one-task-finished",
+		state:          oneFinishedState,
+		expectedStatus: corev1.ConditionUnknown,
+	}, {
+		name:           "one-task-failed",
+		state:          oneFailedState,
+		expectedStatus: corev1.ConditionFalse,
+	}, {
+		name:           "all-finished",
+		state:          allFinishedState,
+		expectedStatus: corev1.ConditionTrue,
+	}, {
+		name:           "one-retry-needed",
+		state:          taskRetriedState,
+		expectedStatus: corev1.ConditionUnknown,
+	}}
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
 			c := GetPipelineConditionStatus("somepipelinerun", tc.state, zap.NewNop().Sugar(), &metav1.Time{Time: time.Now()},
@@ -1032,24 +981,21 @@ func TestResolvePipelineRun_ResourceBindingsDontExist(t *testing.T) {
 	tests := []struct {
 		name string
 		p    *v1alpha1.Pipeline
-	}{
-		{
-			name: "input doesnt exist",
-			p: tb.Pipeline("pipelines", "namespace", tb.PipelineSpec(
-				tb.PipelineTask("mytask1", "task",
-					tb.PipelineTaskInputResource("input1", "git-resource"),
-				),
-			)),
-		},
-		{
-			name: "output doesnt exist",
-			p: tb.Pipeline("pipelines", "namespace", tb.PipelineSpec(
-				tb.PipelineTask("mytask1", "task",
-					tb.PipelineTaskOutputResource("input1", "git-resource"),
-				),
-			)),
-		},
-	}
+	}{{
+		name: "input doesnt exist",
+		p: tb.Pipeline("pipelines", "namespace", tb.PipelineSpec(
+			tb.PipelineTask("mytask1", "task",
+				tb.PipelineTaskInputResource("input1", "git-resource"),
+			),
+		)),
+	}, {
+		name: "output doesnt exist",
+		p: tb.Pipeline("pipelines", "namespace", tb.PipelineSpec(
+			tb.PipelineTask("mytask1", "task",
+				tb.PipelineTaskOutputResource("input1", "git-resource"),
+			),
+		)),
+	}}
 	providedResources := map[string]v1alpha1.PipelineResourceRef{}
 
 	getTask := func(name string) (v1alpha1.TaskInterface, error) { return task, nil }
@@ -1078,24 +1024,21 @@ func TestResolvePipelineRun_ResourcesDontExist(t *testing.T) {
 	tests := []struct {
 		name string
 		p    *v1alpha1.Pipeline
-	}{
-		{
-			name: "input doesnt exist",
-			p: tb.Pipeline("pipelines", "namespace", tb.PipelineSpec(
-				tb.PipelineTask("mytask1", "task",
-					tb.PipelineTaskInputResource("input1", "git-resource"),
-				),
-			)),
-		},
-		{
-			name: "output doesnt exist",
-			p: tb.Pipeline("pipelines", "namespace", tb.PipelineSpec(
-				tb.PipelineTask("mytask1", "task",
-					tb.PipelineTaskOutputResource("input1", "git-resource"),
-				),
-			)),
-		},
-	}
+	}{{
+		name: "input doesnt exist",
+		p: tb.Pipeline("pipelines", "namespace", tb.PipelineSpec(
+			tb.PipelineTask("mytask1", "task",
+				tb.PipelineTaskInputResource("input1", "git-resource"),
+			),
+		)),
+	}, {
+		name: "output doesnt exist",
+		p: tb.Pipeline("pipelines", "namespace", tb.PipelineSpec(
+			tb.PipelineTask("mytask1", "task",
+				tb.PipelineTaskOutputResource("input1", "git-resource"),
+			),
+		)),
+	}}
 	providedResources := map[string]v1alpha1.PipelineResourceRef{
 		"git-resource": {
 			Name: "doesnt-exist",
diff --git a/pkg/reconciler/v1alpha1/taskrun/resources/apply_test.go b/pkg/reconciler/v1alpha1/taskrun/resources/apply_test.go
index b2013038dc3..920f6afc121 100644
--- a/pkg/reconciler/v1alpha1/taskrun/resources/apply_test.go
+++ b/pkg/reconciler/v1alpha1/taskrun/resources/apply_test.go
@@ -143,12 +143,10 @@ var gcsTaskSpec = &v1alpha1.TaskSpec{
 var paramTaskRun = &v1alpha1.TaskRun{
 	Spec: v1alpha1.TaskRunSpec{
 		Inputs: v1alpha1.TaskRunInputs{
-			Params: []v1alpha1.Param{
-				{
-					Name:  "myimage",
-					Value: "bar",
-				},
-			},
+			Params: []v1alpha1.Param{{
+				Name:  "myimage",
+				Value: "bar",
+			}},
 		},
 	},
 }
@@ -168,12 +166,10 @@ var gitResource, _ = v1alpha1.ResourceFromType(&v1alpha1.PipelineResource{
 	},
 	Spec: v1alpha1.PipelineResourceSpec{
 		Type: v1alpha1.PipelineResourceTypeGit,
-		Params: []v1alpha1.Param{
-			{
-				Name:  "URL",
-				Value: "https://git-repo",
-			},
-		},
+		Params: []v1alpha1.Param{{
+			Name:  "URL",
+			Value: "https://git-repo",
+		}},
 	},
 })
 
@@ -183,12 +179,10 @@ var imageResource, _ = v1alpha1.ResourceFromType(&v1alpha1.PipelineResource{
 	},
 	Spec: v1alpha1.PipelineResourceSpec{
 		Type: v1alpha1.PipelineResourceTypeImage,
-		Params: []v1alpha1.Param{
-			{
-				Name:  "URL",
-				Value: "gcr.io/hans/sandwiches",
-			},
-		},
+		Params: []v1alpha1.Param{{
+			Name:  "URL",
+			Value: "gcr.io/hans/sandwiches",
+		}},
 	},
 })
 
@@ -198,16 +192,13 @@ var gcsResource, _ = v1alpha1.ResourceFromType(&v1alpha1.PipelineResource{
 	},
 	Spec: v1alpha1.PipelineResourceSpec{
 		Type: v1alpha1.PipelineResourceTypeStorage,
-		Params: []v1alpha1.Param{
-			{
-				Name:  "type",
-				Value: "gcs",
-			},
-			{
-				Name:  "location",
-				Value: "theCloud?",
-			},
-		},
+		Params: []v1alpha1.Param{{
+			Name:  "type",
+			Value: "gcs",
+		}, {
+			Name:  "location",
+			Value: "theCloud?",
+		}},
 	},
 })
 
@@ -415,8 +406,7 @@ func TestApplyResources(t *testing.T) {
 		want: applyMutation(gcsTaskSpec, func(spec *v1alpha1.TaskSpec) {
 			spec.Steps[0].Args = []string{"/workspace/outputs/bucket"}
 		}),
-	},
-	}
+	}}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			setup()
diff --git a/pkg/reconciler/v1alpha1/taskrun/resources/pod_test.go b/pkg/reconciler/v1alpha1/taskrun/resources/pod_test.go
index 068bea565bb..af37a9b96e5 100644
--- a/pkg/reconciler/v1alpha1/taskrun/resources/pod_test.go
+++ b/pkg/reconciler/v1alpha1/taskrun/resources/pod_test.go
@@ -443,31 +443,28 @@ func TestMakeAnnotations(t *testing.T) {
 		taskRun                  *v1alpha1.TaskRun
 		expectedAnnotationSubset map[string]string
 	}
-	for _, c := range []testcase{
-		{
-			desc: "a taskruns annotations are copied to the pod",
-			taskRun: &v1alpha1.TaskRun{
-				ObjectMeta: metav1.ObjectMeta{
-					Name: "a-taskrun",
-					Annotations: map[string]string{
-						"foo": "bar",
-						"baz": "quux",
-					},
+	for _, c := range []testcase{{
+		desc: "a taskruns annotations are copied to the pod",
+		taskRun: &v1alpha1.TaskRun{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: "a-taskrun",
+				Annotations: map[string]string{
+					"foo": "bar",
+					"baz": "quux",
 				},
 			},
-			expectedAnnotationSubset: map[string]string{
-				"foo": "bar",
-				"baz": "quux",
-			},
 		},
-		{
-			desc:    "initial pod annotations contain the ReadyAnnotation to pause steps until sidecars are ready",
-			taskRun: &v1alpha1.TaskRun{},
-			expectedAnnotationSubset: map[string]string{
-				ReadyAnnotation: "",
-			},
+		expectedAnnotationSubset: map[string]string{
+			"foo": "bar",
+			"baz": "quux",
+		},
+	}, {
+		desc:    "initial pod annotations contain the ReadyAnnotation to pause steps until sidecars are ready",
+		taskRun: &v1alpha1.TaskRun{},
+		expectedAnnotationSubset: map[string]string{
+			ReadyAnnotation: "",
 		},
-	} {
+	}} {
 		t.Run(c.desc, func(t *testing.T) {
 			annos := makeAnnotations(c.taskRun)
 			for k, v := range c.expectedAnnotationSubset {
diff --git a/pkg/reconciler/v1alpha1/taskrun/taskrun_test.go b/pkg/reconciler/v1alpha1/taskrun/taskrun_test.go
index 709de0cfe4f..eecf2003316 100644
--- a/pkg/reconciler/v1alpha1/taskrun/taskrun_test.go
+++ b/pkg/reconciler/v1alpha1/taskrun/taskrun_test.go
@@ -1494,8 +1494,7 @@ func TestReconcileTimeouts(t *testing.T) {
 				Reason:  "TaskRunTimeout",
 				Message: `TaskRun "test-taskrun-timeout" failed to finish within "10s"`,
 			},
-		},
-		{
+		}, {
 			taskRun: tb.TaskRun("test-taskrun-default-timeout-60-minutes", "foo",
 				tb.TaskRunSpec(
 					tb.TaskRunTaskRef(simpleTask.Name),
@@ -1511,8 +1510,7 @@ func TestReconcileTimeouts(t *testing.T) {
 				Reason:  "TaskRunTimeout",
 				Message: `TaskRun "test-taskrun-default-timeout-60-minutes" failed to finish within "1h0m0s"`,
 			},
-		},
-		{
+		}, {
 			taskRun: tb.TaskRun("test-taskrun-nil-timeout-default-60-minutes", "foo",
 				tb.TaskRunSpec(
 					tb.TaskRunTaskRef(simpleTask.Name),
@@ -1529,8 +1527,7 @@ func TestReconcileTimeouts(t *testing.T) {
 				Reason:  "TaskRunTimeout",
 				Message: `TaskRun "test-taskrun-nil-timeout-default-60-minutes" failed to finish within "1h0m0s"`,
 			},
-		},
-	}
+		}}
 
 	for _, tc := range testcases {
 		d := test.Data{
@@ -1587,22 +1584,19 @@ func TestHandlePodCreationError(t *testing.T) {
 		expectedType   apis.ConditionType
 		expectedStatus corev1.ConditionStatus
 		expectedReason string
-	}{
-		{
-			description:    "exceeded quota errors are surfaced in taskrun condition but do not fail taskrun",
-			err:            k8sapierrors.NewForbidden(k8sruntimeschema.GroupResource{Group: "foo", Resource: "bar"}, "baz", errors.New("exceeded quota")),
-			expectedType:   apis.ConditionSucceeded,
-			expectedStatus: corev1.ConditionUnknown,
-			expectedReason: status.ReasonExceededResourceQuota,
-		},
-		{
-			description:    "errors other than exceeded quota fail the taskrun",
-			err:            errors.New("this is a fatal error"),
-			expectedType:   apis.ConditionSucceeded,
-			expectedStatus: corev1.ConditionFalse,
-			expectedReason: status.ReasonCouldntGetTask,
-		},
-	}
+	}{{
+		description:    "exceeded quota errors are surfaced in taskrun condition but do not fail taskrun",
+		err:            k8sapierrors.NewForbidden(k8sruntimeschema.GroupResource{Group: "foo", Resource: "bar"}, "baz", errors.New("exceeded quota")),
+		expectedType:   apis.ConditionSucceeded,
+		expectedStatus: corev1.ConditionUnknown,
+		expectedReason: status.ReasonExceededResourceQuota,
+	}, {
+		description:    "errors other than exceeded quota fail the taskrun",
+		err:            errors.New("this is a fatal error"),
+		expectedType:   apis.ConditionSucceeded,
+		expectedStatus: corev1.ConditionFalse,
+		expectedReason: status.ReasonCouldntGetTask,
+	}}
 	for _, tc := range testcases {
 		t.Run(tc.description, func(t *testing.T) {
 			c.handlePodCreationError(taskRun, tc.err)
diff --git a/pkg/system/names_test.go b/pkg/system/names_test.go
index a1bbe1b3991..3e4fda7737f 100644
--- a/pkg/system/names_test.go
+++ b/pkg/system/names_test.go
@@ -9,16 +9,13 @@ func Test_GetNamespace(t *testing.T) {
 	testcases := []struct {
 		envVar       string
 		expectEnvVar string
-	}{
-		{
-			envVar:       "",
-			expectEnvVar: DefaultNamespace,
-		},
-		{
-			envVar:       "test",
-			expectEnvVar: "test",
-		},
-	}
+	}{{
+		envVar:       "",
+		expectEnvVar: DefaultNamespace,
+	}, {
+		envVar:       "test",
+		expectEnvVar: "test",
+	}}
 
 	value := os.Getenv(SystemNamespaceEnvVar)
 	defer func() { os.Setenv(SystemNamespaceEnvVar, value) }()
diff --git a/pkg/templating/templating_test.go b/pkg/templating/templating_test.go
index 5a5caa135b1..3f3cb292e5a 100644
--- a/pkg/templating/templating_test.go
+++ b/pkg/templating/templating_test.go
@@ -38,84 +38,78 @@ func TestValidateVariables(t *testing.T) {
 		name          string
 		args          args
 		expectedError *apis.FieldError
-	}{
-		{
-			name: "valid variable",
-			args: args{
-				input:         "--flag=${inputs.params.baz}",
-				prefix:        "params",
-				contextPrefix: "inputs.",
-				locationName:  "step",
-				path:          "taskspec.steps",
-				vars: map[string]struct{}{
-					"baz": {},
-				},
+	}{{
+		name: "valid variable",
+		args: args{
+			input:         "--flag=${inputs.params.baz}",
+			prefix:        "params",
+			contextPrefix: "inputs.",
+			locationName:  "step",
+			path:          "taskspec.steps",
+			vars: map[string]struct{}{
+				"baz": {},
 			},
-			expectedError: nil,
 		},
-		{
-			name: "multiple variables",
-			args: args{
-				input:         "--flag=${inputs.params.baz} ${input.params.foo}",
-				prefix:        "params",
-				contextPrefix: "inputs.",
-				locationName:  "step",
-				path:          "taskspec.steps",
-				vars: map[string]struct{}{
-					"baz": {},
-					"foo": {},
-				},
+		expectedError: nil,
+	}, {
+		name: "multiple variables",
+		args: args{
+			input:         "--flag=${inputs.params.baz} ${input.params.foo}",
+			prefix:        "params",
+			contextPrefix: "inputs.",
+			locationName:  "step",
+			path:          "taskspec.steps",
+			vars: map[string]struct{}{
+				"baz": {},
+				"foo": {},
 			},
-			expectedError: nil,
 		},
-		{
-			name: "different context and prefix",
-			args: args{
-				input:        "--flag=${something.baz}",
-				prefix:       "something",
-				locationName: "step",
-				path:         "taskspec.steps",
-				vars: map[string]struct{}{
-					"baz": {},
-				},
+		expectedError: nil,
+	}, {
+		name: "different context and prefix",
+		args: args{
+			input:        "--flag=${something.baz}",
+			prefix:       "something",
+			locationName: "step",
+			path:         "taskspec.steps",
+			vars: map[string]struct{}{
+				"baz": {},
 			},
-			expectedError: nil,
 		},
-		{
-			name: "undefined variable",
-			args: args{
-				input:         "--flag=${inputs.params.baz}",
-				prefix:        "params",
-				contextPrefix: "inputs.",
-				locationName:  "step",
-				path:          "taskspec.steps",
-				vars: map[string]struct{}{
-					"foo": {},
-				},
-			},
-			expectedError: &apis.FieldError{
-				Message: `non-existent variable in "--flag=${inputs.params.baz}" for step somefield`,
-				Paths:   []string{"taskspec.steps.somefield"},
+		expectedError: nil,
+	}, {
+		name: "undefined variable",
+		args: args{
+			input:         "--flag=${inputs.params.baz}",
+			prefix:        "params",
+			contextPrefix: "inputs.",
+			locationName:  "step",
+			path:          "taskspec.steps",
+			vars: map[string]struct{}{
+				"foo": {},
 			},
 		},
-		{
-			name: "undefined variable and defined variable",
-			args: args{
-				input:         "--flag=${inputs.params.baz} ${input.params.foo}",
-				prefix:        "params",
-				contextPrefix: "inputs.",
-				locationName:  "step",
-				path:          "taskspec.steps",
-				vars: map[string]struct{}{
-					"foo": {},
-				},
-			},
-			expectedError: &apis.FieldError{
-				Message: `non-existent variable in "--flag=${inputs.params.baz} ${input.params.foo}" for step somefield`,
-				Paths:   []string{"taskspec.steps.somefield"},
+		expectedError: &apis.FieldError{
+			Message: `non-existent variable in "--flag=${inputs.params.baz}" for step somefield`,
+			Paths:   []string{"taskspec.steps.somefield"},
+		},
+	}, {
+		name: "undefined variable and defined variable",
+		args: args{
+			input:         "--flag=${inputs.params.baz} ${input.params.foo}",
+			prefix:        "params",
+			contextPrefix: "inputs.",
+			locationName:  "step",
+			path:          "taskspec.steps",
+			vars: map[string]struct{}{
+				"foo": {},
 			},
 		},
-	}
+		expectedError: &apis.FieldError{
+			Message: `non-existent variable in "--flag=${inputs.params.baz} ${input.params.foo}" for step somefield`,
+			Paths:   []string{"taskspec.steps.somefield"},
+		},
+	}}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got := templating.ValidateVariable("somefield", tt.args.input, tt.args.prefix, tt.args.contextPrefix, tt.args.locationName, tt.args.path, tt.args.vars)