benchmark: PR 5093 (ginkgolinter)

[ldez]

{
"pr": 5093,
"linter": "ginkgolinter",
"version": "v1.61.0"
}

[github-actions]

The benchmark (Benchmark PR (updated linter)) is done!

beego/beego

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
local	836.6 ± 17.2	816.8	871.5	1.05 ± 0.03
v1.61.0	794.6 ± 16.0	766.0	818.9	1.00

cilium/cilium

local

test/k8s/assertion_helpers.go:23:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "kube-dns was not able to get into ready state")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "kube-dns was not able to get into ready state")
	^
test/k8s/assertion_helpers.go:27:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "kube-dns service not ready")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "kube-dns service not ready")
	^
test/k8s/assertion_helpers.go:36:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "cilium pre-flight checks failed")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "cilium pre-flight checks failed")
	^
test/k8s/assertion_helpers.go:49:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "Cilium operator was not able to get into ready state")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "Cilium operator was not able to get into ready state")
	^
test/k8s/assertion_helpers.go:57:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "hubble-cli was not able to get into ready state")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "hubble-cli was not able to get into ready state")
	^
test/k8s/assertion_helpers.go:65:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "hubble-relay was not able to get into ready state")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "hubble-relay was not able to get into ready state")
	^
test/k8s/assertion_helpers.go:72:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ToNot(HaveOccurred(), "terminating containers are not deleted after timeout")` instead (ginkgolinter)
	ExpectWithOffset(1, err).To(BeNil(), "terminating containers are not deleted after timeout")
	^
test/k8s/assertion_helpers.go:79:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ToNot(HaveOccurred(), "terminating containers are not deleted after timeout")` instead (ginkgolinter)
	ExpectWithOffset(1, err).To(BeNil(), "terminating containers are not deleted after timeout")
	^
test/k8s/assertion_helpers.go:95:2: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "cilium pre-flight check is not ready after timeout, pods status:\n %s", warningMessage)` instead (ginkgolinter)
	Expect(err).To(BeNil(), "cilium pre-flight check is not ready after timeout, pods status:\n %s", warningMessage)
	^
test/k8s/assertion_helpers.go:106:2: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Cilium cannot be installed")` instead (ginkgolinter)
	Expect(err).To(BeNil(), "Cilium cannot be installed")
	^
test/k8s/assertion_helpers.go:118:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "cilium pre-flight checks failed")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "cilium pre-flight checks failed")
	^
test/k8s/assertion_helpers.go:128:2: ginkgo-linter: wrong error assertion. Consider using `Expect(vm.DeleteAndWait(ciliumFilename, true).GetError()).
	To(Succeed(), "Error removing cilium from installed manifest")` instead (ginkgolinter)
	Expect(vm.DeleteAndWait(ciliumFilename, true).GetError()).
	^
test/k8s/assertion_helpers.go:214:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "cilium pre-flight checks failed")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "cilium pre-flight checks failed")
	^
test/k8s/assertion_helpers.go:220:3: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "kube-system pods were not able to get into ready state after restart")` instead (ginkgolinter)
		ExpectWithOffset(1, err).Should(BeNil(), "kube-system pods were not able to get into ready state after restart")
		^
test/k8s/bandwidth.go:78:5: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred())` instead (ginkgolinter)
				Expect(err).Should(BeNil())
				^
test/k8s/bandwidth.go:84:4: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "cannot retrieve pod names by filter %q",
	clientPodLabel)` instead (ginkgolinter)
			ExpectWithOffset(1, err).Should(BeNil(), "cannot retrieve pod names by filter %q",
			^
test/k8s/bandwidth.go:96:7: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, res.InRange(minBandwidth, rate+maxRateDeviation)).To(Succeed(), "Rate mismatch")` instead (ginkgolinter)
						ExpectWithOffset(1, res.InRange(minBandwidth, rate+maxRateDeviation)).To(BeNil(),
						^
test/k8s/bandwidth.go:106:5: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "Cannot retrieve pod IPs for %s", label)` instead (ginkgolinter)
				ExpectWithOffset(1, err).Should(BeNil(), "Cannot retrieve pod IPs for %s", label)
				^
test/k8s/bandwidth.go:107:5: ginkgo-linter: wrong length assertion. Consider using `ExpectWithOffset(1, podIPs).To(HaveLen(int(1)), "Expected pod IPs mismatch")` instead (ginkgolinter)
				ExpectWithOffset(1, len(podIPs)).To(Equal(int(1)), "Expected pod IPs mismatch")
				^
test/k8s/bgp.go:39:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Cannot get nodes info")` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Cannot get nodes info")
			^
test/k8s/bgp.go:144:5: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Cannot retrieve LB IP for test-lb")` instead (ginkgolinter)
				Expect(err).Should(BeNil(), "Cannot retrieve LB IP for test-lb")
				^
test/k8s/chaos.go:62:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Pods are not ready after timeout")` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Pods are not ready after timeout")
			^
test/k8s/chaos.go:79:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Cannot get pods names")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Cannot get pods names")
			^
test/k8s/chaos.go:80:4: ginkgo-linter: wrong length assertion. Consider using `Expect(pods).ToNot(BeEmpty(), "No pods available to test connectivity")` instead (ginkgolinter)
			Expect(len(pods)).To(BeNumerically(">", 0), "No pods available to test connectivity")
			^
test/k8s/chaos.go:83:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Cannot get daemonset pods IPS")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Cannot get daemonset pods IPS")
			^
test/k8s/chaos.go:84:4: ginkgo-linter: wrong length assertion. Consider using `Expect(dsPods).ToNot(BeEmpty(), "No pods available to test connectivity")` instead (ginkgolinter)
			Expect(len(dsPods)).To(BeNumerically(">", 0), "No pods available to test connectivity")
			^
test/k8s/chaos.go:88:4: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ToNot(HaveOccurred(), "DNS entry is not ready after timeout")` instead (ginkgolinter)
			ExpectWithOffset(1, err).To(BeNil(), "DNS entry is not ready after timeout")
			^
test/k8s/chaos.go:92:4: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ToNot(HaveOccurred(), "unable to get ClusterIP and port for service testds-service")` instead (ginkgolinter)
			ExpectWithOffset(1, err).To(BeNil(), "unable to get ClusterIP and port for service testds-service")
			^
test/k8s/chaos.go:123:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Pods are not ready after timeout")` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Pods are not ready after timeout")
			^
test/k8s/chaos.go:126:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Endpoints are not ready after timeout")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Endpoints are not ready after timeout")
			^
test/k8s/chaos.go:133:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not list Cilium pods")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not list Cilium pods")
			^
test/k8s/chaos.go:135:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not look up numeric identity for 1.1.1.1")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not look up numeric identity for 1.1.1.1")
			^
test/k8s/chaos.go:146:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Endpoints are not ready after Cilium restarts")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Endpoints are not ready after Cilium restarts")
			^
test/k8s/chaos.go:153:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not list Cilium pods")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not list Cilium pods")
			^
test/k8s/chaos.go:155:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not look up numeric identity for 1.1.1.1")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not look up numeric identity for 1.1.1.1")
			^
test/k8s/chaos.go:171:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Cilium cannot be installed")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Cilium cannot be installed")
			^
test/k8s/chaos.go:176:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Endpoints are not ready after timeout")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Endpoints are not ready after timeout")
			^
test/k8s/chaos.go:183:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not list Cilium pods")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not list Cilium pods")
			^
test/k8s/chaos.go:185:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not look up numeric identity for 1.1.1.1")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not look up numeric identity for 1.1.1.1")
			^
test/k8s/chaos.go:210:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Pods are not ready after timeout")` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Pods are not ready after timeout")
			^
test/k8s/chaos.go:213:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Cannot get pods ips")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Cannot get pods ips")
			^
test/k8s/chaos.go:216:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "cannot get service netperf ip")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "cannot get service netperf ip")
			^
test/k8s/chaos.go:243:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Pods are not ready after timeout")` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Pods are not ready after timeout")
			^
test/k8s/chaos.go:246:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Endpoints are not ready after timeout")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Endpoints are not ready after timeout")
			^
test/k8s/chaos.go:278:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Cannot install %q policy", netperfPolicy)` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Cannot install %q policy", netperfPolicy)
			^
test/k8s/config.go:39:3: ginkgo-linter: wrong error assertion. Consider using `Expect(res.GetErr("unlabel node")).To(Succeed())` instead (ginkgolinter)
		Expect(res.GetErr("unlabel node")).To(BeNil())
		^
test/k8s/config.go:47:3: ginkgo-linter: wrong error assertion. Consider using `Expect(res.GetErr("unlabel node")).To(Succeed())` instead (ginkgolinter)
		Expect(res.GetErr("unlabel node")).To(BeNil())
		^
test/k8s/config.go:54:3: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "error finding cilium pods")` instead (ginkgolinter)
		Expect(err).To(BeNil(), "error finding cilium pods")
		^
test/k8s/config.go:76:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "error finding cilium pods")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "error finding cilium pods")
			^
test/k8s/config.go:105:3: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred())` instead (ginkgolinter)
		Expect(err).Should(BeNil())
		^

v1.61.0

test/k8s/assertion_helpers.go:23:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "kube-dns was not able to get into ready state")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "kube-dns was not able to get into ready state")
	^
test/k8s/assertion_helpers.go:27:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "kube-dns service not ready")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "kube-dns service not ready")
	^
test/k8s/assertion_helpers.go:36:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "cilium pre-flight checks failed")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "cilium pre-flight checks failed")
	^
test/k8s/assertion_helpers.go:49:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "Cilium operator was not able to get into ready state")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "Cilium operator was not able to get into ready state")
	^
test/k8s/assertion_helpers.go:57:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "hubble-cli was not able to get into ready state")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "hubble-cli was not able to get into ready state")
	^
test/k8s/assertion_helpers.go:65:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "hubble-relay was not able to get into ready state")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "hubble-relay was not able to get into ready state")
	^
test/k8s/assertion_helpers.go:72:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ToNot(HaveOccurred(), "terminating containers are not deleted after timeout")` instead (ginkgolinter)
	ExpectWithOffset(1, err).To(BeNil(), "terminating containers are not deleted after timeout")
	^
test/k8s/assertion_helpers.go:79:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ToNot(HaveOccurred(), "terminating containers are not deleted after timeout")` instead (ginkgolinter)
	ExpectWithOffset(1, err).To(BeNil(), "terminating containers are not deleted after timeout")
	^
test/k8s/assertion_helpers.go:95:2: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "cilium pre-flight check is not ready after timeout, pods status:\n %s", warningMessage)` instead (ginkgolinter)
	Expect(err).To(BeNil(), "cilium pre-flight check is not ready after timeout, pods status:\n %s", warningMessage)
	^
test/k8s/assertion_helpers.go:106:2: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Cilium cannot be installed")` instead (ginkgolinter)
	Expect(err).To(BeNil(), "Cilium cannot be installed")
	^
test/k8s/assertion_helpers.go:118:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "cilium pre-flight checks failed")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "cilium pre-flight checks failed")
	^
test/k8s/assertion_helpers.go:128:2: ginkgo-linter: wrong error assertion. Consider using `Expect(vm.DeleteAndWait(ciliumFilename, true).GetError()).
	To(Succeed(), "Error removing cilium from installed manifest")` instead (ginkgolinter)
	Expect(vm.DeleteAndWait(ciliumFilename, true).GetError()).
	^
test/k8s/assertion_helpers.go:214:2: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "cilium pre-flight checks failed")` instead (ginkgolinter)
	ExpectWithOffset(1, err).Should(BeNil(), "cilium pre-flight checks failed")
	^
test/k8s/assertion_helpers.go:220:3: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "kube-system pods were not able to get into ready state after restart")` instead (ginkgolinter)
		ExpectWithOffset(1, err).Should(BeNil(), "kube-system pods were not able to get into ready state after restart")
		^
test/k8s/bandwidth.go:78:5: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred())` instead (ginkgolinter)
				Expect(err).Should(BeNil())
				^
test/k8s/bandwidth.go:84:4: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "cannot retrieve pod names by filter %q",
	clientPodLabel)` instead (ginkgolinter)
			ExpectWithOffset(1, err).Should(BeNil(), "cannot retrieve pod names by filter %q",
			^
test/k8s/bandwidth.go:96:7: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, res.InRange(minBandwidth, rate+maxRateDeviation)).To(Succeed(), "Rate mismatch")` instead (ginkgolinter)
						ExpectWithOffset(1, res.InRange(minBandwidth, rate+maxRateDeviation)).To(BeNil(),
						^
test/k8s/bandwidth.go:106:5: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ShouldNot(HaveOccurred(), "Cannot retrieve pod IPs for %s", label)` instead (ginkgolinter)
				ExpectWithOffset(1, err).Should(BeNil(), "Cannot retrieve pod IPs for %s", label)
				^
test/k8s/bandwidth.go:107:5: ginkgo-linter: wrong length assertion. Consider using `ExpectWithOffset(1, podIPs).To(HaveLen(int(1)), "Expected pod IPs mismatch")` instead (ginkgolinter)
				ExpectWithOffset(1, len(podIPs)).To(Equal(int(1)), "Expected pod IPs mismatch")
				^
test/k8s/bgp.go:39:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Cannot get nodes info")` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Cannot get nodes info")
			^
test/k8s/bgp.go:144:5: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Cannot retrieve LB IP for test-lb")` instead (ginkgolinter)
				Expect(err).Should(BeNil(), "Cannot retrieve LB IP for test-lb")
				^
test/k8s/chaos.go:62:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Pods are not ready after timeout")` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Pods are not ready after timeout")
			^
test/k8s/chaos.go:79:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Cannot get pods names")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Cannot get pods names")
			^
test/k8s/chaos.go:80:4: ginkgo-linter: wrong length assertion. Consider using `Expect(pods).ToNot(BeEmpty(), "No pods available to test connectivity")` instead (ginkgolinter)
			Expect(len(pods)).To(BeNumerically(">", 0), "No pods available to test connectivity")
			^
test/k8s/chaos.go:83:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Cannot get daemonset pods IPS")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Cannot get daemonset pods IPS")
			^
test/k8s/chaos.go:84:4: ginkgo-linter: wrong length assertion. Consider using `Expect(dsPods).ToNot(BeEmpty(), "No pods available to test connectivity")` instead (ginkgolinter)
			Expect(len(dsPods)).To(BeNumerically(">", 0), "No pods available to test connectivity")
			^
test/k8s/chaos.go:88:4: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ToNot(HaveOccurred(), "DNS entry is not ready after timeout")` instead (ginkgolinter)
			ExpectWithOffset(1, err).To(BeNil(), "DNS entry is not ready after timeout")
			^
test/k8s/chaos.go:92:4: ginkgo-linter: wrong error assertion. Consider using `ExpectWithOffset(1, err).ToNot(HaveOccurred(), "unable to get ClusterIP and port for service testds-service")` instead (ginkgolinter)
			ExpectWithOffset(1, err).To(BeNil(), "unable to get ClusterIP and port for service testds-service")
			^
test/k8s/chaos.go:123:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Pods are not ready after timeout")` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Pods are not ready after timeout")
			^
test/k8s/chaos.go:126:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Endpoints are not ready after timeout")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Endpoints are not ready after timeout")
			^
test/k8s/chaos.go:133:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not list Cilium pods")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not list Cilium pods")
			^
test/k8s/chaos.go:135:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not look up numeric identity for 1.1.1.1")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not look up numeric identity for 1.1.1.1")
			^
test/k8s/chaos.go:146:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Endpoints are not ready after Cilium restarts")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Endpoints are not ready after Cilium restarts")
			^
test/k8s/chaos.go:153:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not list Cilium pods")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not list Cilium pods")
			^
test/k8s/chaos.go:155:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not look up numeric identity for 1.1.1.1")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not look up numeric identity for 1.1.1.1")
			^
test/k8s/chaos.go:171:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Cilium cannot be installed")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Cilium cannot be installed")
			^
test/k8s/chaos.go:176:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Endpoints are not ready after timeout")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Endpoints are not ready after timeout")
			^
test/k8s/chaos.go:183:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not list Cilium pods")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not list Cilium pods")
			^
test/k8s/chaos.go:185:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Could not look up numeric identity for 1.1.1.1")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Could not look up numeric identity for 1.1.1.1")
			^
test/k8s/chaos.go:210:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Pods are not ready after timeout")` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Pods are not ready after timeout")
			^
test/k8s/chaos.go:213:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Cannot get pods ips")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Cannot get pods ips")
			^
test/k8s/chaos.go:216:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "cannot get service netperf ip")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "cannot get service netperf ip")
			^
test/k8s/chaos.go:243:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Pods are not ready after timeout")` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Pods are not ready after timeout")
			^
test/k8s/chaos.go:246:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "Endpoints are not ready after timeout")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "Endpoints are not ready after timeout")
			^
test/k8s/chaos.go:278:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred(), "Cannot install %q policy", netperfPolicy)` instead (ginkgolinter)
			Expect(err).Should(BeNil(), "Cannot install %q policy", netperfPolicy)
			^
test/k8s/config.go:39:3: ginkgo-linter: wrong error assertion. Consider using `Expect(res.GetErr("unlabel node")).To(Succeed())` instead (ginkgolinter)
		Expect(res.GetErr("unlabel node")).To(BeNil())
		^
test/k8s/config.go:47:3: ginkgo-linter: wrong error assertion. Consider using `Expect(res.GetErr("unlabel node")).To(Succeed())` instead (ginkgolinter)
		Expect(res.GetErr("unlabel node")).To(BeNil())
		^
test/k8s/config.go:54:3: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "error finding cilium pods")` instead (ginkgolinter)
		Expect(err).To(BeNil(), "error finding cilium pods")
		^
test/k8s/config.go:76:4: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ToNot(HaveOccurred(), "error finding cilium pods")` instead (ginkgolinter)
			Expect(err).To(BeNil(), "error finding cilium pods")
			^
test/k8s/config.go:105:3: ginkgo-linter: wrong error assertion. Consider using `Expect(err).ShouldNot(HaveOccurred())` instead (ginkgolinter)
		Expect(err).Should(BeNil())
		^

Command	Mean [s]	Min [s]	Max [s]	Relative
local	6.180 ± 0.087	6.079	6.339	1.01 ± 0.02
v1.61.0	6.144 ± 0.072	6.014	6.240	1.00

spf13/cobra

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
local	329.0 ± 2.9	324.2	332.5	1.09 ± 0.02
v1.61.0	301.4 ± 6.3	294.3	315.3	1.00

hashicorp/consul

Command	Mean [s]	Min [s]	Max [s]	Relative
local	4.931 ± 0.026	4.899	4.984	1.01 ± 0.01
v1.61.0	4.889 ± 0.043	4.810	4.939	1.00

go-delve/delve

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
local	895.2 ± 21.3	861.3	929.4	1.02 ± 0.07
v1.61.0	873.9 ± 52.7	845.6	1018.9	1.00

etcd-io/etcd

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
local	574.4 ± 6.8	564.7	584.5	1.06 ± 0.02
v1.61.0	542.6 ± 11.1	526.8	565.9	1.00

go-gitea/gitea

Command	Mean [s]	Min [s]	Max [s]	Relative
local	3.576 ± 0.053	3.470	3.676	1.02 ± 0.02
v1.61.0	3.511 ± 0.033	3.463	3.563	1.00

google/go-github

Command	Mean [s]	Min [s]	Max [s]	Relative
local	1.578 ± 0.034	1.547	1.636	1.05 ± 0.03
v1.61.0	1.499 ± 0.016	1.475	1.530	1.00

golangci/golangci-lint

Command	Mean [s]	Min [s]	Max [s]	Relative
local	1.026 ± 0.011	1.010	1.041	1.03 ± 0.02
v1.61.0	0.995 ± 0.015	0.979	1.031	1.00

goreleaser/goreleaser

Command	Mean [s]	Min [s]	Max [s]	Relative
local	1.614 ± 0.023	1.563	1.641	1.02 ± 0.02
v1.61.0	1.588 ± 0.025	1.533	1.614	1.00

grpc/grpc-go

Command	Mean [s]	Min [s]	Max [s]	Relative
local	1.606 ± 0.014	1.584	1.626	1.02 ± 0.01
v1.61.0	1.568 ± 0.012	1.549	1.583	1.00

gohugoio/hugo

Command	Mean [s]	Min [s]	Max [s]	Relative
local	2.576 ± 0.087	2.496	2.812	1.03 ± 0.04
v1.61.0	2.496 ± 0.043	2.437	2.592	1.00

kubernetes/kubernetes

local

test/e2e/common/node/kubelet.go:111:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	podData, err := podClient.Get(ctx, podName, metav1.GetOptions{})
	if err != nil {
		return err
	}
	if len(podData.Status.ContainerStatuses) != 1 {
		return fmt.Errorf("expected only one container in the pod %q", podName)
	}
	contTerminatedState := podData.Status.ContainerStatuses[0].State.Terminated
	if contTerminatedState == nil {
		return fmt.Errorf("expected state to be terminated. Got pod status: %+v", podData.Status)
	}
	if contTerminatedState.ExitCode == 0 || contTerminatedState.Reason == "" {
		return fmt.Errorf("expected non-zero exitCode and non-empty terminated state reason. Got exitCode: %+v and terminated state reason: %+v", contTerminatedState.ExitCode, contTerminatedState.Reason)
	}
	return nil
}, framework.PodStartTimeout, time.Second*4).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e/common/node/lifecycle_hook.go:112:5: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	return podClient.MatchContainerOutput(ctx, podHandleHookRequest.Name, podHandleHookRequest.Spec.Containers[handlerContainer].Name,
		`GET /echo\?msg=poststart`)
}, postStartWaitTimeout, podCheckInterval).Should(gomega.Succeed())` instead (ginkgolinter)
				gomega.Eventually(ctx, func(ctx context.Context) error {
				^
test/e2e/common/node/lifecycle_hook.go:126:5: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	return podClient.MatchContainerOutput(ctx, podHandleHookRequest.Name, podHandleHookRequest.Spec.Containers[handlerContainer].Name,
		`GET /echo\?msg=prestop`)
}, preStopWaitTimeout, podCheckInterval).Should(gomega.Succeed())` instead (ginkgolinter)
				gomega.Eventually(ctx, func(ctx context.Context) error {
				^
test/e2e/common/node/lifecycle_hook.go:330:5: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	return podClient.MatchContainerOutput(ctx, podHandleHookRequest.Name, podHandleHookRequest.Spec.Containers[handlerContainer].Name,
		`GET /echo\?msg=poststart`)
}, postStartWaitTimeout, podCheckInterval).Should(gomega.Succeed())` instead (ginkgolinter)
				gomega.Eventually(ctx, func(ctx context.Context) error {
				^
test/e2e/common/node/lifecycle_hook.go:344:5: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	return podClient.MatchContainerOutput(ctx, podHandleHookRequest.Name, podHandleHookRequest.Spec.Containers[handlerContainer].Name,
		`GET /echo\?msg=prestop`)
}, preStopWaitTimeout, podCheckInterval).Should(gomega.Succeed())` instead (ginkgolinter)
				gomega.Eventually(ctx, func(ctx context.Context) error {
				^
test/e2e/common/node/node_lease.go:60:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	lease, err = leaseClient.Get(ctx, nodeName, metav1.GetOptions{})
	if err != nil {
		return err
	}
	return nil
}, 5*time.Minute, 5*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e/common/node/node_lease.go:97:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	leaseList, err = leaseClient.List(ctx, metav1.ListOptions{})
	if err != nil {
		return err
	}
	return nil
}, 5*time.Minute, 5*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e/common/node/node_lease.go:122:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	lease, err = f.ClientSet.CoordinationV1().Leases(v1.NamespaceNodeLease).Get(ctx, nodeName, metav1.GetOptions{})
	if err != nil {
		return err
	}
	return nil
}, 5*time.Minute, 5*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e/common/node/pod_resize.go:903:5: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
	WithArguments(patchedPod, initialContainers).
	Should(gomega.Succeed(), "failed to verify Pod allocations for patchedPod")` instead (ginkgolinter)
				gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
				^
test/e2e/common/node/pod_resize.go:918:5: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
	WithArguments(resizedPod, expectedContainers).
	Should(gomega.Succeed(), "failed to verify Pod allocations for resizedPod")` instead (ginkgolinter)
				gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
				^
test/e2e/common/node/pod_resize.go:1005:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
	WithArguments(patchedPod, tc.expected).
	Should(gomega.Succeed(), "failed to verify Pod allocations for patchedPod")` instead (ginkgolinter)
			gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
			^
test/e2e/common/node/pods.go:580:3: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	for {
		var msg []byte
		if err := websocket.Message.Receive(ws, &msg); err != nil {
			if err == io.EOF {
				break
			}
			framework.Failf("Failed to read completely from websocket %s: %v", url.String(), err)
		}
		if len(msg) == 0 {
			continue
		}
		if msg[0] != 1 {
			if len(msg) == 1 {

				continue
			} else {
				framework.Failf("Got message from server that didn't start with channel 1 (STDOUT): %v", msg)
			}

		}
		buf.Write(msg[1:])
	}
	if buf.Len() == 0 {
		return fmt.Errorf("unexpected output from server")
	}
	if !strings.Contains(buf.String(), "remote execution test") {
		return fmt.Errorf("expected to find 'remote execution test' in %q", buf.String())
	}
	return nil
}, time.Minute, 10*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
		gomega.Eventually(ctx, func() error {
		^
test/e2e/apps/statefulset.go:887:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	statefulPod, err := f.ClientSet.CoreV1().Pods(f.Namespace.Name).Get(ctx, statefulPodName, metav1.GetOptions{})
	if err != nil {
		return err
	}
	if statefulPod.Status.Phase != v1.PodRunning {
		return fmt.Errorf("pod %v is not in running phase: %v", statefulPod.Name, statefulPod.Status.Phase)
	} else if statefulPod.UID == initialStatefulPodUID {
		return fmt.Errorf("pod %v wasn't recreated: %v == %v", statefulPod.Name, statefulPod.UID, initialStatefulPodUID)
	}
	return nil
}, statefulPodTimeout, 2*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e/apimachinery/chunking.go:195:3: ginkgo-linter: wrong length assertion. Consider using `gomega.Expect(list.Items).To(gomega.HaveLen(opts.Limit))` instead (ginkgolinter)
		gomega.Expect(len(list.Items)).To(gomega.BeNumerically("==", opts.Limit))
		^
test/e2e/cloud/gcp/node_lease.go:115:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	pass := true
	for _, node := range originalNodes.Items {
		if _, err := leaseClient.Get(ctx, node.ObjectMeta.Name, metav1.GetOptions{}); err != nil {
			framework.Logf("Try to get lease of node %s, but got error: %v", node.ObjectMeta.Name, err)
			pass = false
		}
	}
	if pass {
		return nil
	}
	return fmt.Errorf("some node lease is not ready")
}, 1*time.Minute, 5*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e/cloud/gcp/node_lease.go:158:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	if _, err := leaseClient.Get(ctx, deletedNodeName, metav1.GetOptions{}); err == nil {
		return fmt.Errorf("node lease is not deleted yet for node %q", deletedNodeName)
	}
	return nil
}, 1*time.Minute, 5*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e/cloud/gcp/node_lease.go:166:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	for _, node := range targetNodes.Items {
		if _, err := leaseClient.Get(ctx, node.ObjectMeta.Name, metav1.GetOptions{}); err != nil {
			return err
		}
	}
	return nil
}, 1*time.Minute, 5*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e/dra/dra.go:135:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Consistently(ctx, func(ctx context.Context) error {
	testPod, err := b.f.ClientSet.CoreV1().Pods(pod.Namespace).Get(ctx, pod.Name, metav1.GetOptions{})
	if err != nil {
		return fmt.Errorf("expected the test pod %s to exist: %w", pod.Name, err)
	}
	if testPod.Status.Phase != v1.PodPending {
		return fmt.Errorf("pod %s: unexpected status %s, expected status: %s", pod.Name, testPod.Status.Phase, v1.PodPending)
	}
	return nil
}, 20*time.Second, 200*time.Millisecond).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Consistently(ctx, func(ctx context.Context) error {
			^
test/e2e/instrumentation/monitoring/metrics_grabber.go:46:3: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	grabber, err = e2emetrics.NewMetricsGrabber(ctx, c, ec, f.ClientConfig(), true, true, true, true, true, true)
	if err != nil {
		return fmt.Errorf("failed to create metrics grabber: %w", err)
	}
	return nil
}, 5*time.Minute, 10*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
		gomega.Eventually(ctx, func() error {
		^
test/e2e/instrumentation/metrics.go:45:3: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	grabber, err = e2emetrics.NewMetricsGrabber(ctx, c, ec, f.ClientConfig(), true, true, true, true, true, true)
	if err != nil {
		framework.ExpectNoError(err, "failed to create metrics grabber")
	}
	return nil
}, 5*time.Minute, 10*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
		gomega.Eventually(ctx, func() error {
		^
test/e2e/network/service.go:3762:3: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	return testEndpointReachability(ctx, service.Spec.ClusterIP, 80, v1.ProtocolUDP, execPod, 6*time.Second)
}).WithTimeout(30 * time.Second).WithPolling(5 * time.Second).ShouldNot(gomega.Succeed())` instead (ginkgolinter)
		gomega.Eventually(ctx, func() error {
		^
test/e2e/network/service.go:3785:3: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	return testEndpointReachability(ctx, service.Spec.ClusterIP, 80, v1.ProtocolTCP, execPod, 6*time.Second)
}).WithTimeout(30 * time.Second).WithPolling(5 * time.Second).ShouldNot(gomega.Succeed())` instead (ginkgolinter)
		gomega.Eventually(ctx, func() error {
		^
test/e2e/node/pod_resize.go:105:3: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
	WithArguments(patchedPod, containers).
	Should(gomega.Succeed(), "failed to verify Pod allocations for patchedPod")` instead (ginkgolinter)
		gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
		^
test/e2e/node/pod_resize.go:118:3: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
	WithArguments(resizedPod, expected).
	Should(gomega.Succeed(), "failed to verify Pod allocations for patchedPod")` instead (ginkgolinter)
		gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
		^
test/e2e/node/pod_resize.go:132:3: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
	WithArguments(patchedPodExceedMemory, expected).
	Should(gomega.Succeed(), "failed to verify Pod allocations for patchedPod")` instead (ginkgolinter)
		gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
		^
test/e2e/node/pod_resize.go:146:3: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
	WithArguments(patchedPodExceedCPU, expected).
	Should(gomega.Succeed(), "failed to verify Pod allocations for patchedPod")` instead (ginkgolinter)
		gomega.Eventually(ctx, e2epod.VerifyPodAllocations, timeouts.PodStartShort, timeouts.Poll).
		^
test/e2e/storage/testsuites/volume_modify.go:270:2: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	return c.StorageV1beta1().VolumeAttributesClasses().Delete(ctx, vac.Name, metav1.DeleteOptions{})
}, timeout, modifyPollInterval).Should(gomega.Succeed())` instead (ginkgolinter)
	gomega.Eventually(ctx, func() error {
	^
test/e2e_node/container_manager_test.go:110:6: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	return validateOOMScoreAdjSetting(pid, -999)
}, 5*time.Minute, 30*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
					gomega.Eventually(ctx, func() error {
					^
test/e2e_node/container_manager_test.go:119:5: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	return validateOOMScoreAdjSetting(kubeletPids[0], -999)
}, 5*time.Minute, 30*time.Second).Should(gomega.Succeed())` instead (ginkgolinter)
				gomega.Eventually(ctx, func() error {
				^
test/e2e_node/container_manager_test.go:167:6: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	pausePids, err = getPidsForProcess("pause", "")
	if err != nil {
		return fmt.Errorf("failed to get list of pause pids: %w", err)
	}
	for _, pid := range pausePids {
		if existingPausePIDSet.Has(pid) {

			continue
		}
		if err := validateOOMScoreAdjSetting(pid, -998); err != nil {
			return err
		}
	}
	return nil
}, 2*time.Minute, time.Second*4).Should(gomega.Succeed())` instead (ginkgolinter)
					gomega.Eventually(ctx, func() error {
					^
test/e2e_node/container_manager_test.go:185:6: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	shPids, err = getPidsForProcess("agnhost", "")
	if err != nil {
		return fmt.Errorf("failed to get list of serve hostname process pids: %w", err)
	}
	if len(shPids) != 1 {
		return fmt.Errorf("expected only one agnhost process; found %d", len(shPids))
	}
	return validateOOMScoreAdjSetting(shPids[0], 1000)
}, 2*time.Minute, time.Second*4).Should(gomega.Succeed())` instead (ginkgolinter)
					gomega.Eventually(ctx, func() error {
					^
test/e2e_node/container_manager_test.go:223:6: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	ngPids, err = getPidsForProcess("nginx", "")
	if err != nil {
		return fmt.Errorf("failed to get list of nginx process pids: %w", err)
	}
	for _, pid := range ngPids {
		if err := validateOOMScoreAdjSetting(pid, -998); err != nil {
			return err
		}
	}

	return nil
}, 2*time.Minute, time.Second*4).Should(gomega.Succeed())` instead (ginkgolinter)
					gomega.Eventually(ctx, func() error {
					^
test/e2e_node/container_manager_test.go:265:6: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	wsPids, err = getPidsForProcess("agnhost", "")
	if err != nil {
		return fmt.Errorf("failed to get list of test-webserver process pids: %w", err)
	}
	for _, pid := range wsPids {
		if err := validateOOMScoreAdjSettingIsInRange(pid, 2, 1000); err != nil {
			return err
		}
	}
	return nil
}, 2*time.Minute, time.Second*4).Should(gomega.Succeed())` instead (ginkgolinter)
					gomega.Eventually(ctx, func() error {
					^
test/e2e_node/device_plugin_test.go:679:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	err := checkMirrorPodDisappear(ctx, f.ClientSet, pod.Name, pod.Namespace)
	framework.Logf("pod %s/%s disappear check err=%v", pod.Namespace, pod.Name, err)
	return err
}, f.Timeouts.PodDelete, f.Timeouts.Poll).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func(ctx context.Context) error {
			^
test/e2e_node/dra_test.go:351:4: ginkgo-linter: use a function call in Consistently. This actually checks nothing, because Consistently receives the function returned value, instead of function itself, and this value is never changed. Consider using `gomega.Consistently(kubeletPlugin.CountCalls).WithArguments("/NodePrepareResources").WithTimeout(retryTestTimeout).Should(gomega.Equal(calls))` instead (ginkgolinter)
			gomega.Consistently(kubeletPlugin.CountCalls("/NodePrepareResources")).WithTimeout(retryTestTimeout).Should(gomega.Equal(calls))
			^
test/e2e_node/eviction_test.go:585:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	logFunc(ctx)
	if expectedNodeCondition == noPressure || hasNodeCondition(ctx, f, expectedNodeCondition) {
		return nil
	}
	return fmt.Errorf("NodeCondition: %s not encountered", expectedNodeCondition)
}, pressureTimeout, evictionPollInterval).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func(ctx context.Context) error {
			^
test/e2e_node/eviction_test.go:622:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	logFunc(ctx)
	logKubeletLatencyMetrics(ctx, kubeletmetrics.EvictionStatsAgeKey)
	if expectedNodeCondition != noPressure && hasNodeCondition(ctx, f, expectedNodeCondition) {
		return fmt.Errorf("Conditions haven't returned to normal, node still has %s", expectedNodeCondition)
	}
	return nil
}, pressureDisappearTimeout, evictionPollInterval).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func(ctx context.Context) error {
			^
test/e2e_node/eviction_test.go:665:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	if expectedNodeCondition != noPressure && hasNodeCondition(ctx, f, expectedNodeCondition) {
		return fmt.Errorf("Conditions haven't returned to normal, node still has %s", expectedNodeCondition)
	}
	return nil
}, pressureDisappearTimeout, evictionPollInterval).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func(ctx context.Context) error {
			^
test/e2e_node/eviction_test.go:678:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	if expectedNodeCondition != noPressure && hasNodeCondition(ctx, f, expectedNodeCondition) {
		return fmt.Errorf("Conditions haven't returned to normal, node still has %s", expectedNodeCondition)
	}
	return nil
}, pressureDisappearTimeout, evictionPollInterval).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func(ctx context.Context) error {
			^
test/e2e_node/eviction_test.go:975:2: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	summary, err := getNodeSummary(ctx)
	if err != nil {
		return err
	}
	if summary == nil || summary.Node.Fs == nil || summary.Node.Fs.InodesFree == nil || summary.Node.Fs.AvailableBytes == nil {
		return fmt.Errorf("some part of data is nil")
	}
	s = summary
	return nil
}, time.Minute, evictionPollInterval).Should(gomega.Succeed())` instead (ginkgolinter)
	gomega.Eventually(ctx, func() error {
	^
test/e2e_node/garbage_collector_test.go:180:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	for _, podSpec := range test.testPods {
		err := verifyPodRestartCount(ctx, f, podSpec.podName, podSpec.numContainers, podSpec.restartCount)
		if err != nil {
			return err
		}
	}
	return nil
}, setupDuration, runtimePollInterval).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func(ctx context.Context) error {
			^
test/e2e_node/garbage_collector_test.go:196:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	total := 0
	for _, pod := range test.testPods {
		containerNames, err := pod.getContainerNames()
		if err != nil {
			return err
		}
		total += len(containerNames)

		for i := 0; i < pod.numContainers; i++ {
			containerCount := 0
			for _, containerName := range containerNames {
				if containerName == pod.getContainerName(i) {
					containerCount++
				}
			}
			if containerCount > maxPerPodContainer+1 {
				return fmt.Errorf("expected number of copies of container: %s, to be <= maxPerPodContainer: %d; list of containers: %v",
					pod.getContainerName(i), maxPerPodContainer, containerNames)
			}
		}
	}

	if maxTotalContainers > 0 && totalContainers <= maxTotalContainers && total > maxTotalContainers {
		return fmt.Errorf("expected total number of containers: %v, to be <= maxTotalContainers: %v", total, maxTotalContainers)
	}
	return nil
}, garbageCollectDuration, runtimePollInterval).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e_node/garbage_collector_test.go:227:5: ginkgo-linter: wrong error assertion. Consider using `gomega.Consistently(ctx, func() error {
	for _, pod := range test.testPods {
		containerNames, err := pod.getContainerNames()
		if err != nil {
			return err
		}
		for i := 0; i < pod.numContainers; i++ {
			containerCount := 0
			for _, containerName := range containerNames {
				if containerName == pod.getContainerName(i) {
					containerCount++
				}
			}
			if pod.restartCount > 0 && containerCount < maxPerPodContainer+1 {
				return fmt.Errorf("expected pod %v to have extra copies of old containers", pod.podName)
			}
		}
	}
	return nil
}, garbageCollectDuration, runtimePollInterval).Should(gomega.Succeed())` instead (ginkgolinter)
				gomega.Consistently(ctx, func() error {
				^
test/e2e_node/garbage_collector_test.go:257:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	for _, pod := range test.testPods {
		containerNames, err := pod.getContainerNames()
		if err != nil {
			return err
		}
		if len(containerNames) > 0 {
			return fmt.Errorf("%v containers still remain", containerNames)
		}
	}
	return nil
}, garbageCollectDuration, runtimePollInterval).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e_node/hugepages_test.go:275:5: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	if err := configureHugePages(size, count, nil); err != nil {
		return err
	}
	return nil
}, 30*time.Second, framework.Poll).Should(gomega.Succeed())` instead (ginkgolinter)
				gomega.Eventually(ctx, func() error {
				^
test/e2e_node/hugepages_test.go:286:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	node, err := f.ClientSet.CoreV1().Nodes().Get(ctx, framework.TestContext.NodeName, metav1.GetOptions{})
	if err != nil {
		return err
	}

	for hugepagesResource, count := range hugepages {
		capacity, ok := node.Status.Capacity[v1.ResourceName(hugepagesResource)]
		if !ok {
			return fmt.Errorf("the node does not have the resource %s", hugepagesResource)
		}

		size, succeed := capacity.AsInt64()
		if !succeed {
			return fmt.Errorf("failed to convert quantity to int64")
		}

		expectedSize := count * resourceToSize[hugepagesResource] * 1024
		if size != int64(expectedSize) {
			return fmt.Errorf("the actual size %d is different from the expected one %d", size, expectedSize)
		}
	}
	return nil
}, time.Minute, framework.Poll).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func(ctx context.Context) error {
			^
test/e2e_node/hugepages_test.go:314:4: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func() error {
	for hugepagesResource := range hugepages {
		command := fmt.Sprintf("echo 0 > %s-%dkB/%s", hugepagesDirPrefix, resourceToSize[hugepagesResource], hugepagesCapacityFile)
		if err := exec.Command("/bin/sh", "-c", command).Run(); err != nil {
			return err
		}
	}
	return nil
}, 30*time.Second, framework.Poll).Should(gomega.Succeed())` instead (ginkgolinter)
			gomega.Eventually(ctx, func() error {
			^
test/e2e_node/memory_manager_test.go:286:3: ginkgo-linter: wrong error assertion. Consider using `gomega.Eventually(ctx, func(ctx context.Context) error {
	node, err := f.ClientSet.CoreV1().Nodes().Get(ctx, framework.TestContext.NodeName, metav1.GetOptions{})
	if err != nil {
		return err
	}

	capacity, ok := node.Status.Capacity[v1.ResourceName(hugepagesResourceName2Mi)]
	if !ok {
		return fmt.Errorf("the node does not have the resource %s", hugepagesResourceName2Mi)
	}

	size, succeed := capacity.AsInt64()
	if !succeed {
		return fmt.Errorf("failed to convert quantity to int64")
	}

	expectedSize := int64(hugepagesCount * hugepagesSize2M * 1024)
	if size != expectedSize {

v1.61.0

test/e2e/network/traffic_distribution.go:188:4: ginkgo-linter: use a function call in Eventually. This actually checks nothing, because Eventually receives the function returned value, instead of function itself, and this value is never changed. Consider using `gomega.Eventually(ctx, endpointSlicesForService).WithArguments(svc.GetName()).WithPolling(5 * time.Second).WithTimeout(e2eservice.ServiceEndpointsTimeout).Should(endpointSlicesHaveSameZoneHints)` instead (ginkgolinter)
			gomega.Eventually(ctx, endpointSlicesForService(svc.GetName())).WithPolling(5 * time.Second).WithTimeout(e2eservice.ServiceEndpointsTimeout).Should(endpointSlicesHaveSameZoneHints)
			^
test/e2e/network/traffic_distribution.go:238:5: ginkgo-linter: use a function call in Eventually. This actually checks nothing, because Eventually receives the function returned value, instead of function itself, and this value is never changed. Consider using `gomega.Eventually(ctx, requestsFromClient).WithArguments(clientPod).WithPolling(5 * time.Second).WithTimeout(e2eservice.KubeProxyLagTimeout).Should(requestsSucceedAndStayInSameZone)` instead (ginkgolinter)
				gomega.Eventually(ctx, requestsFromClient(clientPod)).WithPolling(5 * time.Second).WithTimeout(e2eservice.KubeProxyLagTimeout).Should(requestsSucceedAndStayInSameZone)
				^
test/e2e/network/traffic_distribution.go:276:4: ginkgo-linter: use a function call in Eventually. This actually checks nothing, because Eventually receives the function returned value, instead of function itself, and this value is never changed. Consider using `gomega.Eventually(ctx, requestsFromClient).WithArguments(clientPod).WithPolling(5 * time.Second).WithTimeout(e2eservice.KubeProxyLagTimeout).Should(requestsSucceedByReachingAnyServingPod)` instead (ginkgolinter)
			gomega.Eventually(ctx, requestsFromClient(clientPod)).WithPolling(5 * time.Second).WithTimeout(e2eservice.KubeProxyLagTimeout).Should(requestsSucceedByReachingAnyServingPod)
			^
test/e2e_node/dra_test.go:351:4: ginkgo-linter: use a function call in Consistently. This actually checks nothing, because Consistently receives the function returned value, instead of function itself, and this value is never changed. Consider using `gomega.Consistently(kubeletPlugin.CountCalls).WithArguments("/NodePrepareResources").WithTimeout(retryTestTimeout).Should(gomega.Equal(calls))` instead (ginkgolinter)
			gomega.Consistently(kubeletPlugin.CountCalls("/NodePrepareResources")).WithTimeout(retryTestTimeout).Should(gomega.Equal(calls))
			^
test/e2e_node/dra_test.go:362:4: ginkgo-linter: use a function call in Eventually. This actually checks nothing, because Eventually receives the function returned value, instead of function itself, and this value is never changed. Consider using `gomega.Eventually(kubeletPlugin1.GetGRPCCalls).WithTimeout(pluginRegistrationTimeout).Should(testdriver.BeRegistered)` instead (ginkgolinter)
			gomega.Eventually(kubeletPlugin1.GetGRPCCalls()).WithTimeout(pluginRegistrationTimeout).Should(testdriver.BeRegistered)
			^
test/e2e_node/dra_test.go:363:4: ginkgo-linter: use a function call in Eventually. This actually checks nothing, because Eventually receives the function returned value, instead of function itself, and this value is never changed. Consider using `gomega.Eventually(kubeletPlugin2.GetGRPCCalls).WithTimeout(pluginRegistrationTimeout).Should(testdriver.BeRegistered)` instead (ginkgolinter)
			gomega.Eventually(kubeletPlugin2.GetGRPCCalls()).WithTimeout(pluginRegistrationTimeout).Should(testdriver.BeRegistered)
			^

Command	Mean [s]	Min [s]	Max [s]	Relative
local	9.923 ± 0.106	9.709	10.061	1.00 ± 0.01
v1.61.0	9.879 ± 0.090	9.730	10.014	1.00

go-acme/lego

Command	Mean [s]	Min [s]	Max [s]	Relative
local	1.967 ± 0.018	1.943	2.005	1.01 ± 0.01
v1.61.0	1.940 ± 0.018	1.912	1.962	1.00

pact-foundation/pact-go

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
local	452.6 ± 4.3	448.3	460.3	1.07 ± 0.03
v1.61.0	423.4 ± 11.9	411.7	452.6	1.00

rclone/rclone

Command	Mean [s]	Min [s]	Max [s]	Relative
local	2.313 ± 0.079	2.224	2.510	1.01 ± 0.04
v1.61.0	2.289 ± 0.049	2.192	2.367	1.00

hashicorp/terraform

Command	Mean [s]	Min [s]	Max [s]	Relative
local	3.225 ± 0.049	3.143	3.310	1.01 ± 0.03
v1.61.0	3.201 ± 0.072	3.139	3.387	1.00

traefik/traefik

Command	Mean [s]	Min [s]	Max [s]	Relative
local	3.195 ± 0.087	3.113	3.397	1.03 ± 0.03
v1.61.0	3.100 ± 0.047	3.043	3.184	1.00

You can find the workflow here:
https://github.com/ldez/golangci-lint-bench/actions/runs/11576448021