diff --git a/test/e2e/exists_test.go b/test/e2e/exists_test.go
index 269a5f8551..2728e364cf 100644
--- a/test/e2e/exists_test.go
+++ b/test/e2e/exists_test.go
@@ -1,6 +1,7 @@
 package integration
 
 import (
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
@@ -11,12 +12,12 @@ var _ = Describe("Podman image|container exists", func() {
 	It("podman image exists in local storage by fq name", func() {
 		session := podmanTest.Podman([]string{"image", "exists", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 	It("podman image exists in local storage by short name", func() {
 		session := podmanTest.Podman([]string{"image", "exists", "alpine"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 	It("podman image does not exist in local storage", func() {
 		session := podmanTest.Podman([]string{"image", "exists", "alpine9999"})
@@ -26,31 +27,31 @@ var _ = Describe("Podman image|container exists", func() {
 	It("podman container exists in local storage by name", func() {
 		setup := podmanTest.RunTopContainer("foobar")
 		setup.WaitWithDefaultTimeout()
-		Expect(setup).Should(Exit(0))
+		Expect(setup).Should(ExitCleanly())
 
 		session := podmanTest.Podman([]string{"container", "exists", "foobar"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 	It("podman container exists in local storage by container ID", func() {
 		setup := podmanTest.RunTopContainer("")
 		setup.WaitWithDefaultTimeout()
-		Expect(setup).Should(Exit(0))
+		Expect(setup).Should(ExitCleanly())
 		cid := setup.OutputToString()
 
 		session := podmanTest.Podman([]string{"container", "exists", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 	It("podman container exists in local storage by short container ID", func() {
 		setup := podmanTest.RunTopContainer("")
 		setup.WaitWithDefaultTimeout()
-		Expect(setup).Should(Exit(0))
+		Expect(setup).Should(ExitCleanly())
 		cid := setup.OutputToString()[0:12]
 
 		session := podmanTest.Podman([]string{"container", "exists", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 	It("podman container does not exist in local storage", func() {
 		session := podmanTest.Podman([]string{"container", "exists", "foobar"})
@@ -61,29 +62,29 @@ var _ = Describe("Podman image|container exists", func() {
 	It("podman pod exists in local storage by name", func() {
 		setup, _, _ := podmanTest.CreatePod(map[string][]string{"--name": {"foobar"}})
 		setup.WaitWithDefaultTimeout()
-		Expect(setup).Should(Exit(0))
+		Expect(setup).Should(ExitCleanly())
 
 		session := podmanTest.Podman([]string{"pod", "exists", "foobar"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 	It("podman pod exists in local storage by container ID", func() {
 		setup, _, podID := podmanTest.CreatePod(nil)
 		setup.WaitWithDefaultTimeout()
-		Expect(setup).Should(Exit(0))
+		Expect(setup).Should(ExitCleanly())
 
 		session := podmanTest.Podman([]string{"pod", "exists", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 	It("podman pod exists in local storage by short container ID", func() {
 		setup, _, podID := podmanTest.CreatePod(nil)
 		setup.WaitWithDefaultTimeout()
-		Expect(setup).Should(Exit(0))
+		Expect(setup).Should(ExitCleanly())
 
 		session := podmanTest.Podman([]string{"pod", "exists", podID[0:12]})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 	It("podman pod does not exist in local storage", func() {
 		// The exit code for non-existing pod is incorrect (125 vs 1)
diff --git a/test/e2e/network_connect_disconnect_test.go b/test/e2e/network_connect_disconnect_test.go
index 3b93754dfa..2f9a702511 100644
--- a/test/e2e/network_connect_disconnect_test.go
+++ b/test/e2e/network_connect_disconnect_test.go
@@ -21,7 +21,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		netName := "aliasTest" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		dis := podmanTest.Podman([]string{"network", "disconnect", netName, "foobar"})
@@ -33,12 +33,12 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		netName := "slirp" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		session = podmanTest.Podman([]string{"create", "--name", "test", "--network", "slirp4netns", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		con := podmanTest.Podman([]string{"network", "disconnect", netName, "test"})
@@ -52,35 +52,35 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		netName := "aliasTest" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		gw := podmanTest.Podman([]string{"network", "inspect", netName, "--format", "{{(index .Subnets 0).Gateway}}"})
 		gw.WaitWithDefaultTimeout()
-		Expect(gw).Should(Exit(0))
+		Expect(gw).Should(ExitCleanly())
 		ns := gw.OutputToString()
 
 		ctr := podmanTest.Podman([]string{"run", "-dt", "--name", "test", "--network", netName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		exec := podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth0"})
 		exec.WaitWithDefaultTimeout()
-		Expect(exec).Should(Exit(0))
+		Expect(exec).Should(ExitCleanly())
 
 		exec2 := podmanTest.Podman([]string{"exec", "test", "cat", "/etc/resolv.conf"})
 		exec2.WaitWithDefaultTimeout()
-		Expect(exec2).Should(Exit(0))
+		Expect(exec2).Should(ExitCleanly())
 		Expect(exec2.OutputToString()).To(ContainSubstring(ns))
 
 		dis := podmanTest.Podman([]string{"network", "disconnect", netName, "test"})
 		dis.WaitWithDefaultTimeout()
-		Expect(dis).Should(Exit(0))
+		Expect(dis).Should(ExitCleanly())
 		Expect(dis.ErrorToString()).Should(Equal(""))
 
 		inspect := podmanTest.Podman([]string{"container", "inspect", "test", "--format", "{{len .NetworkSettings.Networks}}"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal("0"))
 
 		exec = podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth0"})
@@ -89,13 +89,13 @@ var _ = Describe("Podman network connect and disconnect", func() {
 
 		exec3 := podmanTest.Podman([]string{"exec", "test", "cat", "/etc/resolv.conf"})
 		exec3.WaitWithDefaultTimeout()
-		Expect(exec3).Should(Exit(0))
+		Expect(exec3).Should(ExitCleanly())
 		Expect(exec3.OutputToString()).ToNot(ContainSubstring(ns))
 
 		// make sure stats still works https://github.com/containers/podman/issues/13824
 		stats := podmanTest.Podman([]string{"stats", "test", "--no-stream"})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 	})
 
 	It("bad network name in connect should result in error", func() {
@@ -108,7 +108,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		netName := "aliasTest" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		dis := podmanTest.Podman([]string{"network", "connect", netName, "foobar"})
@@ -120,12 +120,12 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		netName := "slirp" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		session = podmanTest.Podman([]string{"create", "--name", "test", "--network", "slirp4netns", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		con := podmanTest.Podman([]string{"network", "connect", netName, "test"})
@@ -138,27 +138,27 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		netName := "aliasTest" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		ctr := podmanTest.Podman([]string{"create", "--name", "test", "--network", netName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 		cid := ctr.OutputToString()
 
 		// network alias container short id is always added and shown in inspect
 		inspect := podmanTest.Podman([]string{"container", "inspect", "test", "--format", "{{(index .NetworkSettings.Networks \"" + netName + "\").Aliases}}"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal("[" + cid[0:12] + "]"))
 
 		con := podmanTest.Podman([]string{"network", "connect", netName, "test"})
 		con.WaitWithDefaultTimeout()
-		Expect(con).Should(Exit(0))
+		Expect(con).Should(ExitCleanly())
 
 		init := podmanTest.Podman([]string{"init", "test"})
 		init.WaitWithDefaultTimeout()
-		Expect(init).Should(Exit(0))
+		Expect(init).Should(ExitCleanly())
 
 		con2 := podmanTest.Podman([]string{"network", "connect", netName, "test"})
 		con2.WaitWithDefaultTimeout()
@@ -170,73 +170,73 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		netName := "aliasTest" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		ctr := podmanTest.Podman([]string{"run", "-dt", "--name", "test", "--network", netName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 		cid := ctr.OutputToString()
 
 		exec := podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth0"})
 		exec.WaitWithDefaultTimeout()
-		Expect(exec).Should(Exit(0))
+		Expect(exec).Should(ExitCleanly())
 
 		// Create a second network
 		newNetName := "aliasTest" + stringid.GenerateRandomID()
 		session = podmanTest.Podman([]string{"network", "create", newNetName, "--subnet", "10.11.100.0/24"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(newNetName)
 
 		gw := podmanTest.Podman([]string{"network", "inspect", newNetName, "--format", "{{(index .Subnets 0).Gateway}}"})
 		gw.WaitWithDefaultTimeout()
-		Expect(gw).Should(Exit(0))
+		Expect(gw).Should(ExitCleanly())
 		ns := gw.OutputToString()
 
 		exec2 := podmanTest.Podman([]string{"exec", "test", "cat", "/etc/resolv.conf"})
 		exec2.WaitWithDefaultTimeout()
-		Expect(exec2).Should(Exit(0))
+		Expect(exec2).Should(ExitCleanly())
 		Expect(exec2.OutputToString()).ToNot(ContainSubstring(ns))
 
 		ip := "10.11.100.99"
 		mac := "44:11:44:11:44:11"
 		connect := podmanTest.Podman([]string{"network", "connect", "--ip", ip, "--mac-address", mac, newNetName, "test"})
 		connect.WaitWithDefaultTimeout()
-		Expect(connect).Should(Exit(0))
+		Expect(connect).Should(ExitCleanly())
 		Expect(connect.ErrorToString()).Should(Equal(""))
 
 		inspect := podmanTest.Podman([]string{"container", "inspect", "test", "--format", "{{len .NetworkSettings.Networks}}"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal("2"))
 
 		// network alias container short id is always added and shown in inspect
 		inspect = podmanTest.Podman([]string{"container", "inspect", "test", "--format", "{{(index .NetworkSettings.Networks \"" + newNetName + "\").Aliases}}"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal("[" + cid[0:12] + "]"))
 
 		exec = podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth1"})
 		exec.WaitWithDefaultTimeout()
-		Expect(exec).Should(Exit(0))
+		Expect(exec).Should(ExitCleanly())
 		Expect(exec.OutputToString()).Should(ContainSubstring(ip))
 		Expect(exec.OutputToString()).Should(ContainSubstring(mac))
 
 		exec3 := podmanTest.Podman([]string{"exec", "test", "cat", "/etc/resolv.conf"})
 		exec3.WaitWithDefaultTimeout()
-		Expect(exec3).Should(Exit(0))
+		Expect(exec3).Should(ExitCleanly())
 		Expect(exec3.OutputToString()).To(ContainSubstring(ns))
 
 		// make sure stats works https://github.com/containers/podman/issues/13824
 		stats := podmanTest.Podman([]string{"stats", "test", "--no-stream"})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 
 		// make sure no logrus errors are shown https://github.com/containers/podman/issues/9602
 		rm := podmanTest.Podman([]string{"rm", "--time=0", "-f", "test"})
 		rm.WaitWithDefaultTimeout()
-		Expect(rm).Should(Exit(0))
+		Expect(rm).Should(ExitCleanly())
 		Expect(rm.ErrorToString()).To(Equal(""))
 	})
 
@@ -244,117 +244,117 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		netName1 := "connect1" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName1)
 
 		netName2 := "connect2" + stringid.GenerateRandomID()
 		session = podmanTest.Podman([]string{"network", "create", netName2})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName2)
 
 		ctr := podmanTest.Podman([]string{"create", "--name", "test", "--network", netName1, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		dis := podmanTest.Podman([]string{"network", "connect", netName2, "test"})
 		dis.WaitWithDefaultTimeout()
-		Expect(dis).Should(Exit(0))
+		Expect(dis).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"container", "inspect", "test", "--format", "{{len .NetworkSettings.Networks}}"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal("2"))
 
 		start := podmanTest.Podman([]string{"start", "test"})
 		start.WaitWithDefaultTimeout()
-		Expect(start).Should(Exit(0))
+		Expect(start).Should(ExitCleanly())
 
 		exec := podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth0"})
 		exec.WaitWithDefaultTimeout()
-		Expect(exec).Should(Exit(0))
+		Expect(exec).Should(ExitCleanly())
 
 		exec = podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth1"})
 		exec.WaitWithDefaultTimeout()
-		Expect(exec).Should(Exit(0))
+		Expect(exec).Should(ExitCleanly())
 	})
 
 	It("podman network connect and run with network ID", func() {
 		netName := "ID" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		session = podmanTest.Podman([]string{"network", "ls", "--format", "{{.ID}}", "--filter", "name=" + netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		netID := session.OutputToString()
 
 		ctr := podmanTest.Podman([]string{"run", "-dt", "--name", "test", "--network", netID, "--network-alias", "somealias", ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		exec := podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth0"})
 		exec.WaitWithDefaultTimeout()
-		Expect(exec).Should(Exit(0))
+		Expect(exec).Should(ExitCleanly())
 
 		// Create a second network
 		newNetName := "ID2" + stringid.GenerateRandomID()
 		session = podmanTest.Podman([]string{"network", "create", newNetName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(newNetName)
 
 		session = podmanTest.Podman([]string{"network", "ls", "--format", "{{.ID}}", "--filter", "name=" + newNetName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		newNetID := session.OutputToString()
 
 		connect := podmanTest.Podman([]string{"network", "connect", "--alias", "secondalias", newNetID, "test"})
 		connect.WaitWithDefaultTimeout()
-		Expect(connect).Should(Exit(0))
+		Expect(connect).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"container", "inspect", "test", "--format", "{{.NetworkSettings.Networks}}"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(ContainSubstring(netName))
 		Expect(inspect.OutputToString()).To(ContainSubstring(newNetName))
 
 		exec = podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth1"})
 		exec.WaitWithDefaultTimeout()
-		Expect(exec).Should(Exit(0))
+		Expect(exec).Should(ExitCleanly())
 	})
 
 	It("podman network disconnect when not running", func() {
 		netName1 := "aliasTest" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName1)
 
 		netName2 := "aliasTest" + stringid.GenerateRandomID()
 		session2 := podmanTest.Podman([]string{"network", "create", netName2})
 		session2.WaitWithDefaultTimeout()
-		Expect(session2).Should(Exit(0))
+		Expect(session2).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName2)
 
 		ctr := podmanTest.Podman([]string{"create", "--name", "test", "--network", netName1 + "," + netName2, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		dis := podmanTest.Podman([]string{"network", "disconnect", netName1, "test"})
 		dis.WaitWithDefaultTimeout()
-		Expect(dis).Should(Exit(0))
+		Expect(dis).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"container", "inspect", "test", "--format", "{{len .NetworkSettings.Networks}}"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal("1"))
 
 		start := podmanTest.Podman([]string{"start", "test"})
 		start.WaitWithDefaultTimeout()
-		Expect(start).Should(Exit(0))
+		Expect(start).Should(ExitCleanly())
 
 		exec := podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth0"})
 		exec.WaitWithDefaultTimeout()
@@ -375,29 +375,29 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		netName := "aliasTest" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(netName)
 
 		session = podmanTest.Podman([]string{"network", "ls", "--format", "{{.ID}}", "--filter", "name=" + netName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		netID := session.OutputToString()
 
 		ctr := podmanTest.Podman([]string{"run", "-dt", "--name", "test", "--network", netID, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		exec := podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth0"})
 		exec.WaitWithDefaultTimeout()
-		Expect(exec).Should(Exit(0))
+		Expect(exec).Should(ExitCleanly())
 
 		dis := podmanTest.Podman([]string{"network", "disconnect", netID, "test"})
 		dis.WaitWithDefaultTimeout()
-		Expect(dis).Should(Exit(0))
+		Expect(dis).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"container", "inspect", "test", "--format", "{{len .NetworkSettings.Networks}}"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal("0"))
 
 		exec = podmanTest.Podman([]string{"exec", "test", "ip", "addr", "show", "eth0"})
diff --git a/test/e2e/pause_test.go b/test/e2e/pause_test.go
index c4dc227f7e..bfe4c3c155 100644
--- a/test/e2e/pause_test.go
+++ b/test/e2e/pause_test.go
@@ -49,7 +49,7 @@ var _ = Describe("Podman pause", func() {
 	It("podman pause a created container by id", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"pause", cid})
@@ -62,18 +62,18 @@ var _ = Describe("Podman pause", func() {
 		// check we can read stats for a paused container
 		result = podmanTest.Podman([]string{"stats", "--no-stream", cid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman pause a running container by id", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 		result := podmanTest.Podman([]string{"pause", cid})
 		result.WaitWithDefaultTimeout()
 
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 		Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState))
 
@@ -84,13 +84,13 @@ var _ = Describe("Podman pause", func() {
 	It("podman container pause a running container by id", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"container", "pause", cid})
 		result.WaitWithDefaultTimeout()
 
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 		Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState))
 
@@ -101,7 +101,7 @@ var _ = Describe("Podman pause", func() {
 	It("podman unpause a running container by id", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"unpause", cid})
@@ -115,13 +115,13 @@ var _ = Describe("Podman pause", func() {
 	It("podman remove a paused container by id without force", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"pause", cid})
 		result.WaitWithDefaultTimeout()
 
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 		Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState))
 
@@ -136,39 +136,39 @@ var _ = Describe("Podman pause", func() {
 		// otherwise it fails with container state improper
 		session = podmanTest.Podman([]string{"unpause", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman remove a paused container by id with force", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"pause", cid})
 		result.WaitWithDefaultTimeout()
 
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 		Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState))
 
 		result = podmanTest.Podman([]string{"rm", "-t", "0", "--force", cid})
 		result.WaitWithDefaultTimeout()
 
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
 	It("podman stop a paused container by id", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"pause", cid})
 		result.WaitWithDefaultTimeout()
 
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 		Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState))
 
@@ -181,7 +181,7 @@ var _ = Describe("Podman pause", func() {
 
 		result = podmanTest.Podman([]string{"unpause", cid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 
 		result = podmanTest.Podman([]string{"rm", cid})
@@ -191,7 +191,7 @@ var _ = Describe("Podman pause", func() {
 
 		result = podmanTest.Podman([]string{"rm", "-t", "0", "-f", cid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 
 	})
@@ -199,12 +199,12 @@ var _ = Describe("Podman pause", func() {
 	It("podman pause a running container by name", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pause", "test1"})
 		result.WaitWithDefaultTimeout()
 
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 		Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(Equal(pausedState))
 
@@ -215,23 +215,23 @@ var _ = Describe("Podman pause", func() {
 	It("podman pause a running container by id and another by name", func() {
 		session1 := podmanTest.RunTopContainer("test1")
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 
 		session2 := podmanTest.RunTopContainer("")
 		session2.WaitWithDefaultTimeout()
-		Expect(session2).Should(Exit(0))
+		Expect(session2).Should(ExitCleanly())
 		cid2 := session2.OutputToString()
 
 		result := podmanTest.Podman([]string{"pause", cid2})
 		result.WaitWithDefaultTimeout()
 
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 
 		result = podmanTest.Podman([]string{"pause", "test1"})
 		result.WaitWithDefaultTimeout()
 
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 
 		result = podmanTest.Podman([]string{"unpause", "test1"})
@@ -243,7 +243,7 @@ var _ = Describe("Podman pause", func() {
 	It("Pause all containers (no containers exist)", func() {
 		result := podmanTest.Podman([]string{"pause", "--all"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 
 	})
@@ -251,7 +251,7 @@ var _ = Describe("Podman pause", func() {
 	It("Unpause all containers (no paused containers exist)", func() {
 		result := podmanTest.Podman([]string{"unpause", "--all"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
@@ -260,26 +260,26 @@ var _ = Describe("Podman pause", func() {
 			name := fmt.Sprintf("test%d", i)
 			run := podmanTest.Podman([]string{"run", "-dt", "--name", name, NGINX_IMAGE})
 			run.WaitWithDefaultTimeout()
-			Expect(run).Should(Exit(0))
+			Expect(run).Should(ExitCleanly())
 
 		}
 		running := podmanTest.Podman([]string{"ps", "-q"})
 		running.WaitWithDefaultTimeout()
-		Expect(running).Should(Exit(0))
+		Expect(running).Should(ExitCleanly())
 		Expect(running.OutputToStringArray()).To(HaveLen(3))
 
 		pause := podmanTest.Podman([]string{"pause", "--all"})
 		pause.WaitWithDefaultTimeout()
-		Expect(pause).Should(Exit(0))
+		Expect(pause).Should(ExitCleanly())
 
 		running = podmanTest.Podman([]string{"ps", "-q"})
 		running.WaitWithDefaultTimeout()
-		Expect(running).Should(Exit(0))
+		Expect(running).Should(ExitCleanly())
 		Expect(running.OutputToStringArray()).To(BeEmpty())
 
 		unpause := podmanTest.Podman([]string{"unpause", "--all"})
 		unpause.WaitWithDefaultTimeout()
-		Expect(unpause).Should(Exit(0))
+		Expect(unpause).Should(ExitCleanly())
 	})
 
 	It("Unpause a bunch of running containers", func() {
@@ -287,20 +287,20 @@ var _ = Describe("Podman pause", func() {
 			name := fmt.Sprintf("test%d", i)
 			run := podmanTest.Podman([]string{"run", "-dt", "--name", name, NGINX_IMAGE})
 			run.WaitWithDefaultTimeout()
-			Expect(run).Should(Exit(0))
+			Expect(run).Should(ExitCleanly())
 
 		}
 		pause := podmanTest.Podman([]string{"pause", "--all"})
 		pause.WaitWithDefaultTimeout()
-		Expect(pause).Should(Exit(0))
+		Expect(pause).Should(ExitCleanly())
 
 		unpause := podmanTest.Podman([]string{"unpause", "--all"})
 		unpause.WaitWithDefaultTimeout()
-		Expect(unpause).Should(Exit(0))
+		Expect(unpause).Should(ExitCleanly())
 
 		running := podmanTest.Podman([]string{"ps", "-q"})
 		running.WaitWithDefaultTimeout()
-		Expect(running).Should(Exit(0))
+		Expect(running).Should(ExitCleanly())
 		Expect(running.OutputToStringArray()).To(HaveLen(3))
 	})
 
@@ -308,11 +308,11 @@ var _ = Describe("Podman pause", func() {
 		SkipIfRemote("--latest flag n/a")
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		result := podmanTest.Podman([]string{"pause", "-l"})
 		result.WaitWithDefaultTimeout()
 
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 		Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState))
 
@@ -326,22 +326,22 @@ var _ = Describe("Podman pause", func() {
 
 		session := podmanTest.Podman([]string{"create", "--cidfile", tmpFile, ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToStringArray()[0]
 
 		session = podmanTest.Podman([]string{"start", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pause", "--cidfile", tmpFile})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		output := result.OutputToString()
 		Expect(output).To(ContainSubstring(cid))
 
 		result = podmanTest.Podman([]string{"unpause", "--cidfile", tmpFile})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		output = result.OutputToString()
 		Expect(output).To(ContainSubstring(cid))
 	})
@@ -355,19 +355,19 @@ var _ = Describe("Podman pause", func() {
 
 		session := podmanTest.Podman([]string{"run", "--cidfile", tmpFile1, "-d", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid1 := session.OutputToStringArray()[0]
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
 
 		session = podmanTest.Podman([]string{"run", "--cidfile", tmpFile2, "-d", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid2 := session.OutputToStringArray()[0]
 		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
 
 		result := podmanTest.Podman([]string{"pause", "--cidfile", tmpFile1, "--cidfile", tmpFile2})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		output := result.OutputToString()
 		Expect(output).To(ContainSubstring(cid1))
 		Expect(output).To(ContainSubstring(cid2))
@@ -375,7 +375,7 @@ var _ = Describe("Podman pause", func() {
 
 		result = podmanTest.Podman([]string{"unpause", "--cidfile", tmpFile1, "--cidfile", tmpFile2})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		output = result.OutputToString()
 		Expect(output).To(ContainSubstring(cid1))
 		Expect(output).To(ContainSubstring(cid2))
@@ -425,17 +425,17 @@ var _ = Describe("Podman pause", func() {
 	It("podman pause --filter", func() {
 		session1 := podmanTest.RunTopContainer("")
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid1 := session1.OutputToString()
 
 		session1 = podmanTest.RunTopContainer("")
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid2 := session1.OutputToString()
 
 		session1 = podmanTest.RunTopContainerWithArgs("", []string{"--label", "test=with,comma"})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid3 := session1.OutputToString()
 		shortCid3 := cid3[0:5]
 
@@ -449,42 +449,42 @@ var _ = Describe("Podman pause", func() {
 
 		session1 = podmanTest.Podman([]string{"pause", "-a", "--filter", "label=test=with,comma"})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
 
 		session1 = podmanTest.Podman([]string{"unpause", "-a", "--filter", "label=test=with,comma"})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
 
 		session1 = podmanTest.Podman([]string{"pause", "-a", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEmpty())
 
 		session1 = podmanTest.Podman([]string{"pause", "-a", "--filter", fmt.Sprintf("id=%s", shortCid3)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
 
 		session1 = podmanTest.Podman([]string{"unpause", "-a", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEmpty())
 
 		session1 = podmanTest.Podman([]string{"unpause", "-a", "--filter", fmt.Sprintf("id=%s", shortCid3)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
 
 		session1 = podmanTest.Podman([]string{"pause", "-f", fmt.Sprintf("id=%s", cid2)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid2))
 
 		session1 = podmanTest.Podman([]string{"unpause", "-f", fmt.Sprintf("id=%s", cid2)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid2))
 	})
 })
diff --git a/test/e2e/pod_clone_test.go b/test/e2e/pod_clone_test.go
index 90d47a3870..aae89a3087 100644
--- a/test/e2e/pod_clone_test.go
+++ b/test/e2e/pod_clone_test.go
@@ -3,9 +3,9 @@ package integration
 import (
 	"os"
 
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("Podman pod clone", func() {
@@ -19,29 +19,29 @@ var _ = Describe("Podman pod clone", func() {
 	It("podman pod clone basic test", func() {
 		create := podmanTest.Podman([]string{"pod", "create", "--name", "1"})
 		create.WaitWithDefaultTimeout()
-		Expect(create).To(Exit(0))
+		Expect(create).To(ExitCleanly())
 
 		run := podmanTest.Podman([]string{"run", "--pod", "1", "-dt", ALPINE})
 		run.WaitWithDefaultTimeout()
-		Expect(run).To(Exit(0))
+		Expect(run).To(ExitCleanly())
 
 		clone := podmanTest.Podman([]string{"pod", "clone", create.OutputToString()})
 		clone.WaitWithDefaultTimeout()
-		Expect(clone).To(Exit(0))
+		Expect(clone).To(ExitCleanly())
 
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", clone.OutputToString()})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).To(Exit(0))
+		Expect(podInspect).To(ExitCleanly())
 		data := podInspect.InspectPodToJSON()
 		Expect(data.Name).To(ContainSubstring("-clone"))
 
 		podStart := podmanTest.Podman([]string{"pod", "start", clone.OutputToString()})
 		podStart.WaitWithDefaultTimeout()
-		Expect(podStart).To(Exit(0))
+		Expect(podStart).To(ExitCleanly())
 
 		podInspect = podmanTest.Podman([]string{"pod", "inspect", clone.OutputToString()})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).To(Exit(0))
+		Expect(podInspect).To(ExitCleanly())
 		data = podInspect.InspectPodToJSON()
 		Expect(data.Containers[1].State).To(ContainSubstring("running")) // make sure non infra ctr is running
 	})
@@ -49,35 +49,35 @@ var _ = Describe("Podman pod clone", func() {
 	It("podman pod clone renaming test", func() {
 		create := podmanTest.Podman([]string{"pod", "create", "--name", "1"})
 		create.WaitWithDefaultTimeout()
-		Expect(create).To(Exit(0))
+		Expect(create).To(ExitCleanly())
 
 		clone := podmanTest.Podman([]string{"pod", "clone", "--name", "2", create.OutputToString()})
 		clone.WaitWithDefaultTimeout()
-		Expect(clone).To(Exit(0))
+		Expect(clone).To(ExitCleanly())
 
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", clone.OutputToString()})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).To(Exit(0))
+		Expect(podInspect).To(ExitCleanly())
 		data := podInspect.InspectPodToJSON()
 		Expect(data.Name).To(ContainSubstring("2"))
 
 		podStart := podmanTest.Podman([]string{"pod", "start", clone.OutputToString()})
 		podStart.WaitWithDefaultTimeout()
-		Expect(podStart).To(Exit(0))
+		Expect(podStart).To(ExitCleanly())
 	})
 
 	It("podman pod clone start test", func() {
 		create := podmanTest.Podman([]string{"pod", "create", "--name", "1"})
 		create.WaitWithDefaultTimeout()
-		Expect(create).To(Exit(0))
+		Expect(create).To(ExitCleanly())
 
 		clone := podmanTest.Podman([]string{"pod", "clone", "--start", create.OutputToString()})
 		clone.WaitWithDefaultTimeout()
-		Expect(clone).To(Exit(0))
+		Expect(clone).To(ExitCleanly())
 
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", clone.OutputToString()})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).To(Exit(0))
+		Expect(podInspect).To(ExitCleanly())
 		data := podInspect.InspectPodToJSON()
 		Expect(data.State).To(ContainSubstring("Running"))
 
@@ -86,15 +86,15 @@ var _ = Describe("Podman pod clone", func() {
 	It("podman pod clone destroy test", func() {
 		create := podmanTest.Podman([]string{"pod", "create", "--name", "1"})
 		create.WaitWithDefaultTimeout()
-		Expect(create).To(Exit(0))
+		Expect(create).To(ExitCleanly())
 
 		clone := podmanTest.Podman([]string{"pod", "clone", "--destroy", create.OutputToString()})
 		clone.WaitWithDefaultTimeout()
-		Expect(clone).To(Exit(0))
+		Expect(clone).To(ExitCleanly())
 
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", create.OutputToString()})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).ToNot(Exit(0))
+		Expect(podInspect).ToNot(ExitCleanly())
 	})
 
 	It("podman pod clone infra option test", func() {
@@ -103,20 +103,20 @@ var _ = Describe("Podman pod clone", func() {
 		volName := "testVol"
 		volCreate := podmanTest.Podman([]string{"volume", "create", volName})
 		volCreate.WaitWithDefaultTimeout()
-		Expect(volCreate).Should(Exit(0))
+		Expect(volCreate).Should(ExitCleanly())
 
 		podName := "testPod"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podClone := podmanTest.Podman([]string{"pod", "clone", "--volume", volName + ":/tmp1", podName})
 		podClone.WaitWithDefaultTimeout()
-		Expect(podClone).Should(Exit(0))
+		Expect(podClone).Should(ExitCleanly())
 
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", "testPod-clone"})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).Should(Exit(0))
+		Expect(podInspect).Should(ExitCleanly())
 		data := podInspect.InspectPodToJSON()
 		Expect(data.Mounts[0]).To(HaveField("Name", volName))
 	})
@@ -124,15 +124,15 @@ var _ = Describe("Podman pod clone", func() {
 	It("podman pod clone --shm-size", func() {
 		podCreate := podmanTest.Podman([]string{"pod", "create"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podClone := podmanTest.Podman([]string{"pod", "clone", "--shm-size", "10mb", podCreate.OutputToString()})
 		podClone.WaitWithDefaultTimeout()
-		Expect(podClone).Should(Exit(0))
+		Expect(podClone).Should(ExitCleanly())
 
 		run := podmanTest.Podman([]string{"run", "--pod", podClone.OutputToString(), ALPINE, "mount"})
 		run.WaitWithDefaultTimeout()
-		Expect(run).Should(Exit(0))
+		Expect(run).Should(ExitCleanly())
 		t, strings := run.GrepString("shm on /dev/shm type tmpfs")
 		Expect(t).To(BeTrue(), "found /dev/shm")
 		Expect(strings[0]).Should(ContainSubstring("size=10240k"))
@@ -143,15 +143,15 @@ var _ = Describe("Podman pod clone", func() {
 
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "clone", "--uts", "host", session.OutputToString()})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", session.OutputToString(), ALPINE, "printenv", "HOSTNAME"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(hostname))
 
 		podName := "utsPod"
@@ -159,16 +159,16 @@ var _ = Describe("Podman pod clone", func() {
 
 		session = podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// just share uts with a custom path
 		podCreate := podmanTest.Podman([]string{"pod", "clone", "--uts", ns, "--name", podName, session.OutputToString()})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", podName})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).Should(Exit(0))
+		Expect(podInspect).Should(ExitCleanly())
 		podJSON := podInspect.InspectPodToJSON()
 		Expect(podJSON.InfraConfig).To(HaveField("UtsNS", ns))
 	})
diff --git a/test/e2e/pod_create_test.go b/test/e2e/pod_create_test.go
index abe48615b7..a06bb6ae1c 100644
--- a/test/e2e/pod_create_test.go
+++ b/test/e2e/pod_create_test.go
@@ -60,12 +60,12 @@ var _ = Describe("Podman pod create", func() {
 		name := "test"
 		session := podmanTest.Podman([]string{"pod", "create", "--name", name})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		pod := session.OutputToString()
 
 		webserver := podmanTest.Podman([]string{"run", "--pod", pod, "-dt", NGINX_IMAGE})
 		webserver.WaitWithDefaultTimeout()
-		Expect(webserver).Should(Exit(0))
+		Expect(webserver).Should(ExitCleanly())
 
 		check := SystemExec("nc", []string{"-z", "localhost", "80"})
 		Expect(check).Should(Exit(1))
@@ -76,12 +76,12 @@ var _ = Describe("Podman pod create", func() {
 		port := GetPort()
 		session := podmanTest.Podman([]string{"pod", "create", "--name", name, "-p", fmt.Sprintf("%d:80", port)})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		pod := session.OutputToString()
 
 		webserver := podmanTest.Podman([]string{"run", "--pod", pod, "-dt", NGINX_IMAGE})
 		webserver.WaitWithDefaultTimeout()
-		Expect(webserver).Should(Exit(0))
+		Expect(webserver).Should(ExitCleanly())
 		Expect(ncz(port)).To(BeTrue(), "port %d is up", port)
 	})
 
@@ -91,11 +91,11 @@ var _ = Describe("Podman pod create", func() {
 		port := GetPort()
 		session := podmanTest.Podman([]string{"pod", "create", "--name", name, "--pod-id-file", file, "-p", fmt.Sprintf("%d:80", port)})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		webserver := podmanTest.Podman([]string{"run", "--pod-id-file", file, "-dt", NGINX_IMAGE})
 		webserver.WaitWithDefaultTimeout()
-		Expect(webserver).Should(Exit(0))
+		Expect(webserver).Should(ExitCleanly())
 		Expect(ncz(port)).To(BeTrue(), "port %d is up", port)
 	})
 
@@ -110,15 +110,15 @@ var _ = Describe("Podman pod create", func() {
 		name := "test"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--no-hosts", "--name", name})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		alpineResolvConf := podmanTest.Podman([]string{"run", "--rm", "--no-hosts", ALPINE, "cat", "/etc/hosts"})
 		alpineResolvConf.WaitWithDefaultTimeout()
-		Expect(alpineResolvConf).Should(Exit(0))
+		Expect(alpineResolvConf).Should(ExitCleanly())
 
 		podResolvConf := podmanTest.Podman([]string{"run", "--pod", name, "--rm", ALPINE, "cat", "/etc/hosts"})
 		podResolvConf.WaitWithDefaultTimeout()
-		Expect(podResolvConf).Should(Exit(0))
+		Expect(podResolvConf).Should(ExitCleanly())
 		Expect(podResolvConf.OutputToString()).To(Equal(alpineResolvConf.OutputToString()))
 	})
 
@@ -133,11 +133,11 @@ var _ = Describe("Podman pod create", func() {
 		name := "test"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--add-host", "test.example.com:12.34.56.78", "--name", name})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podResolvConf := podmanTest.Podman([]string{"run", "--pod", name, "--rm", ALPINE, "cat", "/etc/hosts"})
 		podResolvConf.WaitWithDefaultTimeout()
-		Expect(podResolvConf).Should(Exit(0))
+		Expect(podResolvConf).Should(ExitCleanly())
 		Expect(podResolvConf.OutputToString()).To(ContainSubstring("12.34.56.78 test.example.com"))
 	})
 
@@ -153,11 +153,11 @@ var _ = Describe("Podman pod create", func() {
 		server := "12.34.56.78"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--dns", server, "--name", name})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podResolvConf := podmanTest.Podman([]string{"run", "--pod", name, "--rm", ALPINE, "cat", "/etc/resolv.conf"})
 		podResolvConf.WaitWithDefaultTimeout()
-		Expect(podResolvConf).Should(Exit(0))
+		Expect(podResolvConf).Should(ExitCleanly())
 		Expect(podResolvConf.OutputToString()).To(ContainSubstring("nameserver %s", server))
 	})
 
@@ -174,11 +174,11 @@ var _ = Describe("Podman pod create", func() {
 		option := "attempts:5"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--dns-opt", option, "--name", name})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podResolvConf := podmanTest.Podman([]string{"run", "--pod", name, "--rm", ALPINE, "cat", "/etc/resolv.conf"})
 		podResolvConf.WaitWithDefaultTimeout()
-		Expect(podResolvConf).Should(Exit(0))
+		Expect(podResolvConf).Should(ExitCleanly())
 		Expect(podResolvConf.OutputToString()).To(ContainSubstring(fmt.Sprintf("options %s", option)))
 	})
 
@@ -195,11 +195,11 @@ var _ = Describe("Podman pod create", func() {
 		search := "example.com"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--dns-search", search, "--name", name})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podResolvConf := podmanTest.Podman([]string{"run", "--pod", name, "--rm", ALPINE, "cat", "/etc/resolv.conf"})
 		podResolvConf.WaitWithDefaultTimeout()
-		Expect(podResolvConf).Should(Exit(0))
+		Expect(podResolvConf).Should(ExitCleanly())
 		Expect(podResolvConf.OutputToString()).To(ContainSubstring(fmt.Sprintf("search %s", search)))
 	})
 
@@ -220,10 +220,10 @@ var _ = Describe("Podman pod create", func() {
 		if isRootless() {
 			Expect(podCreate).Should(Exit(125))
 		} else {
-			Expect(podCreate).Should(Exit(0))
+			Expect(podCreate).Should(ExitCleanly())
 			podResolvConf := podmanTest.Podman([]string{"run", "--pod", name, "--rm", ALPINE, "ip", "addr"})
 			podResolvConf.WaitWithDefaultTimeout()
-			Expect(podResolvConf).Should(Exit(0))
+			Expect(podResolvConf).Should(ExitCleanly())
 			Expect(podResolvConf.OutputToString()).To(ContainSubstring(ip))
 		}
 	})
@@ -235,13 +235,13 @@ var _ = Describe("Podman pod create", func() {
 		ip := GetSafeIPAddress()
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--ip", ip, "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		podCtr := podmanTest.Podman([]string{"run", "--name", ctrName, "--pod", podName, "-d", "-t", ALPINE, "top"})
 		podCtr.WaitWithDefaultTimeout()
-		Expect(podCtr).Should(Exit(0))
+		Expect(podCtr).Should(ExitCleanly())
 		ctrInspect := podmanTest.Podman([]string{"inspect", ctrName})
 		ctrInspect.WaitWithDefaultTimeout()
-		Expect(ctrInspect).Should(Exit(0))
+		Expect(ctrInspect).Should(ExitCleanly())
 		ctrJSON := ctrInspect.InspectContainerToJSON()
 		Expect(ctrJSON[0].NetworkSettings).To(HaveField("IPAddress", ip))
 	})
@@ -263,10 +263,10 @@ var _ = Describe("Podman pod create", func() {
 		if isRootless() {
 			Expect(podCreate).Should(Exit(125))
 		} else {
-			Expect(podCreate).Should(Exit(0))
+			Expect(podCreate).Should(ExitCleanly())
 			podResolvConf := podmanTest.Podman([]string{"run", "--pod", name, "--rm", ALPINE, "ip", "addr"})
 			podResolvConf.WaitWithDefaultTimeout()
-			Expect(podResolvConf).Should(Exit(0))
+			Expect(podResolvConf).Should(ExitCleanly())
 			Expect(podResolvConf.OutputToString()).To(ContainSubstring(mac))
 		}
 	})
@@ -291,7 +291,7 @@ var _ = Describe("Podman pod create", func() {
 
 		session := podmanTest.Podman([]string{"pod", "create", "--name=abc", "--pod-id-file", targetFile})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		id, _ := os.ReadFile(targetFile)
 		check := podmanTest.Podman([]string{"pod", "inspect", "abc"})
@@ -311,7 +311,7 @@ var _ = Describe("Podman pod create", func() {
 		for i := 0; i < 5; i++ {
 			session = podmanTest.Podman([]string{"pod", "create", "--replace", "--name", podName})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 		}
 	})
 
@@ -319,22 +319,22 @@ var _ = Describe("Podman pod create", func() {
 		name := "test"
 		session := podmanTest.Podman([]string{"pod", "create", "--name", name})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"pod", "inspect", name})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		data := check.InspectPodToJSON()
 
 		check1 := podmanTest.Podman([]string{"container", "inspect", "--format", "{{.Config.Entrypoint}}", data.Containers[0].ID})
 		check1.WaitWithDefaultTimeout()
-		Expect(check1).Should(Exit(0))
+		Expect(check1).Should(ExitCleanly())
 		Expect(check1.OutputToString()).To(Equal("/catatonit -P"))
 
 		// check the Path and Args
 		check2 := podmanTest.Podman([]string{"container", "inspect", "--format", "{{.Path}}:{{.Args}}", data.Containers[0].ID})
 		check2.WaitWithDefaultTimeout()
-		Expect(check2).Should(Exit(0))
+		Expect(check2).Should(ExitCleanly())
 		Expect(check2.OutputToString()).To(Equal("/catatonit:[-P]"))
 	})
 
@@ -342,22 +342,22 @@ var _ = Describe("Podman pod create", func() {
 		name := "test"
 		session := podmanTest.Podman([]string{"pod", "create", "--infra-command", "/pause1", "--name", name})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"pod", "inspect", name})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		data := check.InspectPodToJSON()
 
 		check1 := podmanTest.Podman([]string{"container", "inspect", "--format", "{{.Config.Entrypoint}}", data.Containers[0].ID})
 		check1.WaitWithDefaultTimeout()
-		Expect(check1).Should(Exit(0))
+		Expect(check1).Should(ExitCleanly())
 		Expect(check1.OutputToString()).To(Equal("/pause1"))
 
 		// check the Path and Args
 		check2 := podmanTest.Podman([]string{"container", "inspect", "--format", "{{.Path}}:{{.Args}}", data.Containers[0].ID})
 		check2.WaitWithDefaultTimeout()
-		Expect(check2).Should(Exit(0))
+		Expect(check2).Should(ExitCleanly())
 		Expect(check2.OutputToString()).To(Equal("/pause1:[/pause1]"))
 	})
 
@@ -369,22 +369,22 @@ entrypoint ["/fromimage"]
 		name := "test"
 		session := podmanTest.Podman([]string{"pod", "create", "--infra-image", "localhost/infra", "--name", name})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"pod", "inspect", name})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		data := check.InspectPodToJSON()
 
 		check1 := podmanTest.Podman([]string{"container", "inspect", "--format", "{{.Config.Entrypoint}}", data.Containers[0].ID})
 		check1.WaitWithDefaultTimeout()
-		Expect(check1).Should(Exit(0))
+		Expect(check1).Should(ExitCleanly())
 		Expect(check1.OutputToString()).To(Equal("/fromimage"))
 
 		// check the Path and Args
 		check2 := podmanTest.Podman([]string{"container", "inspect", "--format", "{{.Path}}:{{.Args}}", data.Containers[0].ID})
 		check2.WaitWithDefaultTimeout()
-		Expect(check2).Should(Exit(0))
+		Expect(check2).Should(ExitCleanly())
 		Expect(check2.OutputToString()).To(Equal("/fromimage:[/fromimage]"))
 	})
 
@@ -396,22 +396,22 @@ entrypoint ["/fromimage"]
 		name := "test"
 		session := podmanTest.Podman([]string{"pod", "create", "--infra-image", "localhost/infra", "--infra-command", "/fromcommand", "--name", name})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"pod", "inspect", name})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		data := check.InspectPodToJSON()
 
 		check1 := podmanTest.Podman([]string{"container", "inspect", "--format", "{{.Config.Entrypoint}}", data.Containers[0].ID})
 		check1.WaitWithDefaultTimeout()
-		Expect(check1).Should(Exit(0))
+		Expect(check1).Should(ExitCleanly())
 		Expect(check1.OutputToString()).To(Equal("/fromcommand"))
 
 		// check the Path and Args
 		check2 := podmanTest.Podman([]string{"container", "inspect", "--format", "{{.Path}}:{{.Args}}", data.Containers[0].ID})
 		check2.WaitWithDefaultTimeout()
-		Expect(check2).Should(Exit(0))
+		Expect(check2).Should(ExitCleanly())
 		Expect(check2.OutputToString()).To(Equal("/fromcommand:[/fromcommand]"))
 	})
 
@@ -419,11 +419,11 @@ entrypoint ["/fromimage"]
 		name := "test"
 		session := podmanTest.Podman([]string{"pod", "create", "--name", name, "--network", "slirp4netns:port_handler=slirp4netns", "-p", "8082:8000"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"pod", "inspect", "--format", "{{.InfraConfig.NetworkOptions.slirp4netns}}", name})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		Expect(check.OutputToString()).To(Equal("[port_handler=slirp4netns]"))
 	})
 
@@ -431,29 +431,29 @@ entrypoint ["/fromimage"]
 		podName := "testpod"
 		create := podmanTest.Podman([]string{"pod", "create", "--name", podName})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		status1 := podmanTest.Podman([]string{"pod", "inspect", "--format", "{{ .State }}", podName})
 		status1.WaitWithDefaultTimeout()
-		Expect(status1).Should(Exit(0))
+		Expect(status1).Should(ExitCleanly())
 		Expect(status1.OutputToString()).To(ContainSubstring("Created"))
 
 		ctr1 := podmanTest.Podman([]string{"run", "--pod", podName, "-d", ALPINE, "top"})
 		ctr1.WaitWithDefaultTimeout()
-		Expect(ctr1).Should(Exit(0))
+		Expect(ctr1).Should(ExitCleanly())
 
 		status2 := podmanTest.Podman([]string{"pod", "inspect", "--format", "{{ .State }}", podName})
 		status2.WaitWithDefaultTimeout()
-		Expect(status2).Should(Exit(0))
+		Expect(status2).Should(ExitCleanly())
 		Expect(status2.OutputToString()).To(ContainSubstring("Running"))
 
 		ctr2 := podmanTest.Podman([]string{"create", "--pod", podName, ALPINE, "top"})
 		ctr2.WaitWithDefaultTimeout()
-		Expect(ctr2).Should(Exit(0))
+		Expect(ctr2).Should(ExitCleanly())
 
 		status3 := podmanTest.Podman([]string{"pod", "inspect", "--format", "{{ .State }}", podName})
 		status3.WaitWithDefaultTimeout()
-		Expect(status3).Should(Exit(0))
+		Expect(status3).Should(ExitCleanly())
 		Expect(status3.OutputToString()).To(ContainSubstring("Degraded"))
 	})
 
@@ -473,28 +473,28 @@ entrypoint ["/fromimage"]
 		networkMode := fmt.Sprintf("ns:/var/run/netns/%s", netNsName)
 
 		addNetns := SystemExec("ip", []string{"netns", "add", netNsName})
-		Expect(addNetns).Should(Exit(0))
+		Expect(addNetns).Should(ExitCleanly())
 		defer func() {
 			delNetns := SystemExec("ip", []string{"netns", "delete", netNsName})
-			Expect(delNetns).Should(Exit(0))
+			Expect(delNetns).Should(ExitCleanly())
 		}()
 
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--network", networkMode})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podStart := podmanTest.Podman([]string{"pod", "start", podName})
 		podStart.WaitWithDefaultTimeout()
-		Expect(podStart).Should(Exit(0))
+		Expect(podStart).Should(ExitCleanly())
 
 		inspectPod := podmanTest.Podman([]string{"pod", "inspect", podName})
 		inspectPod.WaitWithDefaultTimeout()
-		Expect(inspectPod).Should(Exit(0))
+		Expect(inspectPod).Should(ExitCleanly())
 		inspectPodJSON := inspectPod.InspectPodToJSON()
 
 		inspectInfraContainer := podmanTest.Podman([]string{"inspect", inspectPodJSON.InfraContainerID})
 		inspectInfraContainer.WaitWithDefaultTimeout()
-		Expect(inspectInfraContainer).Should(Exit(0))
+		Expect(inspectInfraContainer).Should(ExitCleanly())
 		inspectInfraContainerJSON := inspectInfraContainer.InspectContainerToJSON()
 
 		Expect(inspectInfraContainerJSON[0].HostConfig.NetworkMode).To(Equal(networkMode))
@@ -504,11 +504,11 @@ entrypoint ["/fromimage"]
 		podName := "testPod"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--network", "none", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		session := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "ip", "-o", "-4", "addr"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("inet 127.0.0.1/8 scope host lo"))
 		Expect(session.OutputToStringArray()).To(HaveLen(1))
 	})
@@ -523,7 +523,7 @@ ENTRYPOINT ["sleep","99999"]
 
 		create := podmanTest.Podman([]string{"pod", "create", "--infra-image", iid})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 	})
 
 	It("podman pod create --cpus", func() {
@@ -533,15 +533,15 @@ ENTRYPOINT ["sleep","99999"]
 		numCPUStr := strconv.Itoa(int(numCPU))
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--cpus", numCPUStr, "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		contCreate := podmanTest.Podman([]string{"container", "create", "--pod", podName, "alpine"})
 		contCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", podName})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).Should(Exit(0))
+		Expect(podInspect).Should(ExitCleanly())
 		podJSON := podInspect.InspectPodToJSON()
 		Expect(podJSON).To(HaveField("CPUPeriod", period))
 		Expect(podJSON).To(HaveField("CPUQuota", quota))
@@ -555,15 +555,15 @@ ENTRYPOINT ["sleep","99999"]
 		in := "0-" + numCPUStr
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--cpuset-cpus", in, "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		contCreate := podmanTest.Podman([]string{"container", "create", "--name", ctrName, "--pod", podName, "alpine"})
 		contCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", podName})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).Should(Exit(0))
+		Expect(podInspect).Should(ExitCleanly())
 		podJSON := podInspect.InspectPodToJSON()
 		Expect(podJSON).To(HaveField("CPUSetCPUs", in))
 	})
@@ -573,11 +573,11 @@ ENTRYPOINT ["sleep","99999"]
 		ns := "ns:/proc/self/ns/"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--pid", ns, "--name", podName, "--share", "pid"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", podName})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).Should(Exit(0))
+		Expect(podInspect).Should(ExitCleanly())
 		podJSON := podInspect.InspectPodToJSON()
 		Expect(podJSON.InfraConfig).To(HaveField("PidNS", ns))
 
@@ -593,11 +593,11 @@ ENTRYPOINT ["sleep","99999"]
 
 		podCreate = podmanTest.Podman([]string{"pod", "create", "--pid", ns, "--name", podName, "--share", "pid"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podInspect = podmanTest.Podman([]string{"pod", "inspect", podName})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).Should(Exit(0))
+		Expect(podInspect).Should(ExitCleanly())
 		podJSON = podInspect.InspectPodToJSON()
 		Expect(podJSON.InfraConfig).To(HaveField("PidNS", "host"))
 
@@ -606,11 +606,11 @@ ENTRYPOINT ["sleep","99999"]
 
 		podCreate = podmanTest.Podman([]string{"pod", "create", "--pid", ns, "--name", podName, "--share", "pid"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podInspect = podmanTest.Podman([]string{"pod", "inspect", podName})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).Should(Exit(0))
+		Expect(podInspect).Should(ExitCleanly())
 		podJSON = podInspect.InspectPodToJSON()
 		Expect(podJSON.InfraConfig).To(HaveField("PidNS", "private"))
 
@@ -631,18 +631,18 @@ ENTRYPOINT ["sleep","99999"]
 		podName := "testPod"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--userns", "keep-id", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		session := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "id", "-u"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		uid := fmt.Sprintf("%d", os.Geteuid())
 		Expect(session.OutputToString()).To(ContainSubstring(uid))
 
 		// Check passwd
 		session = podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "id", "-un"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		u, err := user.Current()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(session.OutputToString()).To(Equal(u.Username))
@@ -650,7 +650,7 @@ ENTRYPOINT ["sleep","99999"]
 		// root owns /usr
 		session = podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "stat", "-c%u", "/usr"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Equal("0"))
 
 		// fail if --pod and --userns set together
@@ -667,12 +667,12 @@ ENTRYPOINT ["sleep","99999"]
 		podName := "testPod"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--userns", "keep-id", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		ctrName := "ctr-name"
 		session := podmanTest.Podman([]string{"run", "--pod", podName, "-d", "--stop-signal", "9", "--name", ctrName, fedoraMinimal, "sleep", "600"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		u, err := user.Current()
 		Expect(err).ToNot(HaveOccurred())
@@ -680,16 +680,16 @@ ENTRYPOINT ["sleep","99999"]
 		// etc/passwd entry will look like USERNAME:*:1000:1000:Full User Name:/:/bin/sh
 		exec1 := podmanTest.Podman([]string{"exec", ctrName, "id", "-un"})
 		exec1.WaitWithDefaultTimeout()
-		Expect(exec1).Should(Exit(0))
+		Expect(exec1).Should(ExitCleanly())
 		Expect(exec1.OutputToString()).To(Equal(u.Username))
 
 		exec2 := podmanTest.Podman([]string{"exec", ctrName, "useradd", "testuser"})
 		exec2.WaitWithDefaultTimeout()
-		Expect(exec2).Should(Exit(0))
+		Expect(exec2).Should(ExitCleanly())
 
 		exec3 := podmanTest.Podman([]string{"exec", ctrName, "cat", "/etc/passwd"})
 		exec3.WaitWithDefaultTimeout()
-		Expect(exec3).Should(Exit(0))
+		Expect(exec3).Should(ExitCleanly())
 		Expect(exec3.OutputToString()).To(ContainSubstring("testuser"))
 	})
 
@@ -714,11 +714,11 @@ ENTRYPOINT ["sleep","99999"]
 			podName := "testPod" + strconv.Itoa(i)
 			podCreate := podmanTest.Podman([]string{"pod", "create", "--userns=auto", "--name", podName})
 			podCreate.WaitWithDefaultTimeout()
-			Expect(podCreate).Should(Exit(0))
+			Expect(podCreate).Should(ExitCleanly())
 
 			session := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "cat", "/proc/self/uid_map"})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 			l := session.OutputToString()
 			Expect(l).To(ContainSubstring("1024"))
 			m[l] = l
@@ -747,19 +747,19 @@ ENTRYPOINT ["sleep","99999"]
 		podName := "testPod"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--userns=auto:size=500", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		session := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "cat", "/proc/self/uid_map"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("500"))
 
 		podName = "testPod-1"
 		podCreate = podmanTest.Podman([]string{"pod", "create", "--userns=auto:size=3000", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "cat", "/proc/self/uid_map"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("3000"))
 	})
 
@@ -783,20 +783,20 @@ ENTRYPOINT ["sleep","99999"]
 		podName := "testPod"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--userns=auto:uidmapping=0:0:1", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		session := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "cat", "/proc/self/uid_map"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		output := session.OutputToString()
 		Expect(output).To(MatchRegexp("\\s0\\s0\\s1"))
 
 		podName = "testPod-1"
 		podCreate = podmanTest.Podman([]string{"pod", "create", "--userns=auto:size=8192,uidmapping=0:0:1", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "cat", "/proc/self/uid_map"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("8191"))
 	})
 
@@ -820,20 +820,20 @@ ENTRYPOINT ["sleep","99999"]
 		podName := "testPod"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--userns=auto:gidmapping=0:0:1", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		session := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "cat", "/proc/self/gid_map"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		output := session.OutputToString()
 		Expect(output).To(MatchRegexp("\\s0\\s0\\s1"))
 
 		podName = "testPod-1"
 		podCreate = podmanTest.Podman([]string{"pod", "create", "--userns=auto:size=8192,gidmapping=0:0:1", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "cat", "/proc/self/gid_map"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("8191"))
 	})
 
@@ -841,29 +841,29 @@ ENTRYPOINT ["sleep","99999"]
 		volName := "testVol"
 		volCreate := podmanTest.Podman([]string{"volume", "create", volName})
 		volCreate.WaitWithDefaultTimeout()
-		Expect(volCreate).Should(Exit(0))
+		Expect(volCreate).Should(ExitCleanly())
 		podName := "testPod"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--volume", volName + ":/tmp1", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", podName})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).Should(Exit(0))
+		Expect(podInspect).Should(ExitCleanly())
 		data := podInspect.InspectPodToJSON()
 		Expect(data.Mounts[0]).To(HaveField("Name", volName))
 		ctrName := "testCtr"
 		ctrCreate := podmanTest.Podman([]string{"create", "--pod", podName, "--name", ctrName, ALPINE})
 		ctrCreate.WaitWithDefaultTimeout()
-		Expect(ctrCreate).Should(Exit(0))
+		Expect(ctrCreate).Should(ExitCleanly())
 		ctrInspect := podmanTest.Podman([]string{"inspect", ctrName})
 		ctrInspect.WaitWithDefaultTimeout()
-		Expect(ctrInspect).Should(Exit(0))
+		Expect(ctrInspect).Should(ExitCleanly())
 		ctrData := ctrInspect.InspectContainerToJSON()
 		Expect(ctrData[0].Mounts[0]).To(HaveField("Name", volName))
 
 		ctr2 := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "sh", "-c", "echo hello >> " + "/tmp1/test"})
 		ctr2.WaitWithDefaultTimeout()
-		Expect(ctr2).Should(Exit(0))
+		Expect(ctr2).Should(ExitCleanly())
 
 		ctr3 := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "cat", "/tmp1/test"})
 		ctr3.WaitWithDefaultTimeout()
@@ -871,7 +871,7 @@ ENTRYPOINT ["sleep","99999"]
 
 		ctr4 := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "touch", "/tmp1/testing.txt"})
 		ctr4.WaitWithDefaultTimeout()
-		Expect(ctr4).Should(Exit(0))
+		Expect(ctr4).Should(ExitCleanly())
 	})
 
 	It("podman pod create --device", func() {
@@ -883,15 +883,15 @@ ENTRYPOINT ["sleep","99999"]
 
 		mknod := SystemExec("mknod", []string{devdir + "/null", "c", "1", "3"})
 		mknod.WaitWithDefaultTimeout()
-		Expect(mknod).Should(Exit(0))
+		Expect(mknod).Should(ExitCleanly())
 
 		podName := "testPod"
 		session := podmanTest.Podman([]string{"pod", "create", "--device", devdir + ":/dev/bar", "--name", podName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"run", "-q", "--pod", podName, ALPINE, "stat", "-c%t:%T", "/dev/bar/null"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Equal("1:3"))
 
 	})
@@ -900,29 +900,29 @@ ENTRYPOINT ["sleep","99999"]
 		volName := "testVol"
 		volCreate := podmanTest.Podman([]string{"volume", "create", volName})
 		volCreate.WaitWithDefaultTimeout()
-		Expect(volCreate).Should(Exit(0))
+		Expect(volCreate).Should(ExitCleanly())
 		ctrName := "testCtr"
 		ctrCreate := podmanTest.Podman([]string{"create", "--volume", volName + ":/tmp1", "--name", ctrName, ALPINE})
 		ctrCreate.WaitWithDefaultTimeout()
-		Expect(ctrCreate).Should(Exit(0))
+		Expect(ctrCreate).Should(ExitCleanly())
 		ctrInspect := podmanTest.Podman([]string{"inspect", ctrName})
 		ctrInspect.WaitWithDefaultTimeout()
-		Expect(ctrInspect).Should(Exit(0))
+		Expect(ctrInspect).Should(ExitCleanly())
 		data := ctrInspect.InspectContainerToJSON()
 		Expect(data[0].Mounts[0]).To(HaveField("Name", volName))
 		podName := "testPod"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--volumes-from", ctrName, "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", podName})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).Should(Exit(0))
+		Expect(podInspect).Should(ExitCleanly())
 		podData := podInspect.InspectPodToJSON()
 		Expect(podData.Mounts[0]).To(HaveField("Name", volName))
 
 		ctr2 := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "sh", "-c", "echo hello >> " + "/tmp1/test"})
 		ctr2.WaitWithDefaultTimeout()
-		Expect(ctr2).Should(Exit(0))
+		Expect(ctr2).Should(ExitCleanly())
 
 		ctr3 := podmanTest.Podman([]string{"run", "--pod", podName, ALPINE, "cat", "/tmp1/test"})
 		ctr3.WaitWithDefaultTimeout()
@@ -939,11 +939,11 @@ ENTRYPOINT ["sleep","99999"]
 
 		pod := podmanTest.Podman([]string{"pod", "create", "--name", "test", "--infra-name", "test-infra"})
 		pod.WaitWithDefaultTimeout()
-		Expect(pod).Should(Exit(0))
+		Expect(pod).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"inspect", "--format", "{{.HostConfig.NetworkMode}}", "test-infra"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).Should(Equal("host"))
 	})
 
@@ -953,22 +953,22 @@ ENTRYPOINT ["sleep","99999"]
 		}
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--security-opt", "label=type:spc_t", "--security-opt", "seccomp=unconfined"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		ctrCreate := podmanTest.Podman([]string{"container", "create", "--pod", podCreate.OutputToString(), ALPINE})
 		ctrCreate.WaitWithDefaultTimeout()
-		Expect(ctrCreate).Should(Exit(0))
+		Expect(ctrCreate).Should(ExitCleanly())
 
 		ctrInspect := podmanTest.InspectContainer(ctrCreate.OutputToString())
 		Expect(ctrInspect[0].HostConfig).To(HaveField("SecurityOpt", []string{"label=type:spc_t", "seccomp=unconfined"}))
 
 		podCreate = podmanTest.Podman([]string{"pod", "create", "--security-opt", "label=disable"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		ctrCreate = podmanTest.Podman([]string{"container", "run", "--pod", podCreate.OutputToString(), ALPINE, "cat", "/proc/self/attr/current"})
 		ctrCreate.WaitWithDefaultTimeout()
-		Expect(ctrCreate).Should(Exit(0))
+		Expect(ctrCreate).Should(ExitCleanly())
 		Expect(ctrCreate.OutputToString()).To(ContainSubstring("spc_t"))
 	})
 
@@ -978,11 +978,11 @@ ENTRYPOINT ["sleep","99999"]
 		}
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--security-opt", "seccomp=unconfined"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		ctrCreate := podmanTest.Podman([]string{"container", "create", "--pod", podCreate.OutputToString(), ALPINE})
 		ctrCreate.WaitWithDefaultTimeout()
-		Expect(ctrCreate).Should(Exit(0))
+		Expect(ctrCreate).Should(ExitCleanly())
 
 		ctrInspect := podmanTest.InspectContainer(ctrCreate.OutputToString())
 		Expect(ctrInspect[0].HostConfig).To(HaveField("SecurityOpt", []string{"seccomp=unconfined"}))
@@ -994,11 +994,11 @@ ENTRYPOINT ["sleep","99999"]
 		}
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--security-opt", fmt.Sprintf("apparmor=%s", apparmor.Profile)})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		ctrCreate := podmanTest.Podman([]string{"container", "create", "--pod", podCreate.OutputToString(), ALPINE})
 		ctrCreate.WaitWithDefaultTimeout()
-		Expect(ctrCreate).Should(Exit(0))
+		Expect(ctrCreate).Should(ExitCleanly())
 
 		inspect := podmanTest.InspectContainer(ctrCreate.OutputToString())
 		Expect(inspect[0]).To(HaveField("AppArmorProfile", apparmor.Profile))
@@ -1009,36 +1009,36 @@ ENTRYPOINT ["sleep","99999"]
 		SkipIfRootless("Network sysctls are not available root rootless")
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--sysctl", "net.core.somaxconn=65535"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		session := podmanTest.Podman([]string{"run", "--pod", podCreate.OutputToString(), "--rm", ALPINE, "sysctl", "net.core.somaxconn"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("net.core.somaxconn = 65535"))
 
 		// if not sharing the net NS, nothing should fail, but the sysctl should not be passed
 		podCreate = podmanTest.Podman([]string{"pod", "create", "--share", "pid", "--sysctl", "net.core.somaxconn=65535"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"run", "--pod", podCreate.OutputToString(), "--rm", ALPINE, "sysctl", "net.core.somaxconn"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).NotTo(ContainSubstring("net.core.somaxconn = 65535"))
 
 		// one other misc option
 		podCreate = podmanTest.Podman([]string{"pod", "create", "--sysctl", "kernel.msgmax=65535"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"run", "--pod", podCreate.OutputToString(), "--rm", ALPINE, "sysctl", "kernel.msgmax"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("kernel.msgmax = 65535"))
 
 		podCreate = podmanTest.Podman([]string{"pod", "create", "--share", "pid", "--sysctl", "kernel.msgmax=65535"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"run", "--pod", podCreate.OutputToString(), "--rm", ALPINE, "sysctl", "kernel.msgmax"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).NotTo(ContainSubstring("kernel.msgmax = 65535"))
 
 	})
@@ -1048,15 +1048,15 @@ ENTRYPOINT ["sleep","99999"]
 		SkipIfCgroupV1("CgroupMode shows 'host' on CGv1, not CID (issue 15013, wontfix")
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--share-parent=false"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		ctrCreate := podmanTest.Podman([]string{"run", "-dt", "--pod", podCreate.OutputToString(), ALPINE})
 		ctrCreate.WaitWithDefaultTimeout()
-		Expect(ctrCreate).Should(Exit(0))
+		Expect(ctrCreate).Should(ExitCleanly())
 
 		inspectPod := podmanTest.Podman([]string{"pod", "inspect", podCreate.OutputToString()})
 		inspectPod.WaitWithDefaultTimeout()
-		Expect(inspectPod).Should(Exit(0))
+		Expect(inspectPod).Should(ExitCleanly())
 		data := inspectPod.InspectPodToJSON()
 
 		inspect := podmanTest.InspectContainer(ctrCreate.OutputToString())
@@ -1069,11 +1069,11 @@ ENTRYPOINT ["sleep","99999"]
 
 		podCreate2 := podmanTest.Podman([]string{"pod", "create", "--share", "cgroup,ipc,net,uts", "--share-parent=false", "--infra-name", "cgroupCtr"})
 		podCreate2.WaitWithDefaultTimeout()
-		Expect(podCreate2).Should(Exit(0))
+		Expect(podCreate2).Should(ExitCleanly())
 
 		ctrCreate2 := podmanTest.Podman([]string{"run", "-dt", "--pod", podCreate2.OutputToString(), ALPINE})
 		ctrCreate2.WaitWithDefaultTimeout()
-		Expect(ctrCreate2).Should(Exit(0))
+		Expect(ctrCreate2).Should(ExitCleanly())
 
 		inspectInfra := podmanTest.InspectContainer("cgroupCtr")
 
@@ -1083,7 +1083,7 @@ ENTRYPOINT ["sleep","99999"]
 
 		podCreate3 := podmanTest.Podman([]string{"pod", "create", "--share", "cgroup"})
 		podCreate3.WaitWithDefaultTimeout()
-		Expect(podCreate3).ShouldNot(Exit(0))
+		Expect(podCreate3).ShouldNot(ExitCleanly())
 
 	})
 
@@ -1091,20 +1091,20 @@ ENTRYPOINT ["sleep","99999"]
 		volName := "testVol1"
 		volCreate := podmanTest.Podman([]string{"volume", "create", volName})
 		volCreate.WaitWithDefaultTimeout()
-		Expect(volCreate).Should(Exit(0))
+		Expect(volCreate).Should(ExitCleanly())
 
 		session := podmanTest.Podman([]string{"pod", "create", "-v", volName + ":/vol1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		volName2 := "testVol2"
 		volCreate = podmanTest.Podman([]string{"volume", "create", volName2})
 		volCreate.WaitWithDefaultTimeout()
-		Expect(volCreate).Should(Exit(0))
+		Expect(volCreate).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", session.OutputToString(), "-v", volName2 + ":/vol2", ALPINE, "mount"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).Should(ContainSubstring("/vol1"))
 		Expect(session.OutputToString()).Should(ContainSubstring("/vol2"))
 	})
@@ -1112,11 +1112,11 @@ ENTRYPOINT ["sleep","99999"]
 	It("podman pod create --shm-size", func() {
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--shm-size", "10mb"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		run := podmanTest.Podman([]string{"run", "--pod", podCreate.OutputToString(), ALPINE, "mount"})
 		run.WaitWithDefaultTimeout()
-		Expect(run).Should(Exit(0))
+		Expect(run).Should(ExitCleanly())
 		t, strings := run.GrepString("shm on /dev/shm type tmpfs")
 		Expect(t).To(BeTrue(), "found /dev/shm")
 		Expect(strings[0]).Should(ContainSubstring("size=10240k"))
@@ -1125,21 +1125,21 @@ ENTRYPOINT ["sleep","99999"]
 	It("podman pod create --shm-size and --ipc=host conflict", func() {
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--shm-size", "10mb"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		run := podmanTest.Podman([]string{"run", "-dt", "--pod", podCreate.OutputToString(), "--ipc", "host", ALPINE})
 		run.WaitWithDefaultTimeout()
-		Expect(run).ShouldNot(Exit(0))
+		Expect(run).ShouldNot(ExitCleanly())
 	})
 
 	It("podman pod create --uts test", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--uts", "host"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", session.OutputToString(), ALPINE, "printenv", "HOSTNAME"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(hostname))
 
 		podName := "utsPod"
@@ -1148,11 +1148,11 @@ ENTRYPOINT ["sleep","99999"]
 		// just share uts with a custom path
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--uts", ns, "--name", podName, "--share", "uts"})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		podInspect := podmanTest.Podman([]string{"pod", "inspect", podName})
 		podInspect.WaitWithDefaultTimeout()
-		Expect(podInspect).Should(Exit(0))
+		Expect(podInspect).Should(ExitCleanly())
 		podJSON := podInspect.InspectPodToJSON()
 		Expect(podJSON.InfraConfig).To(HaveField("UtsNS", ns))
 	})
@@ -1161,16 +1161,16 @@ ENTRYPOINT ["sleep","99999"]
 		podName := "testShmSizeSystemd"
 		session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--shm-size-systemd", "10mb"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// add container to pod
 		ctrRun := podmanTest.Podman([]string{"run", "-d", "--pod", podName, SYSTEMD_IMAGE, "/sbin/init"})
 		ctrRun.WaitWithDefaultTimeout()
-		Expect(ctrRun).Should(Exit(0))
+		Expect(ctrRun).Should(ExitCleanly())
 
 		run := podmanTest.Podman([]string{"exec", ctrRun.OutputToString(), "mount"})
 		run.WaitWithDefaultTimeout()
-		Expect(run).Should(Exit(0))
+		Expect(run).Should(ExitCleanly())
 		t, strings := run.GrepString("tmpfs on /run/lock")
 		Expect(t).To(BeTrue(), "found /run/lock")
 		Expect(strings[0]).Should(ContainSubstring("size=10240k"))
@@ -1179,17 +1179,17 @@ ENTRYPOINT ["sleep","99999"]
 	It("create pod with name subset of existing ID", func() {
 		create1 := podmanTest.Podman([]string{"pod", "create"})
 		create1.WaitWithDefaultTimeout()
-		Expect(create1).Should(Exit(0))
+		Expect(create1).Should(ExitCleanly())
 		pod1ID := create1.OutputToString()
 
 		pod2Name := pod1ID[:5]
 		create2 := podmanTest.Podman([]string{"pod", "create", pod2Name})
 		create2.WaitWithDefaultTimeout()
-		Expect(create2).Should(Exit(0))
+		Expect(create2).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"pod", "inspect", "--format", "{{.Name}}", pod2Name})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).Should(Equal(pod2Name))
 	})
 
@@ -1200,22 +1200,22 @@ ENTRYPOINT ["sleep","99999"]
 		testCtr := "ctr1"
 		session := podmanTest.Podman([]string{"pod", "create", podName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		// add container to pod
 		ctrRun := podmanTest.Podman([]string{"run", "--name", testCtr, "-d", "--pod", podName, ALPINE, "echo", "hello"})
 		ctrRun.WaitWithDefaultTimeout()
-		Expect(ctrRun).Should(Exit(0))
+		Expect(ctrRun).Should(ExitCleanly())
 		// Wait about 1 second, so we can check the number of restarts as default restart policy is set to No
 		time.Sleep(1 * time.Second)
 		ps := podmanTest.Podman([]string{"ps", "-a", "--filter", "name=" + testCtr, "--format", "{{.Restarts}}"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		restarts, err := strconv.Atoi(ps.OutputToString())
 		Expect(err).ToNot(HaveOccurred())
 		Expect(restarts).To(BeNumerically("==", 0))
 		ps = podmanTest.Podman([]string{"ps", "-a", "--filter", "name=" + testCtr, "--format", "{{.Status}}"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		Expect(ps.OutputToString()).To(ContainSubstring("Exited"))
 	})
 
@@ -1226,29 +1226,29 @@ ENTRYPOINT ["sleep","99999"]
 		testCtr := "ctr2"
 		session := podmanTest.Podman([]string{"pod", "create", "--restart", "on-failure:2", podName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		// add container to pod
 		ctrRun := podmanTest.Podman([]string{"run", "--name", runningCtr, "-d", "--pod", podName, ALPINE, "sleep", "100"})
 		ctrRun.WaitWithDefaultTimeout()
-		Expect(ctrRun).Should(Exit(0))
+		Expect(ctrRun).Should(ExitCleanly())
 		ctrRun = podmanTest.Podman([]string{"run", "--name", testCtr, "-d", "--pod", podName, ALPINE, "sh", "-c", "echo hello && exit 1"})
 		ctrRun.WaitWithDefaultTimeout()
-		Expect(ctrRun).Should(Exit(0))
+		Expect(ctrRun).Should(ExitCleanly())
 		// Wait about 2 seconds, so we can check the number of restarts after failure
 		time.Sleep(2 * time.Second)
 		ps := podmanTest.Podman([]string{"ps", "-a", "--filter", "name=" + testCtr, "--format", "{{.Restarts}}"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		restarts, err := strconv.Atoi(ps.OutputToString())
 		Expect(err).ToNot(HaveOccurred())
 		Expect(restarts).To(BeNumerically("==", 2))
 		ps = podmanTest.Podman([]string{"ps", "-a", "--filter", "name=" + testCtr, "--format", "{{.Status}}"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		Expect(ps.OutputToString()).To(ContainSubstring("Exited"))
 		ps = podmanTest.Podman([]string{"ps", "-a", "--filter", "name=" + runningCtr, "--format", "{{.Status}}"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		Expect(ps.OutputToString()).To(ContainSubstring("Up"))
 	})
 
@@ -1262,44 +1262,44 @@ ENTRYPOINT ["sleep","99999"]
 			testCtr2 := "ctr3-" + p
 			session := podmanTest.Podman([]string{"pod", "create", "--restart", p, podName})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 			// add container to pod
 			ctrRun := podmanTest.Podman([]string{"run", "--name", runningCtr, "-d", "--pod", podName, ALPINE, "sleep", "100"})
 			ctrRun.WaitWithDefaultTimeout()
-			Expect(ctrRun).Should(Exit(0))
+			Expect(ctrRun).Should(ExitCleanly())
 			ctrRun = podmanTest.Podman([]string{"run", "--name", testCtr, "-d", "--pod", podName, ALPINE, "echo", "hello"})
 			ctrRun.WaitWithDefaultTimeout()
-			Expect(ctrRun).Should(Exit(0))
+			Expect(ctrRun).Should(ExitCleanly())
 			ctrRun = podmanTest.Podman([]string{"run", "--name", testCtr2, "-d", "--pod", podName, ALPINE, "sh", "-c", "echo hello && exit 1"})
 			ctrRun.WaitWithDefaultTimeout()
-			Expect(ctrRun).Should(Exit(0))
+			Expect(ctrRun).Should(ExitCleanly())
 			// Wait 1 second, so we can check the number of restarts and make sure the container has actually ran
 			time.Sleep(1 * time.Second)
 			// check first test container - container exits with exit code 0
 			ps := podmanTest.Podman([]string{"ps", "-a", "--filter", "name=" + testCtr, "--format", "{{.Restarts}}"})
 			ps.WaitWithDefaultTimeout()
-			Expect(ps).Should(Exit(0))
+			Expect(ps).Should(ExitCleanly())
 			restarts, err := strconv.Atoi(ps.OutputToString())
 			Expect(err).ToNot(HaveOccurred())
 			Expect(restarts).To(BeNumerically("==", 0))
 			ps = podmanTest.Podman([]string{"ps", "-a", "--filter", "name=" + testCtr, "--format", "{{.Status}}"})
 			ps.WaitWithDefaultTimeout()
-			Expect(ps).Should(Exit(0))
+			Expect(ps).Should(ExitCleanly())
 			Expect(ps.OutputToString()).To(ContainSubstring("Exited"))
 			// Check second test container - container exits with non-zero exit code
 			ps = podmanTest.Podman([]string{"ps", "-a", "--filter", "name=" + testCtr2, "--format", "{{.Restarts}}"})
 			ps.WaitWithDefaultTimeout()
-			Expect(ps).Should(Exit(0))
+			Expect(ps).Should(ExitCleanly())
 			restarts, err = strconv.Atoi(ps.OutputToString())
 			Expect(err).ToNot(HaveOccurred())
 			Expect(restarts).To(BeNumerically("==", 0))
 			ps = podmanTest.Podman([]string{"ps", "-a", "--filter", "name=" + testCtr2, "--format", "{{.Status}}"})
 			ps.WaitWithDefaultTimeout()
-			Expect(ps).Should(Exit(0))
+			Expect(ps).Should(ExitCleanly())
 			Expect(ps.OutputToString()).To(ContainSubstring("Exited"))
 			ps = podmanTest.Podman([]string{"ps", "-a", "--filter", "name=" + runningCtr, "--format", "{{.Status}}"})
 			ps.WaitWithDefaultTimeout()
-			Expect(ps).Should(Exit(0))
+			Expect(ps).Should(ExitCleanly())
 			Expect(ps.OutputToString()).To(ContainSubstring("Up"))
 		}
 	})
diff --git a/test/e2e/pod_infra_container_test.go b/test/e2e/pod_infra_container_test.go
index 69d1381ed3..df5bcb767b 100644
--- a/test/e2e/pod_infra_container_test.go
+++ b/test/e2e/pod_infra_container_test.go
@@ -6,7 +6,6 @@ import (
 	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("Podman pod create", func() {
@@ -14,7 +13,7 @@ var _ = Describe("Podman pod create", func() {
 	It("podman create infra container", func() {
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		check := podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc"})
@@ -30,54 +29,54 @@ var _ = Describe("Podman pod create", func() {
 	It("podman start infra container", func() {
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"ps", "-qa", "--no-trunc", "--filter", "status=running"})
 		check.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(check.OutputToStringArray()).To(HaveLen(1))
 	})
 
 	It("podman start infra container different image", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--infra-image", BB})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
 		// If we use the default entry point, we should exit with no error
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman infra container namespaces", func() {
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podID)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"ps", "-a", "--no-trunc", "--ns", "--format", "{{.Namespaces.IPC}} {{.Namespaces.NET}}"})
 		check.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(check.OutputToStringArray()).To(HaveLen(2))
 		Expect(check.OutputToStringArray()[0]).To(Equal(check.OutputToStringArray()[1]))
 
 		check = podmanTest.Podman([]string{"ps", "-a", "--no-trunc", "--ns", "--format", "{{.IPC}} {{.NET}}"})
 		check.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(check.OutputToStringArray()).To(HaveLen(2))
 		Expect(check.OutputToStringArray()[0]).To(Equal(check.OutputToStringArray()[1]))
 	})
@@ -85,20 +84,20 @@ var _ = Describe("Podman pod create", func() {
 	It("podman pod correctly sets up NetNS", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--share", "net"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "-d", "--pod", podID, NGINX_IMAGE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", podID, fedoraMinimal, "curl", "-f", "localhost:80"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", fedoraMinimal, "curl", "-f", "localhost"})
 		session.WaitWithDefaultTimeout()
@@ -106,15 +105,15 @@ var _ = Describe("Podman pod create", func() {
 
 		session = podmanTest.Podman([]string{"pod", "create", "--network", "host"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--name", "hostCtr", "--pod", session.OutputToString(), ALPINE, "readlink", "/proc/self/ns/net"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		ns := SystemExec("readlink", []string{"/proc/self/ns/net"})
 		ns.WaitWithDefaultTimeout()
-		Expect(ns).Should(Exit(0))
+		Expect(ns).Should(ExitCleanly())
 		netns := ns.OutputToString()
 		Expect(netns).ToNot(BeEmpty())
 
@@ -123,7 +122,7 @@ var _ = Describe("Podman pod create", func() {
 		// Sanity Check for podman inspect
 		session = podmanTest.Podman([]string{"inspect", "--format", "'{{.NetworkSettings.SandboxKey}}'", "hostCtr"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).Should(Equal("''")) // no network path... host
 
 	})
@@ -131,43 +130,43 @@ var _ = Describe("Podman pod create", func() {
 	It("podman pod correctly sets up IPCNS", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--share", "ipc"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", podID, fedoraMinimal, "/bin/sh", "-c", "'touch /dev/shm/hi'"})
 		session.WaitWithDefaultTimeout()
 		if session.ExitCode() != 0 {
 			Skip("ShmDir not initialized, skipping...")
 		}
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", podID, fedoraMinimal, "/bin/sh", "-c", "'ls /dev/shm'"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Equal("hi"))
 	})
 
 	It("podman pod correctly sets up PIDNS", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--share", "pid", "--name", "test-pod"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("test-ctr", podID)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"top", "test-ctr", "pid"})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		PIDs := check.OutputToStringArray()
 		Expect(PIDs).To(HaveLen(3))
 
@@ -179,25 +178,25 @@ var _ = Describe("Podman pod create", func() {
 	It("podman pod doesn't share PIDNS if requested to not", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--share", "net", "--name", "test-pod"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("test-ctr", podID)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"top", "test-ctr", "pid"})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		ctrTop := check.OutputToStringArray()
 
 		check = podmanTest.Podman([]string{"top", podID[:12] + "-infra", "pid"})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		infraTop := check.OutputToStringArray()
 
 		ctrPID, _ := strconv.Atoi(ctrTop[1])
@@ -208,16 +207,16 @@ var _ = Describe("Podman pod create", func() {
 	It("podman pod container can override pod net NS", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--share", "net"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "-d", "--pod", podID, NGINX_IMAGE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", podID, "--network", "bridge", NGINX_IMAGE, "curl", "-f", "localhost"})
 		session.WaitWithDefaultTimeout()
@@ -228,26 +227,26 @@ var _ = Describe("Podman pod create", func() {
 		SkipIfRootlessCgroupsV1("Not supported for rootless + CgroupsV1")
 		session := podmanTest.Podman([]string{"pod", "create", "--share", "pid"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", podID, "--pid", "host", "-d", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{.Namespaces.PIDNS}}"})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		outputArray := check.OutputToStringArray()
 		Expect(outputArray).To(HaveLen(2))
 
 		check = podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{.PIDNS}}"})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		outputArray = check.OutputToStringArray()
 		Expect(outputArray).To(HaveLen(2))
 
@@ -259,20 +258,20 @@ var _ = Describe("Podman pod create", func() {
 	It("podman pod container can override pod not sharing pid", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--share", "net"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", podID, "--pid", "pod", "-d", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{.PIDNS}}"})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		outputArray := check.OutputToStringArray()
 		Expect(outputArray).To(HaveLen(2))
 
@@ -284,20 +283,20 @@ var _ = Describe("Podman pod create", func() {
 	It("podman pod container can override pod ipc NS", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--share", "ipc"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", podID, "--ipc", "host", "-d", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{.IPC}}"})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		outputArray := check.OutputToStringArray()
 		Expect(outputArray).To(HaveLen(2))
 
@@ -309,12 +308,12 @@ var _ = Describe("Podman pod create", func() {
 	It("podman pod infra container deletion", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--share", "ipc"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"ps", "-aq"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		infraID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"rm", infraID})
@@ -323,27 +322,27 @@ var _ = Describe("Podman pod create", func() {
 
 		session = podmanTest.Podman([]string{"pod", "rm", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman run in pod starts infra", func() {
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"ps", "-aq"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		infraID := result.OutputToString()
 
 		result = podmanTest.Podman([]string{"run", "--pod", podID, "-d", ALPINE, "top"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		result = podmanTest.Podman([]string{"ps", "-aq"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 
 		Expect(result.OutputToString()).To(ContainSubstring(infraID))
@@ -352,26 +351,26 @@ var _ = Describe("Podman pod create", func() {
 	It("podman start in pod starts infra", func() {
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"ps", "-aq"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		infraID := result.OutputToString()
 
 		result = podmanTest.Podman([]string{"create", "--pod", podID, ALPINE, "ls"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		ctrID := result.OutputToString()
 
 		result = podmanTest.Podman([]string{"start", ctrID})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		result = podmanTest.Podman([]string{"ps", "-aq"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 
 		Expect(result.OutputToString()).To(ContainSubstring(infraID))
@@ -380,7 +379,7 @@ var _ = Describe("Podman pod create", func() {
 	It("podman run --add-host in pod should fail", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--add-host", "host1:127.0.0.1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"create", "--pod", podID, "--add-host", "foobar:127.0.0.1", ALPINE, "ping", "-c", "1", "foobar"})
@@ -391,26 +390,26 @@ var _ = Describe("Podman pod create", func() {
 		// verify we can see the pods hosts
 		session = podmanTest.Podman([]string{"run", "--cap-add", "net_raw", "--pod", podID, ALPINE, "ping", "-c", "1", "host1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman run hostname is shared", func() {
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		// verify we can add a host to the infra's /etc/hosts
 		session = podmanTest.Podman([]string{"run", "--pod", podID, ALPINE, "hostname"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		hostname := session.OutputToString()
 
 		infraName := podID[:12] + "-infra"
 		// verify we can see the other hosts of infra's /etc/hosts
 		session = podmanTest.Podman([]string{"inspect", infraName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(hostname))
 	})
 
@@ -420,11 +419,11 @@ var _ = Describe("Podman pod create", func() {
 		It("podman pod create --share="+test+" should not create an infra ctr", func() {
 			session := podmanTest.Podman([]string{"pod", "create", "--share", test})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 
 			session = podmanTest.Podman([]string{"pod", "inspect", "--format", "{{.NumContainers}}", session.OutputToString()})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 			Expect(session.OutputToString()).Should((Equal("0")))
 		})
 	}
diff --git a/test/e2e/pod_initcontainers_test.go b/test/e2e/pod_initcontainers_test.go
index 9892d3abaa..365416085f 100644
--- a/test/e2e/pod_initcontainers_test.go
+++ b/test/e2e/pod_initcontainers_test.go
@@ -29,19 +29,19 @@ var _ = Describe("Podman init containers", func() {
 		// create a pod
 		topPod := podmanTest.Podman([]string{"create", "-t", "--pod", "new:foobar", ALPINE, "top"})
 		topPod.WaitWithDefaultTimeout()
-		Expect(topPod).Should(Exit(0))
+		Expect(topPod).Should(ExitCleanly())
 		// add an init container
 		session := podmanTest.Podman([]string{"create", "--init-ctr", "always", "--pod", "foobar", ALPINE, "date"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		// start a pod
 		start := podmanTest.Podman([]string{"pod", "start", "foobar"})
 		start.WaitWithDefaultTimeout()
-		Expect(start).Should(Exit(0))
+		Expect(start).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"pod", "inspect", "foobar"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		data := inspect.InspectPodToJSON()
 		Expect(data).To(HaveField("State", define.PodStateRunning))
 	})
@@ -50,7 +50,7 @@ var _ = Describe("Podman init containers", func() {
 		// create a running pod
 		topPod := podmanTest.Podman([]string{"run", "-dt", "--pod", "new:foobar", ALPINE, "top"})
 		topPod.WaitWithDefaultTimeout()
-		Expect(topPod).Should(Exit(0))
+		Expect(topPod).Should(ExitCleanly())
 		// adding init-ctr to running pod should fail
 		session := podmanTest.Podman([]string{"create", "--init-ctr", "always", "--pod", "foobar", ALPINE, "date"})
 		session.WaitWithDefaultTimeout()
@@ -62,16 +62,16 @@ var _ = Describe("Podman init containers", func() {
 		content := RandomString(16)
 		session := podmanTest.Podman([]string{"create", "--init-ctr", "always", "--pod", "new:foobar", ALPINE, "bin/sh", "-c", fmt.Sprintf("echo %s > %s", content, filename)})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		verify := podmanTest.Podman([]string{"create", "--pod", "foobar", "-t", ALPINE, "top"})
 		verify.WaitWithDefaultTimeout()
-		Expect(verify).Should(Exit(0))
+		Expect(verify).Should(ExitCleanly())
 		start := podmanTest.Podman([]string{"pod", "start", "foobar"})
 		start.WaitWithDefaultTimeout()
-		Expect(start).Should(Exit(0))
+		Expect(start).Should(ExitCleanly())
 		checkLog := podmanTest.Podman([]string{"exec", verify.OutputToString(), "cat", filename})
 		checkLog.WaitWithDefaultTimeout()
-		Expect(checkLog).Should(Exit(0))
+		Expect(checkLog).Should(ExitCleanly())
 		Expect(checkLog.OutputToString()).To(Equal(content))
 	})
 
@@ -81,13 +81,13 @@ var _ = Describe("Podman init containers", func() {
 		session := podmanTest.Podman([]string{"create", "--init-ctr", "once", "--pod", "new:foobar", ALPINE, "bin/sh", "-c", fmt.Sprintf("echo %s > %s", content, filename)})
 		session.WaitWithDefaultTimeout()
 		initContainerID := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		verify := podmanTest.Podman([]string{"create", "--pod", "foobar", "-t", ALPINE, "top"})
 		verify.WaitWithDefaultTimeout()
-		Expect(verify).Should(Exit(0))
+		Expect(verify).Should(ExitCleanly())
 		start := podmanTest.Podman([]string{"pod", "start", "foobar"})
 		start.WaitWithDefaultTimeout()
-		Expect(start).Should(Exit(0))
+		Expect(start).Should(ExitCleanly())
 		check := podmanTest.Podman([]string{"container", "exists", initContainerID})
 		check.WaitWithDefaultTimeout()
 		// Container was rm'd
@@ -96,10 +96,10 @@ var _ = Describe("Podman init containers", func() {
 		// Let's double check with a stop and start
 		stopPod := podmanTest.Podman([]string{"pod", "stop", "foobar"})
 		stopPod.WaitWithDefaultTimeout()
-		Expect(stopPod).Should(Exit(0))
+		Expect(stopPod).Should(ExitCleanly())
 		startPod := podmanTest.Podman([]string{"pod", "start", "foobar"})
 		startPod.WaitWithDefaultTimeout()
-		Expect(startPod).Should(Exit(0))
+		Expect(startPod).Should(ExitCleanly())
 
 		// Because no init was run, the file should not even exist
 		doubleCheck := podmanTest.Podman([]string{"exec", verify.OutputToString(), "cat", filename})
@@ -114,32 +114,32 @@ var _ = Describe("Podman init containers", func() {
 		// Write the date to a file
 		session := podmanTest.Podman([]string{"create", "--init-ctr", "always", "--pod", "new:foobar", fedoraMinimal, "bin/sh", "-c", "date +%T.%N > " + filename})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		verify := podmanTest.Podman([]string{"create", "--pod", "foobar", "-t", ALPINE, "top"})
 		verify.WaitWithDefaultTimeout()
-		Expect(verify).Should(Exit(0))
+		Expect(verify).Should(ExitCleanly())
 		start := podmanTest.Podman([]string{"pod", "start", "foobar"})
 		start.WaitWithDefaultTimeout()
-		Expect(start).Should(Exit(0))
+		Expect(start).Should(ExitCleanly())
 
 		// capture the date written
 		checkLog := podmanTest.Podman([]string{"exec", verify.OutputToString(), "cat", filename})
 		checkLog.WaitWithDefaultTimeout()
 		firstResult := checkLog.OutputToString()
-		Expect(checkLog).Should(Exit(0))
+		Expect(checkLog).Should(ExitCleanly())
 
 		// Stop and start the pod
 		stopPod := podmanTest.Podman([]string{"pod", "stop", "foobar"})
 		stopPod.WaitWithDefaultTimeout()
-		Expect(stopPod).Should(Exit(0))
+		Expect(stopPod).Should(ExitCleanly())
 		startPod := podmanTest.Podman([]string{"pod", "start", "foobar"})
 		startPod.WaitWithDefaultTimeout()
-		Expect(startPod).Should(Exit(0))
+		Expect(startPod).Should(ExitCleanly())
 
 		// Check the file again with exec
 		secondCheckLog := podmanTest.Podman([]string{"exec", verify.OutputToString(), "cat", filename})
 		secondCheckLog.WaitWithDefaultTimeout()
-		Expect(secondCheckLog).Should(Exit(0))
+		Expect(secondCheckLog).Should(ExitCleanly())
 
 		// Dates should not match
 		Expect(firstResult).ToNot(Equal(secondCheckLog.OutputToString()))
diff --git a/test/e2e/pod_inspect_test.go b/test/e2e/pod_inspect_test.go
index 60d7de17cd..1663f37fd4 100644
--- a/test/e2e/pod_inspect_test.go
+++ b/test/e2e/pod_inspect_test.go
@@ -7,7 +7,6 @@ import (
 	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("Podman pod inspect", func() {
@@ -24,15 +23,15 @@ var _ = Describe("Podman pod inspect", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"pod", "inspect", podid})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(BeValidJSON())
 		podData := inspect.InspectPodToJSON()
 		Expect(podData).To(HaveField("ID", podid))
@@ -45,13 +44,13 @@ var _ = Describe("Podman pod inspect", func() {
 		// Create the pod.
 		session := podmanTest.Podman(createCommand)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Inspect the pod and make sure that the create command is
 		// exactly how we created the pod.
 		inspect := podmanTest.Podman([]string{"pod", "inspect", podName})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(BeValidJSON())
 		podData := inspect.InspectPodToJSON()
 		// Let's get the last len(createCommand) items in the command.
@@ -64,11 +63,11 @@ var _ = Describe("Podman pod inspect", func() {
 		podName := "testPod"
 		create := podmanTest.Podman([]string{"pod", "create", "--name", podName, "-p", "8383:80"})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		inspectOut := podmanTest.Podman([]string{"pod", "inspect", podName})
 		inspectOut.WaitWithDefaultTimeout()
-		Expect(inspectOut).Should(Exit(0))
+		Expect(inspectOut).Should(ExitCleanly())
 
 		inspectJSON := new(define.InspectPodData)
 		err := json.Unmarshal(inspectOut.Out.Contents(), inspectJSON)
@@ -84,15 +83,15 @@ var _ = Describe("Podman pod inspect", func() {
 		macAddr := "42:43:44:00:00:01"
 		create := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--mac-address", macAddr})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		create = podmanTest.Podman([]string{"run", "-d", "--pod", podName, ALPINE, "top"})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		inspectOut := podmanTest.Podman([]string{"pod", "inspect", podName})
 		inspectOut.WaitWithDefaultTimeout()
-		Expect(inspectOut).Should(Exit(0))
+		Expect(inspectOut).Should(ExitCleanly())
 
 		Expect(inspectOut.OutputToString()).To(ContainSubstring(macAddr))
 	})
@@ -106,7 +105,7 @@ var _ = Describe("Podman pod inspect", func() {
 
 		inspect := podmanTest.Podman([]string{"pod", "inspect", podid1, podid2})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(BeValidJSON())
 		podData := inspect.InspectPodArrToJSON()
 		Expect(podData).To(HaveLen(2))
diff --git a/test/e2e/pod_kill_test.go b/test/e2e/pod_kill_test.go
index b8c529f656..1df19462e7 100644
--- a/test/e2e/pod_kill_test.go
+++ b/test/e2e/pod_kill_test.go
@@ -21,15 +21,15 @@ var _ = Describe("Podman pod kill", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "kill", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
@@ -39,11 +39,11 @@ var _ = Describe("Podman pod kill", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "kill", "-s", "9", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
@@ -53,11 +53,11 @@ var _ = Describe("Podman pod kill", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "kill", "test1"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
@@ -67,7 +67,7 @@ var _ = Describe("Podman pod kill", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "kill", "-s", "bogus", "test1"})
 		result.WaitWithDefaultTimeout()
@@ -81,24 +81,24 @@ var _ = Describe("Podman pod kill", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, podid2 := podmanTest.CreatePod(nil)
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.RunTopContainerInPod("", podid2)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podid2)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		if !IsRemote() {
 			podid2 = "-l"
 		}
 		result := podmanTest.Podman([]string{"pod", "kill", podid2})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 	})
 
@@ -109,23 +109,23 @@ var _ = Describe("Podman pod kill", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, podid2 := podmanTest.CreatePod(nil)
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.RunTopContainerInPod("", podid2)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "kill", "-a"})
 		result.WaitWithDefaultTimeout()
 		GinkgoWriter.Println(result.OutputToString(), result.ErrorToString())
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 })
diff --git a/test/e2e/pod_pause_test.go b/test/e2e/pod_pause_test.go
index 294365a204..b3d918d895 100644
--- a/test/e2e/pod_pause_test.go
+++ b/test/e2e/pod_pause_test.go
@@ -4,7 +4,6 @@ import (
 	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("Podman pod pause", func() {
@@ -32,7 +31,7 @@ var _ = Describe("Podman pod pause", func() {
 
 		result := podmanTest.Podman([]string{"pod", "pause", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("pause a running pod by id", func() {
@@ -41,12 +40,12 @@ var _ = Describe("Podman pod pause", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "pause", podid})
 		result.WaitWithDefaultTimeout()
 
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 		Expect(podmanTest.GetContainerStatus()).To(ContainSubstring(pausedState))
 
@@ -61,18 +60,18 @@ var _ = Describe("Podman pod pause", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "pause", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).Should(HaveLen(1))
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 		Expect(podmanTest.GetContainerStatus()).To(Equal(pausedState))
 
 		result = podmanTest.Podman([]string{"pod", "unpause", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).Should(HaveLen(1))
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 	})
@@ -83,18 +82,18 @@ var _ = Describe("Podman pod pause", func() {
 
 		session := podmanTest.RunTopContainerInPod("", "test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "pause", "test1"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).Should(HaveLen(1))
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 		Expect(podmanTest.GetContainerStatus()).To(Equal(pausedState))
 
 		result = podmanTest.Podman([]string{"pod", "unpause", "test1"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).Should(HaveLen(1))
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 	})
@@ -107,21 +106,21 @@ var _ = Describe("Podman pod pause", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid1)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.RunTopContainerInPod("", podid2)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "pause", podid1})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).Should(HaveLen(1))
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 		Expect(podmanTest.GetContainerStatus()).To(ContainSubstring(pausedState))
 
 		result = podmanTest.Podman([]string{"pod", "unpause", "--all"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).Should(HaveLen(1))
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2))
 	})
diff --git a/test/e2e/pod_pod_namespaces_test.go b/test/e2e/pod_pod_namespaces_test.go
index 109d42b364..63a2508010 100644
--- a/test/e2e/pod_pod_namespaces_test.go
+++ b/test/e2e/pod_pod_namespaces_test.go
@@ -1,9 +1,9 @@
 package integration
 
 import (
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("Podman pod create", func() {
@@ -11,20 +11,20 @@ var _ = Describe("Podman pod create", func() {
 	It("podman pod container share Namespaces", func() {
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", podID, "-d", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{.Namespaces.IPC}} {{.Namespaces.UTS}} {{.Namespaces.NET}}"})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		outputArray := check.OutputToStringArray()
 		Expect(outputArray).To(HaveLen(2))
 
@@ -38,39 +38,39 @@ var _ = Describe("Podman pod create", func() {
 	It("podman pod container share ipc && /dev/shm ", func() {
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--rm", "--pod", podID, ALPINE, "touch", "/dev/shm/test"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--rm", "--pod", podID, ALPINE, "ls", "/dev/shm/test"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman pod container dontshare PIDNS", func() {
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podID := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", podID, "-d", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		check := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{.Namespaces.PIDNS}}"})
 		check.WaitWithDefaultTimeout()
-		Expect(check).Should(Exit(0))
+		Expect(check).Should(ExitCleanly())
 		outputArray := check.OutputToStringArray()
 		Expect(outputArray).To(HaveLen(2))
 
diff --git a/test/e2e/pod_prune_test.go b/test/e2e/pod_prune_test.go
index f5043de815..a827ed7458 100644
--- a/test/e2e/pod_prune_test.go
+++ b/test/e2e/pod_prune_test.go
@@ -1,9 +1,9 @@
 package integration
 
 import (
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("Podman pod prune", func() {
@@ -14,7 +14,7 @@ var _ = Describe("Podman pod prune", func() {
 
 		result := podmanTest.Podman([]string{"pod", "prune", "--force"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman pod prune doesn't remove a pod with a running container", func() {
@@ -23,11 +23,11 @@ var _ = Describe("Podman pod prune", func() {
 
 		ec2 := podmanTest.RunTopContainerInPod("", podid)
 		ec2.WaitWithDefaultTimeout()
-		Expect(ec2).Should(Exit(0))
+		Expect(ec2).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "prune", "-f"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		result = podmanTest.Podman([]string{"ps", "-qa"})
 		result.WaitWithDefaultTimeout()
@@ -43,7 +43,7 @@ var _ = Describe("Podman pod prune", func() {
 
 		result := podmanTest.Podman([]string{"pod", "prune", "-f"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		result = podmanTest.Podman([]string{"ps", "-qa"})
 		result.WaitWithDefaultTimeout()
diff --git a/test/e2e/pod_ps_test.go b/test/e2e/pod_ps_test.go
index dea23ee55f..9d8515d5ac 100644
--- a/test/e2e/pod_ps_test.go
+++ b/test/e2e/pod_ps_test.go
@@ -8,7 +8,6 @@ import (
 	"github.com/containers/storage/pkg/stringid"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("Podman ps", func() {
@@ -16,7 +15,7 @@ var _ = Describe("Podman ps", func() {
 	It("podman pod ps no pods", func() {
 		session := podmanTest.Podman([]string{"pod", "ps"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman pod ps default", func() {
@@ -25,11 +24,11 @@ var _ = Describe("Podman ps", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "ps"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 	})
 
@@ -42,7 +41,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"pod", "ps", "-q"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).To(Exit(0))
+		Expect(result).To(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 		Expect(podid).To(ContainSubstring(result.OutputToStringArray()[0]))
 	})
@@ -56,7 +55,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 		Expect(podid).To(Equal(result.OutputToStringArray()[0]))
 	})
@@ -71,7 +70,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--latest"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(ContainSubstring(podid2))
 		Expect(result.OutputToString()).To(Not(ContainSubstring(podid1)))
 	})
@@ -82,7 +81,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"pod", "ps", "--filter", fmt.Sprintf("id=%s", podid)})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman pod ps --filter until", func() {
@@ -92,17 +91,17 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"pod", "ps", "--filter", "until=50"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(Not(ContainSubstring(name)))
 
 		result = podmanTest.Podman([]string{"pod", "ps", "--filter", "until=5000000000"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(ContainSubstring(name))
 
 		result = podmanTest.Podman([]string{"pod", "ps", "--filter", "label=test=with,comma"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(ContainSubstring(name))
 	})
 
@@ -114,14 +113,14 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "name=mypod"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		output := result.OutputToStringArray()
 		Expect(output).To(HaveLen(2))
 
 		result = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "name=mypod$"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		output = result.OutputToStringArray()
 		Expect(output).To(HaveLen(1))
@@ -148,7 +147,7 @@ var _ = Describe("Podman ps", func() {
 		session := podmanTest.Podman([]string{"pod", "ps", "--sort=name", "--format", "{{.Name}}"})
 
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		sortedArr := session.OutputToStringArray()
 
@@ -162,14 +161,14 @@ var _ = Describe("Podman ps", func() {
 
 		session := podmanTest.RunTopContainerInPod("test1", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, _ = podmanTest.RunLsContainerInPod("test2", podid)
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.Podman([]string{"pod", "ps", "--format={{.ContainerNames}}", "--ctr-names"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("test1"))
 		Expect(session.OutputToString()).To(ContainSubstring("test2"))
 	})
@@ -180,7 +179,7 @@ var _ = Describe("Podman ps", func() {
 
 		session := podmanTest.RunTopContainerInPod("test1", podid1)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec2, podid2 := podmanTest.CreatePod(nil)
 		Expect(ec2).To(Equal(0))
@@ -190,25 +189,25 @@ var _ = Describe("Podman ps", func() {
 
 		session = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "ctr-names=test1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podid1))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid2)))
 
 		session = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "ctr-names=test", "--filter", "ctr-status=running"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podid1))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid2)))
 
 		session = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", fmt.Sprintf("ctr-ids=%s", cid)})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podid2))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid1)))
 
 		session = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "ctr-ids=" + cid[:40], "--filter", "ctr-ids=" + cid + "$"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podid2))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid1)))
 
@@ -217,60 +216,60 @@ var _ = Describe("Podman ps", func() {
 
 		session = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "ctr-number=1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podid1))
 		Expect(session.OutputToString()).To(ContainSubstring(podid2))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid3)))
 
 		session = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "ctr-number=1", "--filter", "ctr-number=0"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podid1))
 		Expect(session.OutputToString()).To(ContainSubstring(podid2))
 		Expect(session.OutputToString()).To(ContainSubstring(podid3))
 
 		session = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "ctr-status=running"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podid1))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid2)))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid3)))
 
 		session = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "ctr-status=exited"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podid2))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid1)))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid3)))
 
 		session = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "ctr-status=exited", "--filter", "ctr-status=running"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podid1))
 		Expect(session.OutputToString()).To(ContainSubstring(podid2))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid3)))
 
 		session = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc", "--filter", "ctr-status=created"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(BeEmpty())
 	})
 
 	It("podman pod ps filter labels", func() {
 		s, _, podid1 := podmanTest.CreatePod(nil)
-		Expect(s).To(Exit(0))
+		Expect(s).To(ExitCleanly())
 
 		s, _, podid2 := podmanTest.CreatePod(map[string][]string{
 			"--label": {"app=myapp", "io.podman.test.key=irrelevant-value"},
 		})
-		Expect(s).To(Exit(0))
+		Expect(s).To(ExitCleanly())
 
 		s, _, podid3 := podmanTest.CreatePod(map[string][]string{"--label": {"app=test"}})
-		Expect(s).To(Exit(0))
+		Expect(s).To(ExitCleanly())
 
 		session := podmanTest.Podman([]string{"pod", "ps", "--no-trunc", "--filter", "label=app", "--filter", "label=app=myapp"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).To(Exit(0))
+		Expect(session).To(ExitCleanly())
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid1)))
 		Expect(session.OutputToString()).To(ContainSubstring(podid2))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podid3)))
@@ -280,22 +279,22 @@ var _ = Describe("Podman ps", func() {
 		net := stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", net})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(net)
 
 		session = podmanTest.Podman([]string{"pod", "create", "--network", net})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podWithNet := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podWithoutNet := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "ps", "--no-trunc", "--filter", "network=" + net})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podWithNet))
 		Expect(session.OutputToString()).To(Not(ContainSubstring(podWithoutNet)))
 	})
@@ -303,11 +302,11 @@ var _ = Describe("Podman ps", func() {
 	It("podman pod ps --format networks", func() {
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "ps", "--format", "{{ .Networks }}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		if isRootless() {
 			// rootless container don't have a network by default
 			Expect(session.OutputToString()).To(Equal(""))
@@ -319,22 +318,22 @@ var _ = Describe("Podman ps", func() {
 		net1 := stringid.GenerateRandomID()
 		session = podmanTest.Podman([]string{"network", "create", net1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(net1)
 		net2 := stringid.GenerateRandomID()
 		session = podmanTest.Podman([]string{"network", "create", net2})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(net2)
 
 		session = podmanTest.Podman([]string{"pod", "create", "--network", net1 + "," + net2})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		pid := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "ps", "--format", "{{ .Networks }}", "--filter", "id=" + pid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		// the output is not deterministic so check both possible orders
 		Expect(session.OutputToString()).To(Or(Equal(net1+","+net2), Equal(net2+","+net1)))
 	})
@@ -342,11 +341,11 @@ var _ = Describe("Podman ps", func() {
 	It("pod no infra should ps", func() {
 		session := podmanTest.Podman([]string{"pod", "create", "--infra=false"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		ps := podmanTest.Podman([]string{"pod", "ps"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 
 		infra := podmanTest.Podman([]string{"pod", "ps", "--format", "{{.InfraId}}"})
 		infra.WaitWithDefaultTimeout()
@@ -365,14 +364,14 @@ var _ = Describe("Podman ps", func() {
 
 		session := podmanTest.Podman([]string{"pod", "ps", "--format", "{{.Labels}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("value1"))
 	})
 
 	It("podman pod ps headers", func() {
 		session := podmanTest.Podman([]string{"pod", "ps", "--ctr-ids", "--ctr-names", "--ctr-status", "--ns"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(MatchRegexp(`^POD ID\s+NAME\s+STATUS\s+CREATED\s+INFRA ID\s+IDS\s+NAMES\s+STATUS\s+CGROUP\s+NAMESPACES$`))
 	})
 
diff --git a/test/e2e/pod_restart_test.go b/test/e2e/pod_restart_test.go
index f68e282235..b051bcb68f 100644
--- a/test/e2e/pod_restart_test.go
+++ b/test/e2e/pod_restart_test.go
@@ -1,6 +1,7 @@
 package integration
 
 import (
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
@@ -29,14 +30,14 @@ var _ = Describe("Podman pod restart", func() {
 
 		session := podmanTest.RunTopContainerInPod("test1", "foobar99")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1"})
 		startTime.WaitWithDefaultTimeout()
 
 		session = podmanTest.Podman([]string{"pod", "restart", "foobar99"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1"})
 		restartTime.WaitWithDefaultTimeout()
@@ -49,29 +50,29 @@ var _ = Describe("Podman pod restart", func() {
 
 		session := podmanTest.RunTopContainerInPod("test1", "foobar99")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, _ = podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.RunTopContainerInPod("test2", "foobar100")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("test3", "foobar100")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("test4", "foobar100")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2", "test3", "test4"})
 		startTime.WaitWithDefaultTimeout()
 
 		session = podmanTest.Podman([]string{"pod", "restart", "foobar99", "foobar100"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2", "test3", "test4"})
 		restartTime.WaitWithDefaultTimeout()
@@ -87,21 +88,21 @@ var _ = Describe("Podman pod restart", func() {
 
 		session := podmanTest.RunTopContainerInPod("test1", "foobar99")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, _ = podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.RunTopContainerInPod("test2", "foobar100")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
 		startTime.WaitWithDefaultTimeout()
 
 		session = podmanTest.Podman([]string{"pod", "restart", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
 		restartTime.WaitWithDefaultTimeout()
@@ -115,14 +116,14 @@ var _ = Describe("Podman pod restart", func() {
 
 		session := podmanTest.RunTopContainerInPod("test1", "foobar99")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, _ = podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.RunTopContainerInPod("test2", "foobar100")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
 		startTime.WaitWithDefaultTimeout()
@@ -133,7 +134,7 @@ var _ = Describe("Podman pod restart", func() {
 		}
 		session = podmanTest.Podman([]string{"pod", "restart", podid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
 		restartTime.WaitWithDefaultTimeout()
@@ -147,7 +148,7 @@ var _ = Describe("Podman pod restart", func() {
 
 		session := podmanTest.RunTopContainerInPod("", "foobar99")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "restart", podid1, "doesnotexist"})
 		session.WaitWithDefaultTimeout()
diff --git a/test/e2e/pod_rm_test.go b/test/e2e/pod_rm_test.go
index d06743ae10..0fd19057f3 100644
--- a/test/e2e/pod_rm_test.go
+++ b/test/e2e/pod_rm_test.go
@@ -22,7 +22,7 @@ var _ = Describe("Podman pod rm", func() {
 
 		result := podmanTest.Podman([]string{"pod", "rm", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		// Also check that we don't leak cgroups
 		err := filepath.WalkDir("/sys/fs/cgroup", func(path string, d fs.DirEntry, err error) error {
@@ -55,11 +55,11 @@ var _ = Describe("Podman pod rm", func() {
 		}
 		result := podmanTest.Podman([]string{"pod", "rm", latest})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		result = podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(ContainSubstring(podid))
 		Expect(result.OutputToString()).To(Not(ContainSubstring(podid2)))
 	})
@@ -73,7 +73,7 @@ var _ = Describe("Podman pod rm", func() {
 
 		result := podmanTest.Podman([]string{"pod", "rm", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		result = podmanTest.Podman([]string{"ps", "-qa"})
 		result.WaitWithDefaultTimeout()
@@ -86,11 +86,11 @@ var _ = Describe("Podman pod rm", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "rm", "-t", "0", "-f", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		result = podmanTest.Podman([]string{"ps", "-q"})
 		result.WaitWithDefaultTimeout()
@@ -108,7 +108,7 @@ var _ = Describe("Podman pod rm", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid1)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podmanTest.WaitForContainer()
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 		GinkgoWriter.Printf("Started container running in one pod")
@@ -146,22 +146,22 @@ var _ = Describe("Podman pod rm", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid1)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", "--pod", podid1, ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, _ = podmanTest.RunLsContainerInPod("", podid2)
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.RunTopContainerInPod("", podid2)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "rm", "-t", "0", "-fa"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		result = podmanTest.Podman([]string{"ps", "-q"})
 		result.WaitWithDefaultTimeout()
@@ -185,7 +185,7 @@ var _ = Describe("Podman pod rm", func() {
 
 		session := podmanTest.RunTopContainerInPod("test1", podid1)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "rm", "bogus", "test1"})
 		session.WaitWithDefaultTimeout()
@@ -203,15 +203,15 @@ var _ = Describe("Podman pod rm", func() {
 
 		session := podmanTest.RunTopContainerInPod("test1", podid1)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "rm", "-t", "0", "--force", "--ignore", "bogus", "test1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "rm", "--ignore", "test1", "bogus"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman pod start/remove single pod via --pod-id-file", func() {
@@ -223,21 +223,21 @@ var _ = Describe("Podman pod rm", func() {
 		// Create a pod with --pod-id-file.
 		session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--pod-id-file", tmpFile})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Create container inside the pod.
 		session = podmanTest.Podman([]string{"create", "--pod", podName, ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "start", "--pod-id-file", tmpFile})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2)) // infra+top
 
 		session = podmanTest.Podman([]string{"pod", "rm", "-t", "0", "--pod-id-file", tmpFile, "--force"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
@@ -251,12 +251,12 @@ var _ = Describe("Podman pod rm", func() {
 			// Create a pod with --pod-id-file.
 			session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--pod-id-file", tmpFile})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 
 			// Create container inside the pod.
 			session = podmanTest.Podman([]string{"create", "--pod", podName, ALPINE, "top"})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 
 			// Append the id files along with the command.
 			podIDFiles = append(podIDFiles, "--pod-id-file")
@@ -267,14 +267,14 @@ var _ = Describe("Podman pod rm", func() {
 		cmd = append(cmd, podIDFiles...)
 		session := podmanTest.Podman(cmd)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(20)) // 10*(infra+top)
 
 		cmd = []string{"pod", "rm", "--time=0", "--force"}
 		cmd = append(cmd, podIDFiles...)
 		session = podmanTest.Podman(cmd)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
@@ -284,15 +284,15 @@ var _ = Describe("Podman pod rm", func() {
 
 		session := podmanTest.Podman([]string{"run", "--pod", podid, ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--pod", podid, ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "rm", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman pod rm pod with infra container and running container", func() {
@@ -301,24 +301,24 @@ var _ = Describe("Podman pod rm", func() {
 
 		ctrAndPod := podmanTest.Podman([]string{"run", "-d", "--pod", fmt.Sprintf("new:%s", podName), "--name", ctrName, ALPINE, "top"})
 		ctrAndPod.WaitWithDefaultTimeout()
-		Expect(ctrAndPod).Should(Exit(0))
+		Expect(ctrAndPod).Should(ExitCleanly())
 
 		removePod := podmanTest.Podman([]string{"pod", "rm", "-a"})
 		removePod.WaitWithDefaultTimeout()
-		Expect(removePod).Should(Not(Exit(0)))
+		Expect(removePod).Should(Not(ExitCleanly()))
 
 		ps := podmanTest.Podman([]string{"pod", "ps"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		Expect(ps.OutputToString()).To(ContainSubstring(podName))
 
 		removePodForce := podmanTest.Podman([]string{"pod", "rm", "-af"})
 		removePodForce.WaitWithDefaultTimeout()
-		Expect(removePodForce).Should(Exit(0))
+		Expect(removePodForce).Should(ExitCleanly())
 
 		ps2 := podmanTest.Podman([]string{"pod", "ps"})
 		ps2.WaitWithDefaultTimeout()
-		Expect(ps2).Should(Exit(0))
+		Expect(ps2).Should(ExitCleanly())
 		Expect(ps2.OutputToString()).To(Not(ContainSubstring(podName)))
 	})
 })
diff --git a/test/e2e/pod_start_test.go b/test/e2e/pod_start_test.go
index dd4be832dd..6030bac7bb 100644
--- a/test/e2e/pod_start_test.go
+++ b/test/e2e/pod_start_test.go
@@ -35,11 +35,11 @@ var _ = Describe("Podman pod start", func() {
 
 		session := podmanTest.Podman([]string{"create", "--pod", "foobar99", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "start", "foobar99"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman pod start multiple pods", func() {
@@ -48,18 +48,18 @@ var _ = Describe("Podman pod start", func() {
 
 		session := podmanTest.Podman([]string{"create", "--pod", "foobar99", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec2, podid2 := podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
 		Expect(ec2).To(Equal(0))
 
 		session = podmanTest.Podman([]string{"create", "--pod", "foobar100", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "start", podid1, podid2})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2))
 	})
 
@@ -71,22 +71,22 @@ var _ = Describe("Podman pod start", func() {
 			"--name":    {podName[0]},
 			"--publish": {"127.0.0.1:8083:80"},
 		})
-		Expect(pod).To(Exit(0))
+		Expect(pod).To(ExitCleanly())
 
 		session := podmanTest.Podman([]string{"create", "--pod", podName[0], ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).To(Exit(0))
+		Expect(session).To(ExitCleanly())
 
 		pod, _, podid2 := podmanTest.CreatePod(map[string][]string{
 			"--infra":   {"true"},
 			"--name":    {podName[1]},
 			"--publish": {"127.0.0.1:8083:80"},
 		})
-		Expect(pod).To(Exit(0))
+		Expect(pod).To(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", "--pod", podName[1], ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).To(Exit(0))
+		Expect(session).To(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "start", podid1, podid2})
 		session.WaitWithDefaultTimeout()
@@ -99,18 +99,18 @@ var _ = Describe("Podman pod start", func() {
 
 		session := podmanTest.Podman([]string{"create", "--pod", "foobar99", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, _ = podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.Podman([]string{"create", "--pod", "foobar100", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "start", "--all"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2))
 	})
 
@@ -120,14 +120,14 @@ var _ = Describe("Podman pod start", func() {
 
 		session := podmanTest.Podman([]string{"create", "--pod", "foobar99", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, _ = podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.Podman([]string{"create", "--pod", "foobar100", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		podid := "--latest"
 		if IsRemote() {
@@ -135,7 +135,7 @@ var _ = Describe("Podman pod start", func() {
 		}
 		session = podmanTest.Podman([]string{"pod", "start", podid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 	})
 
@@ -145,7 +145,7 @@ var _ = Describe("Podman pod start", func() {
 
 		session := podmanTest.Podman([]string{"create", "--pod", "foobar99", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "start", podid, "doesnotexist"})
 		session.WaitWithDefaultTimeout()
@@ -161,16 +161,16 @@ var _ = Describe("Podman pod start", func() {
 		// Create a pod with --pod-id-file.
 		session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--pod-id-file", tmpFile})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Create container inside the pod.
 		session = podmanTest.Podman([]string{"create", "--pod", podName, ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "start", "--pod-id-file", tmpFile})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2)) // infra+top
 	})
 
@@ -184,12 +184,12 @@ var _ = Describe("Podman pod start", func() {
 			// Create a pod with --pod-id-file.
 			session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--pod-id-file", tmpFile})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 
 			// Create container inside the pod.
 			session = podmanTest.Podman([]string{"create", "--pod", podName, ALPINE, "top"})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 
 			// Append the id files along with the command.
 			podIDFiles = append(podIDFiles, "--pod-id-file")
@@ -200,7 +200,7 @@ var _ = Describe("Podman pod start", func() {
 		cmd = append(cmd, podIDFiles...)
 		session := podmanTest.Podman(cmd)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(20)) // 10*(infra+top)
 	})
 
@@ -212,11 +212,11 @@ var _ = Describe("Podman pod start", func() {
 		// Create a pod with --infra-conmon-pid.
 		session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--infra-conmon-pidfile", tmpFile})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "start", podName})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1)) // infra
 
 		readFirstLine := func(path string) string {
diff --git a/test/e2e/pod_stats_test.go b/test/e2e/pod_stats_test.go
index 3d5d02da5f..b872c95657 100644
--- a/test/e2e/pod_stats_test.go
+++ b/test/e2e/pod_stats_test.go
@@ -19,7 +19,7 @@ var _ = Describe("Podman pod stats", func() {
 	It("podman pod stats should run with no pods", func() {
 		session := podmanTest.Podman([]string{"pod", "stats", "--no-stream"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman pod stats with a bogus pod", func() {
@@ -34,15 +34,15 @@ var _ = Describe("Podman pod stats", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		stats := podmanTest.Podman([]string{"pod", "stats", "--no-stream", podid})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 	})
 
 	It("podman pod stats on a specific running pod with shortID", func() {
@@ -51,15 +51,15 @@ var _ = Describe("Podman pod stats", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		stats := podmanTest.Podman([]string{"pod", "stats", "--no-stream", podid[:5]})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 	})
 
 	It("podman pod stats on a specific running pod with name", func() {
@@ -68,15 +68,15 @@ var _ = Describe("Podman pod stats", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		stats := podmanTest.Podman([]string{"pod", "stats", "--no-stream", "test"})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 	})
 
 	It("podman pod stats on running pods", func() {
@@ -85,15 +85,15 @@ var _ = Describe("Podman pod stats", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		stats := podmanTest.Podman([]string{"pod", "stats", "--no-stream"})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 	})
 
 	It("podman pod stats on all pods", func() {
@@ -102,15 +102,15 @@ var _ = Describe("Podman pod stats", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		stats := podmanTest.Podman([]string{"pod", "stats", "--no-stream", "-a"})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 	})
 
 	It("podman pod stats with json output", func() {
@@ -119,15 +119,15 @@ var _ = Describe("Podman pod stats", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		stats := podmanTest.Podman([]string{"pod", "stats", "--format", "json", "--no-stream", "-a"})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 		Expect(stats.OutputToString()).To(BeValidJSON())
 	})
 	It("podman pod stats with GO template", func() {
@@ -136,10 +136,10 @@ var _ = Describe("Podman pod stats", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		stats := podmanTest.Podman([]string{"pod", "stats", "-a", "--no-reset", "--no-stream", "--format", "table {{.CID}} {{.Pod}} {{.Mem}} {{.MemUsage}} {{.CPU}} {{.NetIO}} {{.BlockIO}} {{.PIDS}} {{.Pod}}"})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).To(Exit(0))
+		Expect(stats).To(ExitCleanly())
 	})
 
 	It("podman pod stats with invalid GO template", func() {
@@ -148,7 +148,7 @@ var _ = Describe("Podman pod stats", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		stats := podmanTest.Podman([]string{"pod", "stats", "-a", "--no-reset", "--no-stream", "--format", "\"table {{.ID}} \""})
 		stats.WaitWithDefaultTimeout()
 		Expect(stats).To(ExitWithError())
@@ -159,15 +159,15 @@ var _ = Describe("Podman pod stats", func() {
 		podName := "testPod"
 		podCreate := podmanTest.Podman([]string{"pod", "create", "--net=host", "--name", podName})
 		podCreate.WaitWithDefaultTimeout()
-		Expect(podCreate).Should(Exit(0))
+		Expect(podCreate).Should(ExitCleanly())
 
 		ctrRun := podmanTest.Podman([]string{"run", "-d", "--pod", podName, ALPINE, "top"})
 		ctrRun.WaitWithDefaultTimeout()
-		Expect(ctrRun).Should(Exit(0))
+		Expect(ctrRun).Should(ExitCleanly())
 
 		stats := podmanTest.Podman([]string{"pod", "stats", "--format", "json", "--no-stream", podName})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 		Expect(stats.OutputToString()).To(BeValidJSON())
 	})
 })
diff --git a/test/e2e/pod_stop_test.go b/test/e2e/pod_stop_test.go
index c94b7fa3b6..6901ee26a2 100644
--- a/test/e2e/pod_stop_test.go
+++ b/test/e2e/pod_stop_test.go
@@ -1,6 +1,7 @@
 package integration
 
 import (
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
@@ -18,7 +19,7 @@ var _ = Describe("Podman pod stop", func() {
 
 		session := podmanTest.Podman([]string{"pod", "stop", "--ignore", "123"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman stop bogus pod and a running pod", func() {
@@ -27,7 +28,7 @@ var _ = Describe("Podman pod stop", func() {
 
 		session := podmanTest.RunTopContainerInPod("test1", podid1)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", "bogus", "test1"})
 		session.WaitWithDefaultTimeout()
@@ -41,15 +42,15 @@ var _ = Describe("Podman pod stop", func() {
 
 		session := podmanTest.RunTopContainerInPod("test1", podid1)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", "--ignore", "bogus", "test1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", "-t", "-1", "--ignore", "test1", "bogus"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman pod stop single empty pod", func() {
@@ -58,7 +59,7 @@ var _ = Describe("Podman pod stop", func() {
 
 		session := podmanTest.Podman([]string{"pod", "stop", podid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman pod stop single pod by name", func() {
@@ -67,11 +68,11 @@ var _ = Describe("Podman pod stop", func() {
 
 		session := podmanTest.RunTopContainerInPod("", "foobar99")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", "foobar99"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
@@ -81,18 +82,18 @@ var _ = Describe("Podman pod stop", func() {
 
 		session := podmanTest.RunTopContainerInPod("", "foobar99")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec2, podid2 := podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
 		Expect(ec2).To(Equal(0))
 
 		session = podmanTest.RunTopContainerInPod("", "foobar100")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", podid1, podid2})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
@@ -102,18 +103,18 @@ var _ = Describe("Podman pod stop", func() {
 
 		session := podmanTest.RunTopContainerInPod("", "foobar99")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, _ = podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.RunTopContainerInPod("", "foobar100")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", "--all"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
@@ -123,14 +124,14 @@ var _ = Describe("Podman pod stop", func() {
 
 		session := podmanTest.RunTopContainerInPod("", "foobar99")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, _ = podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
 		Expect(ec).To(Equal(0))
 
 		session = podmanTest.RunTopContainerInPod("", "foobar100")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		podid := "--latest"
 		if IsRemote() {
@@ -138,7 +139,7 @@ var _ = Describe("Podman pod stop", func() {
 		}
 		session = podmanTest.Podman([]string{"pod", "stop", podid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 	})
 
@@ -148,7 +149,7 @@ var _ = Describe("Podman pod stop", func() {
 
 		session := podmanTest.RunTopContainerInPod("", "foobar99")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", podid1, "doesnotexist"})
 		session.WaitWithDefaultTimeout()
@@ -164,21 +165,21 @@ var _ = Describe("Podman pod stop", func() {
 		// Create a pod with --pod-id-file.
 		session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--pod-id-file", tmpFile})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Create container inside the pod.
 		session = podmanTest.Podman([]string{"create", "--pod", podName, ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "start", "--pod-id-file", tmpFile})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2)) // infra+top
 
 		session = podmanTest.Podman([]string{"pod", "stop", "--pod-id-file", tmpFile})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
@@ -192,12 +193,12 @@ var _ = Describe("Podman pod stop", func() {
 			// Create a pod with --pod-id-file.
 			session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--pod-id-file", tmpFile})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 
 			// Create container inside the pod.
 			session = podmanTest.Podman([]string{"create", "--pod", podName, ALPINE, "top"})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 
 			// Append the id files along with the command.
 			podIDFiles = append(podIDFiles, "--pod-id-file")
@@ -208,14 +209,14 @@ var _ = Describe("Podman pod stop", func() {
 		cmd = append(cmd, podIDFiles...)
 		session := podmanTest.Podman(cmd)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(20)) // 10*(infra+top)
 
 		cmd = []string{"pod", "stop"}
 		cmd = append(cmd, podIDFiles...)
 		session = podmanTest.Podman(cmd)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 })
diff --git a/test/e2e/pod_top_test.go b/test/e2e/pod_top_test.go
index bde2920191..28befd554f 100644
--- a/test/e2e/pod_top_test.go
+++ b/test/e2e/pod_top_test.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"time"
 
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
@@ -38,14 +39,14 @@ var _ = Describe("Podman top", func() {
 
 		session := podmanTest.Podman([]string{"run", "-d", "--pod", podid, ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		if !IsRemote() {
 			podid = "-l"
 		}
 		result := podmanTest.Podman([]string{"pod", "top", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(len(result.OutputToStringArray())).To(BeNumerically(">", 1))
 	})
 
@@ -55,11 +56,11 @@ var _ = Describe("Podman top", func() {
 
 		session := podmanTest.Podman([]string{"run", "-d", "--pod", podid, ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "top", podid, "pid", "%C", "args"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(len(result.OutputToStringArray())).To(BeNumerically(">", 1))
 	})
 
@@ -69,7 +70,7 @@ var _ = Describe("Podman top", func() {
 
 		session := podmanTest.Podman([]string{"run", "-d", "--pod", podid, ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// We need to pass -eo to force executing ps in the Alpine container.
 		// Alpines stripped down ps(1) is accepting any kind of weird input in
@@ -86,16 +87,16 @@ var _ = Describe("Podman top", func() {
 
 		session := podmanTest.Podman([]string{"run", "-d", "--pod", podid, ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"run", "-d", "--pod", podid, "--pid", fmt.Sprintf("container:%s", cid), ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"pod", "top", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).To(HaveLen(3))
 	})
 
@@ -105,11 +106,11 @@ var _ = Describe("Podman top", func() {
 
 		session := podmanTest.Podman([]string{"run", "-d", "--pod", podid, ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "-d", "--pod", podid, ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		for i := 0; i < 10; i++ {
 			GinkgoWriter.Println("Waiting for containers to be running .... ")
@@ -120,7 +121,7 @@ var _ = Describe("Podman top", func() {
 		}
 		result := podmanTest.Podman([]string{"pod", "top", podid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).To(HaveLen(3))
 	})
 })
diff --git a/test/e2e/port_test.go b/test/e2e/port_test.go
index eab738a753..e6c9e64a5f 100644
--- a/test/e2e/port_test.go
+++ b/test/e2e/port_test.go
@@ -7,7 +7,6 @@ import (
 	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("Podman port", func() {
@@ -26,7 +25,7 @@ var _ = Describe("Podman port", func() {
 
 	It("podman port -l nginx", func() {
 		session, cid := podmanTest.RunNginxWithHealthCheck("test1")
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		if err := podmanTest.RunHealthCheck(cid); err != nil {
 			Fail(err.Error())
@@ -37,14 +36,14 @@ var _ = Describe("Podman port", func() {
 		}
 		result := podmanTest.Podman([]string{"port", cid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		port := strings.Split(result.OutputToStringArray()[0], ":")[1]
 		Expect(result.OutputToStringArray()).To(ContainElement(HavePrefix(fmt.Sprintf("80/tcp -> 0.0.0.0:%s", port))))
 	})
 
 	It("podman container port  -l nginx", func() {
 		session, cid := podmanTest.RunNginxWithHealthCheck("")
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		if err := podmanTest.RunHealthCheck(cid); err != nil {
 			Fail(err.Error())
@@ -55,14 +54,14 @@ var _ = Describe("Podman port", func() {
 		}
 		result := podmanTest.Podman([]string{"container", "port", cid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		port := strings.Split(result.OutputToStringArray()[0], ":")[1]
 		Expect(result.OutputToStringArray()).To(ContainElement(HavePrefix(fmt.Sprintf("80/tcp -> 0.0.0.0:%s", port))))
 	})
 
 	It("podman port -l port nginx", func() {
 		session, cid := podmanTest.RunNginxWithHealthCheck("")
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		if err := podmanTest.RunHealthCheck(cid); err != nil {
 			Fail(err.Error())
@@ -73,14 +72,14 @@ var _ = Describe("Podman port", func() {
 		}
 		result := podmanTest.Podman([]string{"port", cid, "80"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		port := strings.Split(result.OutputToStringArray()[0], ":")[1]
 		Expect(result.OutputToStringArray()).To(ContainElement(HavePrefix(fmt.Sprintf("0.0.0.0:%s", port))))
 	})
 
 	It("podman port -a nginx", func() {
 		session, cid := podmanTest.RunNginxWithHealthCheck("")
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		if err := podmanTest.RunHealthCheck(cid); err != nil {
 			Fail(err.Error())
@@ -88,12 +87,12 @@ var _ = Describe("Podman port", func() {
 
 		result := podmanTest.Podman([]string{"port", "-a"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman port nginx by name", func() {
 		session, cid := podmanTest.RunNginxWithHealthCheck("portcheck")
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		if err := podmanTest.RunHealthCheck(cid); err != nil {
 			Fail(err.Error())
@@ -101,7 +100,7 @@ var _ = Describe("Podman port", func() {
 
 		result := podmanTest.Podman([]string{"port", "portcheck"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).To(ContainElement(HavePrefix("80/tcp -> 0.0.0.0:")))
 	})
 
@@ -114,18 +113,18 @@ var _ = Describe("Podman port", func() {
 
 		setup := podmanTest.Podman([]string{"run", "--name", "test", "-dt", "-p", "5000:5000", "-p", "5001:5001", ALPINE, "top"})
 		setup.WaitWithDefaultTimeout()
-		Expect(setup).Should(Exit(0))
+		Expect(setup).Should(ExitCleanly())
 
 		// Check that the first port was honored
 		result1 := podmanTest.Podman([]string{"port", "test", "5000"})
 		result1.WaitWithDefaultTimeout()
-		Expect(result1).Should(Exit(0))
+		Expect(result1).Should(ExitCleanly())
 		Expect(result1.OutputToStringArray()).To(ContainElement(HavePrefix("0.0.0.0:5000")))
 
 		// Check that the second port was honored
 		result2 := podmanTest.Podman([]string{"port", "test", "5001"})
 		result2.WaitWithDefaultTimeout()
-		Expect(result2).Should(Exit(0))
+		Expect(result2).Should(ExitCleanly())
 		Expect(result2.OutputToStringArray()).To(ContainElement(HavePrefix("0.0.0.0:5001")))
 	})
 })
diff --git a/test/e2e/prune_test.go b/test/e2e/prune_test.go
index 6e7ec4a96c..01e8484785 100644
--- a/test/e2e/prune_test.go
+++ b/test/e2e/prune_test.go
@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
@@ -26,20 +27,20 @@ var _ = Describe("Podman prune", func() {
 	It("podman container prune containers", func() {
 		top := podmanTest.RunTopContainer("")
 		top.WaitWithDefaultTimeout()
-		Expect(top).Should(Exit(0))
+		Expect(top).Should(ExitCleanly())
 
 		top = podmanTest.RunTopContainer("")
 		top.WaitWithDefaultTimeout()
-		Expect(top).Should(Exit(0))
+		Expect(top).Should(ExitCleanly())
 		cid := top.OutputToString()
 
 		stop := podmanTest.Podman([]string{"stop", cid})
 		stop.WaitWithDefaultTimeout()
-		Expect(stop).Should(Exit(0))
+		Expect(stop).Should(ExitCleanly())
 
 		prune := podmanTest.Podman([]string{"container", "prune", "-f"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
 	})
@@ -47,11 +48,11 @@ var _ = Describe("Podman prune", func() {
 	It("podman container prune after create containers", func() {
 		create := podmanTest.Podman([]string{"create", "--name", "test", BB})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		prune := podmanTest.Podman([]string{"container", "prune", "-f"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
 	})
@@ -59,15 +60,15 @@ var _ = Describe("Podman prune", func() {
 	It("podman container prune after create & init containers", func() {
 		create := podmanTest.Podman([]string{"create", "--name", "test", BB})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		init := podmanTest.Podman([]string{"init", "test"})
 		init.WaitWithDefaultTimeout()
-		Expect(init).Should(Exit(0))
+		Expect(init).Should(ExitCleanly())
 
 		prune := podmanTest.Podman([]string{"container", "prune", "-f"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
 	})
@@ -75,21 +76,21 @@ var _ = Describe("Podman prune", func() {
 	It("podman image prune - remove only dangling images", func() {
 		session := podmanTest.Podman([]string{"images", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Not(ContainSubstring("<none>")))
 		numImages := len(session.OutputToStringArray())
 
 		// Since there's no dangling image, none should be removed.
 		session = podmanTest.Podman([]string{"image", "prune", "-f"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(BeEmpty())
 
 		// Let's be extra sure that the same number of images is
 		// reported.
 		session = podmanTest.Podman([]string{"images", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(numImages))
 
 		// Now build an image and untag it.  The (intermediate) images
@@ -97,11 +98,11 @@ var _ = Describe("Podman prune", func() {
 		podmanTest.BuildImage(pruneImage, "alpine_bash:latest", "true")
 		session = podmanTest.Podman([]string{"untag", "alpine_bash:latest"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"images", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("<none>"))
 		numImages = len(session.OutputToStringArray())
 
@@ -109,7 +110,7 @@ var _ = Describe("Podman prune", func() {
 		// remove them.
 		session = podmanTest.Podman([]string{"image", "prune", "-f"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		numPrunedImages := len(session.OutputToStringArray())
 		Expect(numPrunedImages).To(BeNumerically(">=", 1), "numPrunedImages")
 
@@ -117,7 +118,7 @@ var _ = Describe("Podman prune", func() {
 		// been removed.
 		session = podmanTest.Podman([]string{"images", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(numImages - numPrunedImages))
 	})
 
@@ -128,24 +129,24 @@ var _ = Describe("Podman prune", func() {
 
 		session := podmanTest.Podman([]string{"images", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("<none>"))
 
 		// Nothing will be pruned.
 		session = podmanTest.Podman([]string{"image", "prune", "-f"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(BeEmpty())
 
 		// Now the image will be untagged, and its parent images will
 		// be removed recursively.
 		session = podmanTest.Podman([]string{"untag", "empty:scratch"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"image", "prune", "-f"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 	})
 
@@ -154,18 +155,18 @@ var _ = Describe("Podman prune", func() {
 		podmanTest.BuildImage(pruneImage, "alpine_bash:latest", "true")
 		none := podmanTest.Podman([]string{"images", "-a"})
 		none.WaitWithDefaultTimeout()
-		Expect(none).Should(Exit(0))
+		Expect(none).Should(ExitCleanly())
 		hasNone, result := none.GrepString("<none>")
 		Expect(result).To(HaveLen(2))
 		Expect(hasNone).To(BeTrue())
 
 		prune := podmanTest.Podman([]string{"image", "prune", "-f"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		after := podmanTest.Podman([]string{"images", "-a"})
 		after.WaitWithDefaultTimeout()
-		Expect(after).Should(Exit(0))
+		Expect(after).Should(ExitCleanly())
 		hasNoneAfter, result := after.GrepString("<none>")
 		Expect(hasNoneAfter).To(BeTrue())
 		Expect(len(after.OutputToStringArray())).To(BeNumerically(">", 1))
@@ -178,15 +179,15 @@ var _ = Describe("Podman prune", func() {
 
 		images := podmanTest.Podman([]string{"images", "-a"})
 		images.WaitWithDefaultTimeout()
-		Expect(images).Should(Exit(0))
+		Expect(images).Should(ExitCleanly())
 
 		prune := podmanTest.Podman([]string{"image", "prune", "-af"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		images = podmanTest.Podman([]string{"images", "-aq"})
 		images.WaitWithDefaultTimeout()
-		Expect(images).Should(Exit(0))
+		Expect(images).Should(ExitCleanly())
 		// all images are unused, so they all should be deleted!
 		Expect(images.OutputToStringArray()).To(HaveLen(len(CACHE_IMAGES)))
 	})
@@ -197,7 +198,7 @@ var _ = Describe("Podman prune", func() {
 		podmanTest.BuildImage(pruneImage, "alpine_bash:latest", "true")
 		prune := podmanTest.Podman([]string{"system", "prune", "-a", "--force"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		images := podmanTest.Podman([]string{"images", "-aq"})
 		images.WaitWithDefaultTimeout()
@@ -209,33 +210,33 @@ var _ = Describe("Podman prune", func() {
 		useCustomNetworkDir(podmanTest, tempdir)
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podid1 := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podid1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", podid1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		pods := podmanTest.Podman([]string{"pod", "ps"})
 		pods.WaitWithDefaultTimeout()
-		Expect(pods).Should(Exit(0))
+		Expect(pods).Should(ExitCleanly())
 		Expect(pods.OutputToStringArray()).To(HaveLen(3))
 
 		prune := podmanTest.Podman([]string{"system", "prune", "-f"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		pods = podmanTest.Podman([]string{"pod", "ps"})
 		pods.WaitWithDefaultTimeout()
-		Expect(pods).Should(Exit(0))
+		Expect(pods).Should(ExitCleanly())
 		Expect(pods.OutputToStringArray()).To(HaveLen(2))
 	})
 
@@ -244,40 +245,40 @@ var _ = Describe("Podman prune", func() {
 		// Create new network.
 		session := podmanTest.Podman([]string{"network", "create", "test"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Remove all unused networks.
 		session = podmanTest.Podman([]string{"system", "prune", "-f"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Default network should exists.
 		session = podmanTest.Podman([]string{"network", "ls", "-q", "--filter", "name=^podman$"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(1))
 
 		// Unused networks removed.
 		session = podmanTest.Podman([]string{"network", "ls", "-q", "--filter", "name=^test$"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(BeEmpty())
 
 		// Create new network.
 		session = podmanTest.Podman([]string{"network", "create", "test1", "--label", "foo"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Remove all unused networks.
 		session = podmanTest.Podman([]string{"system", "prune", "-f", "--filter", "label!=foo"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).Should(Equal("Total reclaimed space: 0B"))
 
 		// Unused networks removed.
 		session = podmanTest.Podman([]string{"network", "ls", "-q", "--filter", "name=^test1$"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		// label should make sure we do not remove this network
 		Expect(session.OutputToStringArray()).To(HaveLen(1))
 	})
@@ -286,30 +287,30 @@ var _ = Describe("Podman prune", func() {
 		useCustomNetworkDir(podmanTest, tempdir)
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podid1 := session.OutputToString()
 
 		// Start and stop a pod to get it in exited state.
 		session = podmanTest.Podman([]string{"pod", "start", podid1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", podid1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Create a container. This container should be pruned.
 		create := podmanTest.Podman([]string{"create", "--name", "test", BB})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		prune := podmanTest.Podman([]string{"system", "prune", "-f"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		pods := podmanTest.Podman([]string{"pod", "ps"})
 		pods.WaitWithDefaultTimeout()
-		Expect(pods).Should(Exit(0))
+		Expect(pods).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfPods()).To(Equal(0))
 
 		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
@@ -320,26 +321,26 @@ var _ = Describe("Podman prune", func() {
 		// Start and stop a pod to get it in exited state.
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podid1 := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podid1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", podid1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Start a pod and leave it running
 		session = podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podid2 := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"pod", "start", podid2})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Number of pod should be 2. One exited one running.
 		Expect(podmanTest.NumberOfPods()).To(Equal(2))
@@ -360,25 +361,25 @@ var _ = Describe("Podman prune", func() {
 		// Adding unused volume should be pruned
 		session = podmanTest.Podman([]string{"volume", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", "-v", "myvol:/myvol", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"volume", "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(3))
 
 		session = podmanTest.Podman([]string{"system", "prune", "--force", "--volumes"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Volumes should be pruned.
 		session = podmanTest.Podman([]string{"volume", "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(BeEmpty())
 
 		// One Pod should not be pruned as it was running
@@ -397,35 +398,35 @@ var _ = Describe("Podman prune", func() {
 		useCustomNetworkDir(podmanTest, tempdir)
 		session := podmanTest.Podman([]string{"pod", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		podid1 := session.OutputToString()
 
 		// Start and stop a pod to get it in exited state.
 		session = podmanTest.Podman([]string{"pod", "start", podid1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"pod", "stop", podid1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Create a container. This container should be pruned.
 		create := podmanTest.Podman([]string{"create", "--name", "test", BB})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		// Adding unused volume should not be pruned as volumes not set
 		session = podmanTest.Podman([]string{"volume", "create"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		prune := podmanTest.Podman([]string{"system", "prune", "-f", "-a"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		pods := podmanTest.Podman([]string{"pod", "ps"})
 		pods.WaitWithDefaultTimeout()
-		Expect(pods).Should(Exit(0))
+		Expect(pods).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfPods()).To(Equal(0))
 
 		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
@@ -433,7 +434,7 @@ var _ = Describe("Podman prune", func() {
 		// Volumes should not be pruned
 		session = podmanTest.Podman([]string{"volume", "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 
 		images := podmanTest.Podman([]string{"images", "-aq"})
@@ -446,58 +447,58 @@ var _ = Describe("Podman prune", func() {
 		useCustomNetworkDir(podmanTest, tempdir)
 		session := podmanTest.Podman([]string{"volume", "create", "--label", "label1=value1", "myvol1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"volume", "create", "--label", "sharedlabel1=slv1", "myvol2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"volume", "create", "--label", "sharedlabel1=slv2", "myvol3"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"volume", "create", "--label", "sharedlabel1", "myvol4"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", "-v", "myvol5:/myvol5", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", "-v", "myvol6:/myvol6", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"volume", "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(7))
 
 		session = podmanTest.Podman([]string{"system", "prune", "--force", "--volumes", "--filter", "label=label1=value1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"volume", "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(6))
 
 		session = podmanTest.Podman([]string{"system", "prune", "--force", "--volumes", "--filter", "label=sharedlabel1=slv1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"volume", "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(5))
 
 		session = podmanTest.Podman([]string{"system", "prune", "--force", "--volumes", "--filter", "label=sharedlabel1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"volume", "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(3))
 	})
 
@@ -514,7 +515,7 @@ var _ = Describe("Podman prune", func() {
 
 		create := podmanTest.Podman([]string{"create", "--name", "test", BB})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		// Container should exist
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
@@ -526,7 +527,7 @@ var _ = Describe("Podman prune", func() {
 
 		prune := podmanTest.Podman([]string{"system", "prune", "--external", "-f"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		// Container should still exist
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
@@ -547,7 +548,7 @@ var _ = Describe("Podman prune", func() {
 		// Create container 1
 		create := podmanTest.Podman([]string{"create", "--name", "test", BB})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
 
@@ -574,7 +575,7 @@ var _ = Describe("Podman prune", func() {
 		// Create container 2
 		create = podmanTest.Podman([]string{"create", "--name", "test", BB})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
 
@@ -585,7 +586,7 @@ var _ = Describe("Podman prune", func() {
 
 		prune := podmanTest.Podman([]string{"system", "prune", "--external", "-f"})
 		prune.WaitWithDefaultTimeout()
-		Expect(prune).Should(Exit(0))
+		Expect(prune).Should(ExitCleanly())
 
 		// container 1 dir should be gone now
 		dirents, err = os.ReadDir(containerStorageDir)
diff --git a/test/e2e/ps_test.go b/test/e2e/ps_test.go
index a6e322fc3e..79351839a4 100644
--- a/test/e2e/ps_test.go
+++ b/test/e2e/ps_test.go
@@ -19,23 +19,23 @@ var _ = Describe("Podman ps", func() {
 	It("podman ps no containers", func() {
 		session := podmanTest.Podman([]string{"ps"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman container ps no containers", func() {
 		session := podmanTest.Podman([]string{"container", "ps"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman ps default", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"ps"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 	})
 
@@ -45,7 +45,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-a"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 	})
 
@@ -55,12 +55,12 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"container", "list", "-a"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 
 		result = podmanTest.Podman([]string{"container", "ls", "-a"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 	})
 
@@ -70,7 +70,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-a", "--size"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 	})
 
@@ -80,7 +80,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-a", "-q"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 		Expect(fullCid).To(ContainSubstring(result.OutputToStringArray()[0]))
 	})
@@ -94,7 +94,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-q", "--latest"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).To(HaveLen(1))
 	})
 
@@ -105,11 +105,11 @@ var _ = Describe("Podman ps", func() {
 		// well.
 		session := podmanTest.Podman([]string{"create", "alpine", "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"ps", "--last", "2"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).Should(HaveLen(2)) // 1 container
 
 		_, ec, _ := podmanTest.RunLsContainer("test1")
@@ -123,17 +123,17 @@ var _ = Describe("Podman ps", func() {
 
 		result = podmanTest.Podman([]string{"ps", "--last", "2"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).Should(HaveLen(3)) // 2 containers
 
 		result = podmanTest.Podman([]string{"ps", "--last", "3"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).Should(HaveLen(4)) // 3 containers
 
 		result = podmanTest.Podman([]string{"ps", "--last", "100"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).Should(HaveLen(5)) // 4 containers (3 running + 1 created)
 	})
 
@@ -143,7 +143,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 		Expect(fullCid).To(Equal(result.OutputToStringArray()[0]))
 	})
@@ -152,17 +152,17 @@ var _ = Describe("Podman ps", func() {
 		ctrAlpha := "alpha"
 		container := podmanTest.Podman([]string{"run", "-dt", "--name", ctrAlpha, ALPINE, "top"})
 		container.WaitWithDefaultTimeout()
-		Expect(container).Should(Exit(0))
+		Expect(container).Should(ExitCleanly())
 
 		ctrBravo := "bravo"
 		containerBravo := podmanTest.Podman([]string{"run", "-dt", "--network", "container:alpha", "--name", ctrBravo, ALPINE, "top"})
 		containerBravo.WaitWithDefaultTimeout()
-		Expect(containerBravo).Should(Exit(0))
+		Expect(containerBravo).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"ps", "-a", "--format", "table {{.Names}}", "--filter", "network=container:alpha"})
 		result.WaitWithDefaultTimeout()
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		actual := result.OutputToString()
 		Expect(actual).To(ContainSubstring("bravo"))
@@ -174,17 +174,17 @@ var _ = Describe("Podman ps", func() {
 		container := podmanTest.Podman([]string{"run", "-dt", "--name", ctrAlpha, ALPINE, "top"})
 		container.WaitWithDefaultTimeout()
 		cid := container.OutputToString()
-		Expect(container).Should(Exit(0))
+		Expect(container).Should(ExitCleanly())
 
 		ctrBravo := "second"
 		containerBravo := podmanTest.Podman([]string{"run", "-dt", "--network", "container:" + cid, "--name", ctrBravo, ALPINE, "top"})
 		containerBravo.WaitWithDefaultTimeout()
-		Expect(containerBravo).Should(Exit(0))
+		Expect(containerBravo).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"ps", "-a", "--format", "table {{.Names}}", "--filter", "network=container:" + cid})
 		result.WaitWithDefaultTimeout()
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		actual := result.OutputToString()
 		Expect(actual).To(ContainSubstring("second"))
 		Expect(actual).ToNot(ContainSubstring("table"))
@@ -194,17 +194,17 @@ var _ = Describe("Podman ps", func() {
 		ctrAlpha := "first"
 		container := podmanTest.Podman([]string{"run", "-dt", "--label", "test=with,comma", "--name", ctrAlpha, ALPINE, "top"})
 		container.WaitWithDefaultTimeout()
-		Expect(container).Should(Exit(0))
+		Expect(container).Should(ExitCleanly())
 
 		ctrBravo := "second"
 		containerBravo := podmanTest.Podman([]string{"run", "-dt", "--name", ctrBravo, ALPINE, "top"})
 		containerBravo.WaitWithDefaultTimeout()
-		Expect(containerBravo).Should(Exit(0))
+		Expect(containerBravo).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"ps", "-a", "--format", "table {{.Names}}", "--filter", "label=test=with,comma"})
 		result.WaitWithDefaultTimeout()
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		actual := result.OutputToString()
 		Expect(actual).To(ContainSubstring("first"))
 		Expect(actual).ToNot(ContainSubstring("table"))
@@ -216,7 +216,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-a", "--namespace"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).ShouldNot(BeEmpty())
 	})
 
@@ -227,7 +227,7 @@ var _ = Describe("Podman ps", func() {
 		result := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format",
 			"{{with .Namespaces}}{{.Cgroup}}:{{.IPC}}:{{.MNT}}:{{.NET}}:{{.PIDNS}}:{{.User}}:{{.UTS}}{{end}}"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		// it must contains `::` when some ns is null. If it works normally, it should be "$num1:$num2:$num3"
 		Expect(result.OutputToString()).ToNot(ContainSubstring(`::`))
 	})
@@ -235,7 +235,7 @@ var _ = Describe("Podman ps", func() {
 	It("podman ps with no containers is valid json format", func() {
 		result := podmanTest.Podman([]string{"ps", "--format", "json"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(BeValidJSON())
 	})
 
@@ -245,7 +245,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{ json . }}"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(BeValidJSON())
 		// https://github.com/containers/podman/issues/16436
 		Expect(result.OutputToString()).To(HavePrefix("{"), "test for single json object and not array see #16436")
@@ -254,11 +254,11 @@ var _ = Describe("Podman ps", func() {
 	It("podman ps json format Created field is int64", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"ps", "--format", "json"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		// Make sure Created field is an int64
 		created, err := result.jq(".[0].Created")
@@ -273,7 +273,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-a", "--format", "json"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(BeValidJSON())
 		// must contain "Status"
 		match, StatusLine := result.GrepString(`Status`)
@@ -288,7 +288,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-a", "--format", "table {{.ID}} {{.Image}} {{.ImageID}} {{.Labels}}"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		Expect(result.OutputToString()).ToNot(ContainSubstring("table"))
 
@@ -304,31 +304,31 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "-a", "--filter", "ancestor=quay.io/libpod/alpine:latest"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(Equal(cid))
 
 		// Query just by image name, without :latest tag
 		result = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "-a", "--filter", "ancestor=quay.io/libpod/alpine"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(Equal(cid))
 
 		// Query by truncated image name should match (regexp match)
 		result = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "-a", "--filter", "ancestor=quay.io/libpod/alpi"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(Equal(cid))
 
 		// Query using regex by truncated image name should match (regexp match)
 		result = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "-a", "--filter", "ancestor=^(quay.io|docker.io)/libpod/alpine:[a-zA-Z]+"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(Equal(cid))
 
 		// Query for a non-existing image using regex should not match anything
 		result = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "-a", "--filter", "ancestor=^quai.io/libpod/alpi"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(Equal(""))
 	})
 
@@ -338,34 +338,34 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-a", "--filter", fmt.Sprintf("id=%s", fullCid)})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman ps id filter flag", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		fullCid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc", "--filter", "status=running"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()[0]).To(Equal(fullCid))
 	})
 
 	It("podman ps multiple filters", func() {
 		session := podmanTest.Podman([]string{"run", "-d", "--name", "test1", "--label", "key1=value1", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		fullCid := session.OutputToString()
 
 		session2 := podmanTest.Podman([]string{"run", "-d", "--name", "test2", "--label", "key1=value1", ALPINE, "top"})
 		session2.WaitWithDefaultTimeout()
-		Expect(session2).Should(Exit(0))
+		Expect(session2).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc", "--filter", "name=test1", "--filter", "label=key1=value1"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		output := result.OutputToStringArray()
 		Expect(output).To(HaveLen(1))
@@ -375,15 +375,15 @@ var _ = Describe("Podman ps", func() {
 	It("podman ps filter by exited does not need all", func() {
 		ctr := podmanTest.Podman([]string{"run", ALPINE, "ls", "/"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		psAll := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc"})
 		psAll.WaitWithDefaultTimeout()
-		Expect(psAll).Should(Exit(0))
+		Expect(psAll).Should(ExitCleanly())
 
 		psFilter := podmanTest.Podman([]string{"ps", "--no-trunc", "--quiet", "--filter", "status=exited"})
 		psFilter.WaitWithDefaultTimeout()
-		Expect(psFilter).Should(Exit(0))
+		Expect(psFilter).Should(ExitCleanly())
 
 		Expect(psAll.OutputToString()).To(Equal(psFilter.OutputToString()))
 	})
@@ -392,11 +392,11 @@ var _ = Describe("Podman ps", func() {
 		ctrName := "aContainerName"
 		ctr := podmanTest.Podman([]string{"create", "--name", ctrName, ALPINE, "ls", "/"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		psFilter := podmanTest.Podman([]string{"ps", "--no-trunc", "--quiet", "--format", "{{.Names}}", "--filter", fmt.Sprintf("name=%s", ctrName)})
 		psFilter.WaitWithDefaultTimeout()
-		Expect(psFilter).Should(Exit(0))
+		Expect(psFilter).Should(ExitCleanly())
 
 		actual := psFilter.OutputToString()
 		Expect(actual).ToNot(ContainSubstring(ctrName))
@@ -416,30 +416,30 @@ var _ = Describe("Podman ps", func() {
 	It("podman --format by size", func() {
 		session := podmanTest.Podman([]string{"create", BB, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"ps", "-a", "--format", "{{.Size}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.ErrorToString()).To(ContainSubstring("Size format requires --size option"))
 	})
 
 	It("podman --sort by size", func() {
 		session := podmanTest.Podman([]string{"create", BB, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"ps", "-a", "-s", "--sort=size", "--format", "{{.Size}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		sortedArr := session.OutputToStringArray()
 
@@ -465,15 +465,15 @@ var _ = Describe("Podman ps", func() {
 	It("podman --sort by command", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "-d", ALPINE, "pwd"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"ps", "-a", "--sort=command", "--format", "{{.Command}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		Expect(session.OutputToString()).ToNot(ContainSubstring("COMMAND"))
 
@@ -487,16 +487,16 @@ var _ = Describe("Podman ps", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podid)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"ps", "--no-trunc"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).ToNot(ContainSubstring(podid))
 
 		session = podmanTest.Podman([]string{"ps", "--pod", "--no-trunc"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(podid))
 	})
 
@@ -507,14 +507,14 @@ var _ = Describe("Podman ps", func() {
 
 		session := podmanTest.RunTopContainerInPod("", podName)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// "--no-trunc" must be given. If not it will trunc the pod ID
 		// in the output and you will have to trunc it in the test too.
 		session = podmanTest.Podman([]string{"ps", "--pod", "--no-trunc"})
 
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		output := session.OutputToString()
 		Expect(output).To(ContainSubstring(podid))
@@ -524,11 +524,11 @@ var _ = Describe("Podman ps", func() {
 	It("podman ps test with single port range", func() {
 		session := podmanTest.Podman([]string{"run", "-dt", "-p", "2000-2006:2000-2006", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"ps", "--format", "{{.Ports}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).To(Exit(0))
+		Expect(session).To(ExitCleanly())
 
 		actual := session.OutputToString()
 		Expect(actual).To(ContainSubstring("0.0.0.0:2000-2006"))
@@ -555,7 +555,7 @@ var _ = Describe("Podman ps", func() {
 			ALPINE, "top"},
 		)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"ps", "--format", "{{.Ports}}"})
 		session.WaitWithDefaultTimeout()
@@ -567,35 +567,35 @@ var _ = Describe("Podman ps", func() {
 	It("podman ps sync flag", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		fullCid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--sync"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()[0]).To(Equal(fullCid))
 	})
 
 	It("podman ps filter name regexp", func() {
 		session := podmanTest.Podman([]string{"run", "-d", "--name", "test1", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		fullCid := session.OutputToString()
 
 		session2 := podmanTest.Podman([]string{"run", "-d", "--name", "test11", ALPINE, "top"})
 		session2.WaitWithDefaultTimeout()
-		Expect(session2).Should(Exit(0))
+		Expect(session2).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc", "--filter", "name=test1"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		output := result.OutputToStringArray()
 		Expect(output).To(HaveLen(2))
 
 		result = podmanTest.Podman([]string{"ps", "-aq", "--no-trunc", "--filter", "name=test1$"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		output = result.OutputToStringArray()
 		Expect(output).To(HaveLen(1))
@@ -606,11 +606,11 @@ var _ = Describe("Podman ps", func() {
 		ctrName := "testCtr"
 		session := podmanTest.Podman([]string{"run", "-d", "--name", ctrName, ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"ps", "-q", "-a", "--format", "{{ .Names }}"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		output := result.OutputToStringArray()
 		Expect(output).To(HaveLen(1))
@@ -621,23 +621,23 @@ var _ = Describe("Podman ps", func() {
 		podName := "testPod"
 		pod := podmanTest.Podman([]string{"pod", "create", "-p", "8085:80", "--name", podName})
 		pod.WaitWithDefaultTimeout()
-		Expect(pod).Should(Exit(0))
+		Expect(pod).Should(ExitCleanly())
 
 		ctrName := "testCtr"
 		session := podmanTest.Podman([]string{"run", "--name", ctrName, "-dt", "--pod", podName, ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		ps := podmanTest.Podman([]string{"ps", "--filter", fmt.Sprintf("name=%s", ctrName), "--format", "{{.Ports}}"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		Expect(ps.OutputToString()).To(ContainSubstring("0.0.0.0:8085->80/tcp"))
 	})
 
 	It("podman ps truncate long create command", func() {
 		session := podmanTest.Podman([]string{"run", ALPINE, "echo", "very", "long", "create", "command"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"ps", "-a"})
 		session.WaitWithDefaultTimeout()
@@ -649,7 +649,7 @@ var _ = Describe("Podman ps", func() {
 
 		result := podmanTest.Podman([]string{"ps", "-a", "--format", "{{.RunningFor}}"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		actual := result.OutputToString()
 		Expect(actual).To(ContainSubstring("ago"))
@@ -660,7 +660,7 @@ var _ = Describe("Podman ps", func() {
 		session := podmanTest.Podman([]string{"run", "-d", "--name", "test1", "--label", "foo=1",
 			"--label", "bar=2", "--volume", "volume1:/test", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid1 := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"run", "--name", "test2", "--label", "foo=1",
@@ -670,16 +670,16 @@ var _ = Describe("Podman ps", func() {
 
 		session = podmanTest.Podman([]string{"create", "--name", "test3", ALPINE, cid1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "--name", "test4", "--volume", "volume1:/test1",
 			"--volume", "/:/test2", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "name=test"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(5))
 		Expect(session.OutputToString()).To(ContainSubstring("test1"))
 		Expect(session.OutputToString()).To(ContainSubstring("test2"))
@@ -688,7 +688,7 @@ var _ = Describe("Podman ps", func() {
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "name=test1", "--filter", "name=test2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(3))
 		Expect(session.OutputToString()).To(ContainSubstring("test1"))
 		Expect(session.OutputToString()).To(ContainSubstring("test2"))
@@ -696,19 +696,19 @@ var _ = Describe("Podman ps", func() {
 		// check container id matches with regex
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "id=" + cid1[:40], "--filter", "id=" + cid1 + "$"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 		Expect(session.OutputToString()).To(ContainSubstring("test1"))
 
 		session = podmanTest.Podman([]string{"ps", "--filter", "status=created"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 		Expect(session.OutputToString()).To(ContainSubstring("test3"))
 
 		session = podmanTest.Podman([]string{"ps", "--filter", "status=created", "--filter", "status=exited"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(4))
 		Expect(session.OutputToString()).To(ContainSubstring("test2"))
 		Expect(session.OutputToString()).To(ContainSubstring("test3"))
@@ -716,63 +716,63 @@ var _ = Describe("Podman ps", func() {
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "label=foo=1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(3))
 		Expect(session.OutputToString()).To(ContainSubstring("test1"))
 		Expect(session.OutputToString()).To(ContainSubstring("test2"))
 
 		session = podmanTest.Podman([]string{"ps", "--filter", "label=foo=1", "--filter", "status=exited"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 		Expect(session.OutputToString()).To(ContainSubstring("test2"))
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "label=foo=1", "--filter", "label=non=1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(1))
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "label=foo=1", "--filter", "label=bar=2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 		Expect(session.OutputToString()).To(ContainSubstring("test1"))
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "exited=1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 		Expect(session.OutputToString()).To(ContainSubstring("test2"))
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "exited=1", "--filter", "exited=0"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(3))
 		Expect(session.OutputToString()).To(ContainSubstring("test2"))
 		Expect(session.OutputToString()).To(ContainSubstring("test4"))
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "volume=volume1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(3))
 		Expect(session.OutputToString()).To(ContainSubstring("test1"))
 		Expect(session.OutputToString()).To(ContainSubstring("test4"))
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "volume=/:/test2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 		Expect(session.OutputToString()).To(ContainSubstring("test4"))
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "before=test2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 		Expect(session.OutputToString()).To(ContainSubstring("test1"))
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--filter", "since=test2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(3))
 		Expect(session.OutputToString()).To(ContainSubstring("test3"))
 		Expect(session.OutputToString()).To(ContainSubstring("test4"))
@@ -780,48 +780,48 @@ var _ = Describe("Podman ps", func() {
 	It("podman ps filter pod", func() {
 		pod1 := podmanTest.Podman([]string{"pod", "create", "--name", "pod1"})
 		pod1.WaitWithDefaultTimeout()
-		Expect(pod1).Should(Exit(0))
+		Expect(pod1).Should(ExitCleanly())
 		con1 := podmanTest.Podman([]string{"run", "-dt", "--pod", "pod1", ALPINE, "top"})
 		con1.WaitWithDefaultTimeout()
-		Expect(con1).Should(Exit(0))
+		Expect(con1).Should(ExitCleanly())
 
 		pod2 := podmanTest.Podman([]string{"pod", "create", "--name", "pod2"})
 		pod2.WaitWithDefaultTimeout()
-		Expect(pod2).Should(Exit(0))
+		Expect(pod2).Should(ExitCleanly())
 		con2 := podmanTest.Podman([]string{"run", "-dt", "--pod", "pod2", ALPINE, "top"})
 		con2.WaitWithDefaultTimeout()
-		Expect(con2).Should(Exit(0))
+		Expect(con2).Should(ExitCleanly())
 
 		// bogus pod name or id should not result in error
 		session := podmanTest.Podman([]string{"ps", "--filter", "pod=1234"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// filter by pod name
 		session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=pod1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 		Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString()))
 
 		// filter by full pod id
 		session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=" + pod1.OutputToString()})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 		Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString()))
 
 		// filter by partial pod id
 		session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=" + pod1.OutputToString()[0:12]})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(2))
 		Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString()))
 
 		// filter by multiple pods is inclusive
 		session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=pod1", "--filter", "pod=pod2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(4))
 		Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString()))
 		Expect(session.OutputToStringArray()).To(ContainElement(con2.OutputToString()))
@@ -832,22 +832,22 @@ var _ = Describe("Podman ps", func() {
 		net := stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", net})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(net)
 
 		session = podmanTest.Podman([]string{"create", "--network", net, ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		ctrWithNet := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"create", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		ctrWithoutNet := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--no-trunc", "--filter", "network=" + net})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		actual := session.OutputToString()
 		Expect(actual).To(ContainSubstring(ctrWithNet))
 		Expect(actual).ToNot(ContainSubstring(ctrWithoutNet))
@@ -856,11 +856,11 @@ var _ = Describe("Podman ps", func() {
 	It("podman ps --format networks", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--format", "{{ .Networks }}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		actual := session.OutputToString()
 		Expect(actual).ToNot(ContainSubstring("NETWORKS"))
@@ -875,22 +875,22 @@ var _ = Describe("Podman ps", func() {
 		net1 := stringid.GenerateRandomID()
 		session = podmanTest.Podman([]string{"network", "create", net1})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(net1)
 		net2 := stringid.GenerateRandomID()
 		session = podmanTest.Podman([]string{"network", "create", net2})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		defer podmanTest.removeNetwork(net2)
 
 		session = podmanTest.Podman([]string{"create", "--network", net1 + "," + net2, ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"ps", "--all", "--format", "{{ .Networks }}", "--filter", "id=" + cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		// the output is not deterministic so check both possible orders
 		Expect(session.OutputToString()).To(Or(Equal(net1+","+net2), Equal(net2+","+net1)))
 	})
diff --git a/test/e2e/rename_test.go b/test/e2e/rename_test.go
index 5c1c75ecb7..b3d38a98b3 100644
--- a/test/e2e/rename_test.go
+++ b/test/e2e/rename_test.go
@@ -6,7 +6,6 @@ import (
 	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("podman rename", func() {
@@ -21,7 +20,7 @@ var _ = Describe("podman rename", func() {
 		ctrName := "testCtr"
 		ctr := podmanTest.Podman([]string{"create", "--name", ctrName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		newName := "invalid<>:char"
 		rename := podmanTest.Podman([]string{"rename", ctrName, newName})
@@ -30,7 +29,7 @@ var _ = Describe("podman rename", func() {
 
 		ps := podmanTest.Podman([]string{"ps", "-aq", "--filter", fmt.Sprintf("name=%s", ctrName), "--format", "{{ .Names }}"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		Expect(ps.OutputToString()).To(ContainSubstring(ctrName))
 	})
 
@@ -38,16 +37,16 @@ var _ = Describe("podman rename", func() {
 		ctrName := "testCtr"
 		ctr := podmanTest.Podman([]string{"create", "--name", ctrName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		newName := "aNewName"
 		rename := podmanTest.Podman([]string{"rename", ctrName, newName})
 		rename.WaitWithDefaultTimeout()
-		Expect(rename).Should(Exit(0))
+		Expect(rename).Should(ExitCleanly())
 
 		ps := podmanTest.Podman([]string{"ps", "-aq", "--filter", fmt.Sprintf("name=%s", newName), "--format", "{{ .Names }}"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		Expect(ps.OutputToString()).To(ContainSubstring(newName))
 	})
 
@@ -55,16 +54,16 @@ var _ = Describe("podman rename", func() {
 		ctrName := "testCtr"
 		ctr := podmanTest.Podman([]string{"create", "--name", ctrName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		newName := "aNewName"
 		rename := podmanTest.Podman([]string{"rename", ctrName, newName})
 		rename.WaitWithDefaultTimeout()
-		Expect(rename).Should(Exit(0))
+		Expect(rename).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"events", "--stream=false", "--filter", "container=aNewName"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToString()).To(ContainSubstring("rename"))
 	})
 
@@ -72,16 +71,16 @@ var _ = Describe("podman rename", func() {
 		ctrName := "testCtr"
 		ctr := podmanTest.Podman([]string{"run", "-d", "--name", ctrName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		newName := "aNewName"
 		rename := podmanTest.Podman([]string{"rename", ctrName, newName})
 		rename.WaitWithDefaultTimeout()
-		Expect(rename).Should(Exit(0))
+		Expect(rename).Should(ExitCleanly())
 
 		ps := podmanTest.Podman([]string{"ps", "-aq", "--filter", fmt.Sprintf("name=%s", newName), "--format", "{{ .Names }}"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		Expect(ps.OutputToString()).To(ContainSubstring(newName))
 	})
 
@@ -89,20 +88,20 @@ var _ = Describe("podman rename", func() {
 		ctrName := "testCtr"
 		ctr := podmanTest.Podman([]string{"run", "-d", "--name", ctrName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
-		Expect(ctr).Should(Exit(0))
+		Expect(ctr).Should(ExitCleanly())
 
 		exec := podmanTest.Podman([]string{"exec", "-d", ctrName, "top"})
 		exec.WaitWithDefaultTimeout()
-		Expect(exec).Should(Exit(0))
+		Expect(exec).Should(ExitCleanly())
 
 		newName := "aNewName"
 		rename := podmanTest.Podman([]string{"rename", ctrName, newName})
 		rename.WaitWithDefaultTimeout()
-		Expect(rename).Should(Exit(0))
+		Expect(rename).Should(ExitCleanly())
 
 		ps := podmanTest.Podman([]string{"ps", "-aq", "--filter", fmt.Sprintf("name=%s", newName), "--format", "{{ .Names }}"})
 		ps.WaitWithDefaultTimeout()
-		Expect(ps).Should(Exit(0))
+		Expect(ps).Should(ExitCleanly())
 		Expect(ps.OutputToString()).To(ContainSubstring(newName))
 	})
 
@@ -111,23 +110,23 @@ var _ = Describe("podman rename", func() {
 		infraName := "infra1"
 		pod := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--infra-name", infraName})
 		pod.WaitWithDefaultTimeout()
-		Expect(pod).Should(Exit(0))
+		Expect(pod).Should(ExitCleanly())
 
 		infraName2 := "infra2"
 		rename := podmanTest.Podman([]string{"rename", infraName, infraName2})
 		rename.WaitWithDefaultTimeout()
-		Expect(rename).Should(Exit(0))
+		Expect(rename).Should(ExitCleanly())
 
 		remove := podmanTest.Podman([]string{"pod", "rm", "-f", podName})
 		remove.WaitWithDefaultTimeout()
-		Expect(remove).Should(Exit(0))
+		Expect(remove).Should(ExitCleanly())
 
 		create := podmanTest.Podman([]string{"create", "--name", infraName2, ALPINE, "top"})
 		create.WaitWithDefaultTimeout()
-		Expect(create).Should(Exit(0))
+		Expect(create).Should(ExitCleanly())
 
 		create2 := podmanTest.Podman([]string{"create", "--name", infraName, ALPINE, "top"})
 		create2.WaitWithDefaultTimeout()
-		Expect(create2).Should(Exit(0))
+		Expect(create2).Should(ExitCleanly())
 	})
 })
diff --git a/test/e2e/rm_test.go b/test/e2e/rm_test.go
index 4f8f354eae..961b610dbf 100644
--- a/test/e2e/rm_test.go
+++ b/test/e2e/rm_test.go
@@ -3,6 +3,7 @@ package integration
 import (
 	"fmt"
 
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
@@ -16,13 +17,13 @@ var _ = Describe("Podman rm", func() {
 
 		result := podmanTest.Podman([]string{"rm", cid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman rm refuse to remove a running container", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"rm", cid})
@@ -34,76 +35,76 @@ var _ = Describe("Podman rm", func() {
 	It("podman rm created container", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"rm", cid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman container rm created container", func() {
 		session := podmanTest.Podman([]string{"container", "create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"container", "rm", cid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman rm running container with -f", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"rm", "-t", "0", "-f", cid})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman rm all containers", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"rm", "-a"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman rm all containers with one running and short options", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"rm", "-af"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 	})
 
 	It("podman rm the latest container", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		_, ec, cid := podmanTest.RunLsContainer("test1")
 		Expect(ec).To(Equal(0))
@@ -114,7 +115,7 @@ var _ = Describe("Podman rm", func() {
 		}
 		result := podmanTest.Podman([]string{"rm", latest})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		output := result.OutputToString()
 		Expect(output).To(ContainSubstring(cid))
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
@@ -126,13 +127,13 @@ var _ = Describe("Podman rm", func() {
 
 		session := podmanTest.Podman([]string{"create", "--cidfile", tmpFile, ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToStringArray()[0]
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
 
 		result := podmanTest.Podman([]string{"rm", "--cidfile", tmpFile})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		output := result.OutputToString()
 		Expect(output).To(ContainSubstring(cid))
 		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
@@ -145,19 +146,19 @@ var _ = Describe("Podman rm", func() {
 
 		session := podmanTest.Podman([]string{"create", "--cidfile", tmpFile1, ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid1 := session.OutputToStringArray()[0]
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
 
 		session = podmanTest.Podman([]string{"create", "--cidfile", tmpFile2, ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid2 := session.OutputToStringArray()[0]
 		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
 
 		result := podmanTest.Podman([]string{"rm", "--cidfile", tmpFile1, "--cidfile", tmpFile2})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		output := result.OutputToString()
 		Expect(output).To(ContainSubstring(cid1))
 		Expect(output).To(ContainSubstring(cid2))
@@ -191,24 +192,24 @@ var _ = Describe("Podman rm", func() {
 	It("podman rm --all", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
 
 		session = podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
 
 		session = podmanTest.Podman([]string{"rm", "--all"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
 	})
 
 	It("podman rm --ignore", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToStringArray()[0]
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
 
@@ -222,7 +223,7 @@ var _ = Describe("Podman rm", func() {
 
 		session = podmanTest.Podman([]string{"rm", "--ignore", "bogus", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		if !IsRemote() {
 			Expect(session.OutputToString()).To(BeEquivalentTo(cid))
 		}
@@ -239,7 +240,7 @@ var _ = Describe("Podman rm", func() {
 	It("podman rm bogus container and a running container", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"rm", "bogus", "test1"})
 		session.WaitWithDefaultTimeout()
@@ -255,7 +256,7 @@ var _ = Describe("Podman rm", func() {
 	It("podman rm --ignore bogus container and a running container", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"rm", "--ignore", "test1", "bogus"})
 		session.WaitWithDefaultTimeout()
@@ -264,30 +265,30 @@ var _ = Describe("Podman rm", func() {
 
 		session = podmanTest.Podman([]string{"rm", "-t", "0", "--force", "--ignore", "bogus", "test1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(BeEquivalentTo("test1"))
 	})
 
 	It("podman rm --filter", func() {
 		session1 := podmanTest.RunTopContainer("test1")
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid1 := session1.OutputToString()
 
 		session1 = podmanTest.RunTopContainer("test2")
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid2 := session1.OutputToString()
 
 		session1 = podmanTest.RunTopContainer("test3")
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid3 := session1.OutputToString()
 		shortCid3 := cid3[0:5]
 
 		session1 = podmanTest.RunTopContainerWithArgs("test4", []string{"--label", "test=with,comma"})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid4 := session1.OutputToString()
 
 		session1 = podmanTest.Podman([]string{"rm", cid1, "-f", "--filter", "status=running"})
@@ -297,22 +298,22 @@ var _ = Describe("Podman rm", func() {
 
 		session1 = podmanTest.Podman([]string{"rm", "-a", "-f", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEmpty())
 
 		session1 = podmanTest.Podman([]string{"rm", "-a", "-f", "--filter", fmt.Sprintf("id=%s", shortCid3)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
 
 		session1 = podmanTest.Podman([]string{"rm", "-f", "--filter", fmt.Sprintf("id=%s", cid2)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid2))
 
 		session1 = podmanTest.Podman([]string{"rm", "-f", "--filter", "label=test=with,comma"})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid4))
 	})
 
@@ -320,17 +321,17 @@ var _ = Describe("Podman rm", func() {
 		ctr1Name := "ctr1"
 		ctr1 := podmanTest.RunTopContainer(ctr1Name)
 		ctr1.WaitWithDefaultTimeout()
-		Expect(ctr1).Should(Exit(0))
+		Expect(ctr1).Should(ExitCleanly())
 		cid1 := ctr1.OutputToString()
 
 		ctr2 := podmanTest.Podman([]string{"run", "-d", "--network", fmt.Sprintf("container:%s", ctr1Name), ALPINE, "top"})
 		ctr2.WaitWithDefaultTimeout()
-		Expect(ctr2).Should(Exit(0))
+		Expect(ctr2).Should(ExitCleanly())
 		cid2 := ctr2.OutputToString()
 
 		rm := podmanTest.Podman([]string{"rm", "-fa"})
 		rm.WaitWithDefaultTimeout()
-		Expect(rm).Should(Exit(0))
+		Expect(rm).Should(ExitCleanly())
 		Expect(rm.ErrorToString()).To(BeEmpty(), "rm -fa error logged")
 		Expect(rm.OutputToStringArray()).Should(ConsistOf(cid1, cid2))
 
diff --git a/test/e2e/rmi_test.go b/test/e2e/rmi_test.go
index 535d458ec6..eeb033b463 100644
--- a/test/e2e/rmi_test.go
+++ b/test/e2e/rmi_test.go
@@ -23,7 +23,7 @@ var _ = Describe("Podman rmi", func() {
 		podmanTest.AddImageToRWStore(ALPINE)
 		session := podmanTest.Podman([]string{"rmi", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 	})
 
@@ -31,7 +31,7 @@ var _ = Describe("Podman rmi", func() {
 		podmanTest.AddImageToRWStore(CIRROS_IMAGE)
 		session := podmanTest.Podman([]string{"rmi", "cirros"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 	})
 
@@ -41,7 +41,7 @@ var _ = Describe("Podman rmi", func() {
 		session.WaitWithDefaultTimeout()
 		images := podmanTest.Podman([]string{"images"})
 		images.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 	})
 
@@ -49,7 +49,7 @@ var _ = Describe("Podman rmi", func() {
 		podmanTest.AddImageToRWStore(NGINX_IMAGE)
 		session := podmanTest.Podman([]string{"rmi", "-fa"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 	})
 
@@ -57,15 +57,15 @@ var _ = Describe("Podman rmi", func() {
 		podmanTest.AddImageToRWStore(CIRROS_IMAGE)
 		setup := podmanTest.Podman([]string{"images", "-q", CIRROS_IMAGE})
 		setup.WaitWithDefaultTimeout()
-		Expect(setup).Should(Exit(0))
+		Expect(setup).Should(ExitCleanly())
 
 		session := podmanTest.Podman([]string{"tag", CIRROS_IMAGE, "foo:bar", "foo"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"images", "-q", "foo"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 
 		Expect(result.OutputToString()).To(ContainSubstring(setup.OutputToString()))
 	})
@@ -74,12 +74,12 @@ var _ = Describe("Podman rmi", func() {
 		podmanTest.AddImageToRWStore(CIRROS_IMAGE)
 		setup := podmanTest.Podman([]string{"images", "-q", CIRROS_IMAGE})
 		setup.WaitWithDefaultTimeout()
-		Expect(setup).Should(Exit(0))
+		Expect(setup).Should(ExitCleanly())
 		cirrosID := setup.OutputToString()
 
 		session := podmanTest.Podman([]string{"tag", "cirros", "foo:bar", "foo"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Trying without --force should fail
 		result := podmanTest.Podman([]string{"rmi", cirrosID})
@@ -89,7 +89,7 @@ var _ = Describe("Podman rmi", func() {
 		// With --force it should work
 		resultForce := podmanTest.Podman([]string{"rmi", "-f", cirrosID})
 		resultForce.WaitWithDefaultTimeout()
-		Expect(resultForce).Should(Exit(0))
+		Expect(resultForce).Should(ExitCleanly())
 	})
 
 	It("podman rmi image that is a parent of another image", func() {
@@ -97,28 +97,28 @@ var _ = Describe("Podman rmi", func() {
 		podmanTest.AddImageToRWStore(CIRROS_IMAGE)
 		session := podmanTest.Podman([]string{"run", "--name", "c_test", CIRROS_IMAGE, "true"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"commit", "-q", "c_test", "test"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"rm", "c_test"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"rmi", CIRROS_IMAGE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"images", "-q"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(12))
 
 		session = podmanTest.Podman([]string{"images", "--sort", "created", "--format", "{{.Id}}", "--all"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(13),
 			"Output from 'podman images -q -a'")
 		untaggedImg := session.OutputToStringArray()[1]
@@ -132,31 +132,31 @@ var _ = Describe("Podman rmi", func() {
 		podmanTest.AddImageToRWStore(ALPINE)
 		session := podmanTest.Podman([]string{"create", "--name", "c_test1", ALPINE, "true"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"commit", "-q", "c_test1", "test1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", "--name", "c_test2", "test1", "true"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"commit", "-q", "c_test2", "test2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"rm", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"rmi", "test2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"images", "-q"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(len(CACHE_IMAGES) + 1))
 	})
 
@@ -180,51 +180,51 @@ var _ = Describe("Podman rmi", func() {
 
 		session := podmanTest.Podman([]string{"images", "-q", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		numOfImages := len(session.OutputToStringArray())
 
 		session = podmanTest.Podman([]string{"rmi", "test2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"images", "-q", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(numOfImages - len(session.OutputToStringArray())).To(Equal(2))
 
 		session = podmanTest.Podman([]string{"rmi", "test"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"images", "-q", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(len(CACHE_IMAGES) + 1))
 
 		podmanTest.BuildImage(dockerfile, "test3", "true")
 
 		session = podmanTest.Podman([]string{"rmi", CIRROS_IMAGE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"rmi", "test3"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"images", "-q", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(HaveLen(142))
 	})
 
 	It("podman rmi -a with no images should be exit 0", func() {
 		session := podmanTest.Podman([]string{"rmi", "-fa"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session2 := podmanTest.Podman([]string{"rmi", "-fa"})
 		session2.WaitWithDefaultTimeout()
-		Expect(session2).Should(Exit(0))
+		Expect(session2).Should(ExitCleanly())
 	})
 
 	It("podman rmi -a with parent|child images", func() {
@@ -240,11 +240,11 @@ RUN find $LOCAL
 		podmanTest.BuildImage(dockerfile, "test", "true")
 		session := podmanTest.Podman([]string{"rmi", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		images := podmanTest.Podman([]string{"images", "-aq"})
 		images.WaitWithDefaultTimeout()
-		Expect(images).Should(Exit(0))
+		Expect(images).Should(ExitCleanly())
 		Expect(images.OutputToStringArray()).To(HaveLen(len(CACHE_IMAGES)))
 	})
 
@@ -291,7 +291,7 @@ RUN find $LOCAL
 				imageName := fmt.Sprintf("rmtest:%d", i)
 				session := podmanTest.Podman([]string{"rmi", "-f", imageName})
 				session.WaitWithDefaultTimeout()
-				Expect(session).Should(Exit(0))
+				Expect(session).Should(ExitCleanly())
 			}(i)
 		}
 		wg.Wait()
@@ -301,41 +301,41 @@ RUN find $LOCAL
 		podmanTest.AddImageToRWStore(ALPINE)
 		session := podmanTest.Podman([]string{"create", "--name", "c_test1", ALPINE, "true"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"commit", "-q", "c_test1", "test1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", "--name", "c_test2", "test1", "true"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"commit", "-q", "c_test2", "test2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		imageID2 := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"create", "--name", "c_test3", "test2", "true"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"commit", "-q", "c_test3", "test3"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		imageID3 := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"untag", "test2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"untag", "test1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"rmi", "-f", "--no-prune", "test3"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(imageID3))
 		Expect(session.OutputToString()).NotTo(ContainSubstring(imageID2))
 	})
@@ -344,33 +344,33 @@ RUN find $LOCAL
 		podmanTest.AddImageToRWStore(ALPINE)
 		session := podmanTest.Podman([]string{"create", "--name", "c_test1", ALPINE, "true"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"commit", "-q", "c_test1", "test1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"create", "--name", "c_test2", "test1", "true"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"commit", "-q", "c_test2", "test2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		imageID2 := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"create", "--name", "c_test3", "test2", "true"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"commit", "-q", "c_test3", "test3"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		imageID3 := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"rmi", "-f", "--no-prune", "test3"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring(imageID3))
 		Expect(session.OutputToString()).NotTo(ContainSubstring(imageID2))
 	})
diff --git a/test/e2e/secret_test.go b/test/e2e/secret_test.go
index fdea3694c5..4d73c2271a 100644
--- a/test/e2e/secret_test.go
+++ b/test/e2e/secret_test.go
@@ -26,15 +26,15 @@ var _ = Describe("Podman secret", func() {
 		session := podmanTest.Podman([]string{"secret", "create", "-d", "file", "--driver-opts", "opt1=val", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"secret", "inspect", "--format", "{{.ID}}", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal(secrID))
 		inspect = podmanTest.Podman([]string{"secret", "inspect", "-f", "{{.Spec.Driver.Options}}", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(ContainSubstring("opt1:val"))
 
 		session = podmanTest.Podman([]string{"secret", "create", "-d", "file", "--driver-opts", "opt1=val1", "a", secretFilePath})
@@ -44,7 +44,7 @@ var _ = Describe("Podman secret", func() {
 
 		session = podmanTest.Podman([]string{"secret", "create", "-d", "file", "--driver-opts", "opt1=val1", "--replace", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Not(Equal(secrID)))
 
 		inspect = podmanTest.Podman([]string{"secret", "inspect", "-f", "{{.Spec.Driver.Options}}", secrID})
@@ -54,7 +54,7 @@ var _ = Describe("Podman secret", func() {
 
 		inspect = podmanTest.Podman([]string{"secret", "inspect", "-f", "{{.Spec.Driver.Options}}", "a"})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(ContainSubstring("opt1:val1"))
 	})
 
@@ -85,21 +85,21 @@ var _ = Describe("Podman secret", func() {
 		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"secret", "inspect", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(BeValidJSON())
 
 		inspect = podmanTest.Podman([]string{"secret", "inspect", "--format", "{{ .SecretData }}", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal(""))
 
 		inspect = podmanTest.Podman([]string{"secret", "inspect", "--showsecret", "--format", "{{ .SecretData }}", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal(random))
 	})
 
@@ -111,11 +111,11 @@ var _ = Describe("Podman secret", func() {
 		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"secret", "inspect", "--format", "{{.ID}}", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal(secrID))
 	})
 
@@ -127,11 +127,11 @@ var _ = Describe("Podman secret", func() {
 		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"secret", "inspect", "--pretty", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(ContainSubstring("Name:"))
 		Expect(inspect.OutputToString()).To(ContainSubstring(secrID))
 	})
@@ -144,16 +144,16 @@ var _ = Describe("Podman secret", func() {
 		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session2 := podmanTest.Podman([]string{"secret", "create", "b", secretFilePath})
 		session2.WaitWithDefaultTimeout()
 		secrID2 := session2.OutputToString()
-		Expect(session2).Should(Exit(0))
+		Expect(session2).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"secret", "inspect", secrID, secrID2})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(BeValidJSON())
 	})
 
@@ -174,11 +174,11 @@ var _ = Describe("Podman secret", func() {
 
 		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		list := podmanTest.Podman([]string{"secret", "ls"})
 		list.WaitWithDefaultTimeout()
-		Expect(list).Should(Exit(0))
+		Expect(list).Should(ExitCleanly())
 		Expect(list.OutputToStringArray()).To(HaveLen(2))
 
 	})
@@ -192,23 +192,23 @@ var _ = Describe("Podman secret", func() {
 
 		session := podmanTest.Podman([]string{"secret", "create", secretName, secretFilePath})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		secretID := session.OutputToString()
 
 		list := podmanTest.Podman([]string{"secret", "ls", "-q"})
 		list.WaitWithDefaultTimeout()
-		Expect(list).Should(Exit(0))
+		Expect(list).Should(ExitCleanly())
 		Expect(list.OutputToString()).To(Equal(secretID))
 
 		list = podmanTest.Podman([]string{"secret", "ls", "--quiet"})
 		list.WaitWithDefaultTimeout()
-		Expect(list).Should(Exit(0))
+		Expect(list).Should(ExitCleanly())
 		Expect(list.OutputToString()).To(Equal(secretID))
 
 		// Prefer format over quiet
 		list = podmanTest.Podman([]string{"secret", "ls", "-q", "--format", "{{.Name}}"})
 		list.WaitWithDefaultTimeout()
-		Expect(list).Should(Exit(0))
+		Expect(list).Should(ExitCleanly())
 		Expect(list.OutputToString()).To(Equal(secretName))
 
 	})
@@ -223,55 +223,55 @@ var _ = Describe("Podman secret", func() {
 
 		session := podmanTest.Podman([]string{"secret", "ls", "-n"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Equal(""))
 
 		session = podmanTest.Podman([]string{"secret", "ls", "--noheading"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Equal(""))
 
 		session = podmanTest.Podman([]string{"secret", "create", secret1, secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID1 := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"secret", "create", secret2, secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID2 := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"secret", "create", "Secret3", secretFilePath})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		list := podmanTest.Podman([]string{"secret", "ls", "--filter", fmt.Sprintf("name=%s", secret1)})
 		list.WaitWithDefaultTimeout()
-		Expect(list).Should(Exit(0))
+		Expect(list).Should(ExitCleanly())
 		Expect(list.OutputToStringArray()).To(HaveLen(2))
 		Expect(list.OutputToStringArray()[1]).To(ContainSubstring(secret1))
 
 		list = podmanTest.Podman([]string{"secret", "ls", "--filter", fmt.Sprintf("name=%s", secret2)})
 		list.WaitWithDefaultTimeout()
-		Expect(list).Should(Exit(0))
+		Expect(list).Should(ExitCleanly())
 		Expect(list.OutputToStringArray()).To(HaveLen(2))
 		Expect(list.OutputToStringArray()[1]).To(ContainSubstring(secret2))
 
 		list = podmanTest.Podman([]string{"secret", "ls", "--filter", fmt.Sprintf("id=%s", secrID1)})
 		list.WaitWithDefaultTimeout()
-		Expect(list).Should(Exit(0))
+		Expect(list).Should(ExitCleanly())
 		Expect(list.OutputToStringArray()).To(HaveLen(2))
 		Expect(list.OutputToStringArray()[1]).To(ContainSubstring(secrID1))
 
 		list = podmanTest.Podman([]string{"secret", "ls", "--filter", fmt.Sprintf("id=%s", secrID2)})
 		list.WaitWithDefaultTimeout()
-		Expect(list).Should(Exit(0))
+		Expect(list).Should(ExitCleanly())
 		Expect(list.OutputToStringArray()).To(HaveLen(2))
 		Expect(list.OutputToStringArray()[1]).To(ContainSubstring(secrID2))
 
 		list = podmanTest.Podman([]string{"secret", "ls", "--filter", fmt.Sprintf("name=%s", secret1), "--filter", fmt.Sprintf("name=%s", secret2)})
 		list.WaitWithDefaultTimeout()
-		Expect(list).Should(Exit(0))
+		Expect(list).Should(ExitCleanly())
 		Expect(list.OutputToStringArray()).To(HaveLen(3))
 		Expect(list.OutputToString()).To(ContainSubstring(secret1))
 		Expect(list.OutputToString()).To(ContainSubstring(secret2))
@@ -284,12 +284,12 @@ var _ = Describe("Podman secret", func() {
 
 		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		list := podmanTest.Podman([]string{"secret", "ls", "--format", "table {{.Name}}"})
 		list.WaitWithDefaultTimeout()
 
-		Expect(list).Should(Exit(0))
+		Expect(list).Should(ExitCleanly())
 		Expect(list.OutputToStringArray()).To(HaveLen(2), list.OutputToString())
 	})
 
@@ -301,16 +301,16 @@ var _ = Describe("Podman secret", func() {
 		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		removed := podmanTest.Podman([]string{"secret", "rm", "a"})
 		removed.WaitWithDefaultTimeout()
-		Expect(removed).Should(Exit(0))
+		Expect(removed).Should(ExitCleanly())
 		Expect(removed.OutputToString()).To(Equal(secrID))
 
 		session = podmanTest.Podman([]string{"secret", "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(1))
 	})
 
@@ -321,30 +321,30 @@ var _ = Describe("Podman secret", func() {
 
 		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"secret", "create", "b", secretFilePath})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		removed := podmanTest.Podman([]string{"secret", "rm", "-a"})
 		removed.WaitWithDefaultTimeout()
-		Expect(removed).Should(Exit(0))
+		Expect(removed).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"secret", "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(1))
 	})
 
 	It("podman secret rm --ignore", func() {
 		remove := podmanTest.Podman([]string{"secret", "rm", "non-existent-secret"})
 		remove.WaitWithDefaultTimeout()
-		Expect(remove).Should(Not(Exit(0)))
+		Expect(remove).Should(Not(ExitCleanly()))
 		Expect(remove.ErrorToString()).To(Equal("Error: no secret with name or id \"non-existent-secret\": no such secret"))
 
 		ignoreRm := podmanTest.Podman([]string{"secret", "rm", "--ignore", "non-existent-secret"})
 		ignoreRm.WaitWithDefaultTimeout()
-		Expect(ignoreRm).Should(Exit(0))
+		Expect(ignoreRm).Should(ExitCleanly())
 		Expect(ignoreRm.ErrorToString()).To(BeEmpty())
 	})
 
@@ -362,11 +362,11 @@ var _ = Describe("Podman secret", func() {
 		session = podmanTest.Podman([]string{"secret", "create", "--env", "a", "MYENVVAR"})
 		session.WaitWithDefaultTimeout()
 		secrID := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"secret", "inspect", "--format", "{{.ID}}", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal(secrID))
 	})
 
@@ -378,32 +378,32 @@ var _ = Describe("Podman secret", func() {
 		session := podmanTest.Podman([]string{"secret", "create", "--label", "foo=bar", "a", secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		inspect := podmanTest.Podman([]string{"secret", "inspect", "--format", "{{.Spec.Labels}}", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(ContainSubstring("foo:bar"))
 
 		session = podmanTest.Podman([]string{"secret", "create", "--label", "foo=bar", "--label", "a:b", "b", secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID = session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		inspect = podmanTest.Podman([]string{"secret", "inspect", "--format", "{{.Spec.Labels}}", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(ContainSubstring("foo:bar"))
 		Expect(inspect.OutputToString()).To(ContainSubstring("a:b"))
 
 		session = podmanTest.Podman([]string{"secret", "create", "c", secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secrID = session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		inspect = podmanTest.Podman([]string{"secret", "inspect", "--format", "{{.Spec.Labels}}", secrID})
 		inspect.WaitWithDefaultTimeout()
-		Expect(inspect).Should(Exit(0))
+		Expect(inspect).Should(ExitCleanly())
 		Expect(inspect.OutputToString()).To(Equal("map[]"))
 
 	})
@@ -418,15 +418,15 @@ var _ = Describe("Podman secret", func() {
 		session := podmanTest.Podman([]string{"secret", "create", secretName, secretFilePath})
 		session.WaitWithDefaultTimeout()
 		secretID := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		exists := podmanTest.Podman([]string{"secret", "exists", secretName})
 		exists.WaitWithDefaultTimeout()
-		Expect(exists).Should(Exit(0))
+		Expect(exists).Should(ExitCleanly())
 
 		exists = podmanTest.Podman([]string{"secret", "exists", secretID})
 		exists.WaitWithDefaultTimeout()
-		Expect(exists).Should(Exit(0))
+		Expect(exists).Should(ExitCleanly())
 	})
 
 	It("podman secret exists should return false if secret does not exist", func() {
diff --git a/test/e2e/start_test.go b/test/e2e/start_test.go
index d527d384d0..6b8fb601f8 100644
--- a/test/e2e/start_test.go
+++ b/test/e2e/start_test.go
@@ -23,17 +23,17 @@ var _ = Describe("Podman start", func() {
 	It("podman start single container by id", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 		session = podmanTest.Podman([]string{"start", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman start --rm removed on failure", func() {
 		session := podmanTest.Podman([]string{"create", "--name=test", "--rm", ALPINE, "foo"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"start", "test"})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(125))
@@ -45,7 +45,7 @@ var _ = Describe("Podman start", func() {
 	It("podman start --rm --attach removed on failure", func() {
 		session := podmanTest.Podman([]string{"create", "--rm", ALPINE, "foo"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 		session = podmanTest.Podman([]string{"start", "--attach", cid})
 		session.WaitWithDefaultTimeout()
@@ -58,23 +58,23 @@ var _ = Describe("Podman start", func() {
 	It("podman container start single container by id", func() {
 		session := podmanTest.Podman([]string{"container", "create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 		session = podmanTest.Podman([]string{"container", "start", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Equal(cid))
 	})
 
 	It("podman container start single container by short id", func() {
 		session := podmanTest.Podman([]string{"container", "create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 		shortID := cid[0:10]
 		session = podmanTest.Podman([]string{"container", "start", shortID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Equal(shortID))
 	})
 
@@ -82,17 +82,17 @@ var _ = Describe("Podman start", func() {
 		name := "foobar99"
 		session := podmanTest.Podman([]string{"create", "--name", name, ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"start", name})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Equal(name))
 	})
 
 	It("podman start single container with attach and test the signal", func() {
 		session := podmanTest.Podman([]string{"create", "--entrypoint", "sh", ALPINE, "-c", "exit 1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 		session = podmanTest.Podman([]string{"start", "--attach", cid})
 		session.WaitWithDefaultTimeout()
@@ -109,7 +109,7 @@ var _ = Describe("Podman start", func() {
 		cid2 := session2.OutputToString()
 		session = podmanTest.Podman([]string{"start", cid1, cid2})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman start multiple containers with bogus", func() {
@@ -124,10 +124,10 @@ var _ = Describe("Podman start", func() {
 	It("podman multiple containers -- attach should fail", func() {
 		session := podmanTest.Podman([]string{"create", "--name", "foobar1", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"create", "--name", "foobar2", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"start", "-a", "foobar1", "foobar2"})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(125))
@@ -136,7 +136,7 @@ var _ = Describe("Podman start", func() {
 	It("podman failed to start with --rm should delete the container", func() {
 		session := podmanTest.Podman([]string{"create", "--name", "test1", "--rm", ALPINE, "foo"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		start := podmanTest.Podman([]string{"start", "test1"})
 		start.WaitWithDefaultTimeout()
@@ -151,7 +151,7 @@ var _ = Describe("Podman start", func() {
 	It("podman failed to start without --rm should NOT delete the container", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE, "foo"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		start := podmanTest.Podman([]string{"start", session.OutputToString()})
 		start.WaitWithDefaultTimeout()
@@ -163,7 +163,7 @@ var _ = Describe("Podman start", func() {
 	It("podman start --sig-proxy should not work without --attach", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"start", "-l", "--sig-proxy"})
 		session.WaitWithDefaultTimeout()
@@ -175,12 +175,12 @@ var _ = Describe("Podman start", func() {
 		pidfile := tempdir + "pidfile"
 		session := podmanTest.Podman([]string{"create", "--pidfile", pidfile, ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"start", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		readFirstLine := func(path string) string {
 			content, err := os.ReadFile(path)
 			Expect(err).ToNot(HaveOccurred())
@@ -194,48 +194,48 @@ var _ = Describe("Podman start", func() {
 	It("podman start container --filter", func() {
 		session1 := podmanTest.Podman([]string{"container", "create", ALPINE})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid1 := session1.OutputToString()
 
 		session1 = podmanTest.Podman([]string{"container", "create", ALPINE})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid2 := session1.OutputToString()
 
 		session1 = podmanTest.Podman([]string{"container", "create", ALPINE})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid3 := session1.OutputToString()
 		shortCid3 := cid3[0:5]
 
 		session1 = podmanTest.Podman([]string{"container", "create", "--label", "test=with,comma", ALPINE})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid4 := session1.OutputToString()
 
 		session1 = podmanTest.Podman([]string{"start", cid1, "-f", "status=running"})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEmpty())
 
 		session1 = podmanTest.Podman([]string{"start", "--all", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEmpty())
 
 		session1 = podmanTest.Podman([]string{"start", "--all", "--filter", fmt.Sprintf("id=%s", shortCid3)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
 
 		session1 = podmanTest.Podman([]string{"start", "--all", "--filter", "label=test=with,comma"})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid4))
 
 		session1 = podmanTest.Podman([]string{"start", "-f", fmt.Sprintf("id=%s", cid2)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid2))
 	})
 
@@ -244,27 +244,27 @@ var _ = Describe("Podman start", func() {
 		Expect(err).ToNot(HaveOccurred())
 		session := podmanTest.Podman([]string{"create", "--userns", "keep-id", "--user", "bin:bin", "--volume", fmt.Sprintf("%s:%s:ro", home, home), ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"start", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		env := session.OutputToString()
 		Expect(env).To(ContainSubstring("HOME"))
 		Expect(env).ToNot(ContainSubstring(fmt.Sprintf("HOME=%s", home)))
 
 		session = podmanTest.Podman([]string{"restart", "-t", "-1", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		env = session.OutputToString()
 		Expect(env).To(ContainSubstring("HOME"))
 		Expect(env).ToNot(ContainSubstring(fmt.Sprintf("HOME=%s", home)))
@@ -273,26 +273,26 @@ var _ = Describe("Podman start", func() {
 	It("podman start container sets HOME to home of execUser", func() {
 		session := podmanTest.Podman([]string{"create", "--userns", "keep-id", "--user", "bin:bin", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"start", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		env := session.OutputToString()
 		Expect(env).To(ContainSubstring("HOME=/bin"))
 
 		session = podmanTest.Podman([]string{"restart", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		env = session.OutputToString()
 		Expect(env).To(ContainSubstring("HOME=/bin"))
 	})
@@ -300,26 +300,26 @@ var _ = Describe("Podman start", func() {
 	It("podman start container retains the HOME env if present", func() {
 		session := podmanTest.Podman([]string{"create", "--userns", "keep-id", "--user", "bin:bin", "--env=HOME=/env/is/respected", ALPINE, "ls"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"start", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		env := session.OutputToString()
 		Expect(env).To(ContainSubstring("HOME=/env/is/respected"))
 
 		session = podmanTest.Podman([]string{"restart", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"inspect", cid, "--format", "{{.Config.Env}}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		env = session.OutputToString()
 		Expect(env).To(ContainSubstring("HOME=/env/is/respected"))
 	})
diff --git a/test/e2e/stats_test.go b/test/e2e/stats_test.go
index 8a34cffb00..b75bef339c 100644
--- a/test/e2e/stats_test.go
+++ b/test/e2e/stats_test.go
@@ -32,54 +32,54 @@ var _ = Describe("Podman stats", func() {
 	It("podman stats on a running container", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 		session = podmanTest.Podman([]string{"stats", "--no-stream", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman stats on all containers", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"stats", "--no-stream", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman stats on all running containers", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"stats", "--no-stream"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman stats only output cids", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"stats", "--all", "--no-trunc", "--no-stream", "--format", "\"{{.ID}}\""})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(len(session.OutputToStringArray()[0])).Should(BeEquivalentTo(66))
 	})
 
 	It("podman stats with GO template", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		stats := podmanTest.Podman([]string{"stats", "-a", "--no-reset", "--no-stream", "--format", "table {{.ID}} {{.AVGCPU}} {{.MemUsage}} {{.CPU}} {{.NetIO}} {{.BlockIO}} {{.PIDS}}"})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).To(Exit(0))
+		Expect(stats).To(ExitCleanly())
 	})
 
 	It("podman stats with invalid GO template", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		stats := podmanTest.Podman([]string{"stats", "-a", "--no-reset", "--no-stream", "--format", "\"table {{.ID}} {{.NoSuchField}} \""})
 		stats.WaitWithDefaultTimeout()
 		Expect(stats).To(ExitWithError())
@@ -88,7 +88,7 @@ var _ = Describe("Podman stats", func() {
 	It("podman stats with negative interval", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		stats := podmanTest.Podman([]string{"stats", "-a", "--no-reset", "--no-stream", "--interval=-1"})
 		stats.WaitWithDefaultTimeout()
 		Expect(stats).To(ExitWithError())
@@ -97,7 +97,7 @@ var _ = Describe("Podman stats", func() {
 	It("podman stats with zero interval", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		stats := podmanTest.Podman([]string{"stats", "-a", "--no-reset", "--no-stream", "--interval=0"})
 		stats.WaitWithDefaultTimeout()
 		Expect(stats).To(ExitWithError())
@@ -106,17 +106,17 @@ var _ = Describe("Podman stats", func() {
 	It("podman stats with interval", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		stats := podmanTest.Podman([]string{"stats", "-a", "--no-reset", "--no-stream", "--interval=5"})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 	})
 
 	It("podman stats with json output", func() {
 		var found bool
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		for i := 0; i < 5; i++ {
 			ps := podmanTest.Podman([]string{"ps", "-q"})
 			ps.WaitWithDefaultTimeout()
@@ -129,54 +129,54 @@ var _ = Describe("Podman stats", func() {
 		Expect(found).To(BeTrue(), "container has started")
 		stats := podmanTest.Podman([]string{"stats", "--all", "--no-stream", "--format", "json"})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 		Expect(stats.OutputToString()).To(BeValidJSON())
 	})
 
 	It("podman stats on a container with no net ns", func() {
 		session := podmanTest.Podman([]string{"run", "-d", "--net", "none", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"stats", "--no-stream", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman stats on a container that joined another's net ns", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"run", "-d", "--net", fmt.Sprintf("container:%s", cid), ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"stats", "--no-stream", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman stats on container with forced slirp4netns", func() {
 		// This will force the slirp4netns net mode to be tested as root
 		session := podmanTest.Podman([]string{"run", "-d", "--net", "slirp4netns", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"stats", "--no-stream", "-a"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman reads slirp4netns network stats", func() {
 		session := podmanTest.Podman([]string{"run", "-d", "--network", "slirp4netns", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		cid := session.OutputToString()
 
 		stats := podmanTest.Podman([]string{"stats", "--format", "'{{.NetIO}}'", "--no-stream", cid})
 		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(Exit(0))
+		Expect(stats).Should(ExitCleanly())
 		Expect(stats.OutputToString()).To(Not(ContainSubstring("-- / --")))
 	})
 
@@ -194,19 +194,19 @@ var _ = Describe("Podman stats", func() {
 
 		session := podmanTest.Podman([]string{"run", "-d", "--name", ctrNoLimit0, ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "-d", "--name", ctrNoLimit1, ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "-d", "--name", ctrWithLimit, "--memory", "50m", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"stats", "--no-stream", "--format", "{{.MemLimit}}", ctrNoLimit0, ctrNoLimit1, ctrWithLimit})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// We have three containers.  The unlimited ones need to have
 		// the same limit, the limited one a lower one.
@@ -227,11 +227,11 @@ var _ = Describe("Podman stats", func() {
 		ctr := "created_container"
 		session := podmanTest.Podman([]string{"create", "--name", ctr, ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"stats", "--no-stream", ctr})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman stats show cgroup memory limit", func() {
@@ -242,11 +242,11 @@ var _ = Describe("Podman stats", func() {
 
 		session := podmanTest.Podman([]string{"run", "-d", "--name", ctrWithLimit, "--memory", "50m", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"stats", "--no-stream", "--format", "{{.MemLimit}}", ctrWithLimit})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		limit, err := strconv.Atoi(session.OutputToString())
 		Expect(err).ToNot(HaveOccurred())
@@ -254,11 +254,11 @@ var _ = Describe("Podman stats", func() {
 
 		session = podmanTest.Podman([]string{"container", "update", ctrWithLimit, "--memory", "100m"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"stats", "--no-stream", "--format", "{{.MemLimit}}", ctrWithLimit})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		limit, err = strconv.Atoi(session.OutputToString())
 		Expect(err).ToNot(HaveOccurred())
@@ -268,7 +268,7 @@ var _ = Describe("Podman stats", func() {
 	It("podman stats --all", func() {
 		runningContainersession := podmanTest.RunTopContainer("")
 		runningContainersession.WaitWithDefaultTimeout()
-		Expect(runningContainersession).Should(Exit(0))
+		Expect(runningContainersession).Should(ExitCleanly())
 		runningCtrID := runningContainersession.OutputToString()[0:12]
 
 		createdContainerSession, _, _ := podmanTest.CreatePod(map[string][]string{
@@ -276,26 +276,26 @@ var _ = Describe("Podman stats", func() {
 		})
 
 		createdContainerSession.WaitWithDefaultTimeout()
-		Expect(createdContainerSession).Should(Exit(0))
+		Expect(createdContainerSession).Should(ExitCleanly())
 
 		sessionAll := podmanTest.Podman([]string{"stats", "--no-stream", "--format", "{{.ID}}"})
 		sessionAll.WaitWithDefaultTimeout()
-		Expect(sessionAll).Should(Exit(0))
+		Expect(sessionAll).Should(ExitCleanly())
 		Expect(sessionAll.OutputToString()).Should(Equal(runningCtrID))
 
 		sessionAll = podmanTest.Podman([]string{"stats", "--no-stream", "--all=false", "--format", "{{.ID}}"})
 		sessionAll.WaitWithDefaultTimeout()
-		Expect(sessionAll).Should(Exit(0))
+		Expect(sessionAll).Should(ExitCleanly())
 		Expect(sessionAll.OutputToString()).Should(Equal(runningCtrID))
 
 		sessionAll = podmanTest.Podman([]string{"stats", "--all=true", "--no-stream", "--format", "{{.ID}}"})
 		sessionAll.WaitWithDefaultTimeout()
-		Expect(sessionAll).Should(Exit(0))
+		Expect(sessionAll).Should(ExitCleanly())
 		Expect(sessionAll.OutputToStringArray()).Should(HaveLen(2))
 
 		sessionAll = podmanTest.Podman([]string{"stats", "--all", "--no-stream", "--format", "{{.ID}}"})
 		sessionAll.WaitWithDefaultTimeout()
-		Expect(sessionAll).Should(Exit(0))
+		Expect(sessionAll).Should(ExitCleanly())
 		Expect(sessionAll.OutputToStringArray()).Should(HaveLen(2))
 	})
 })
diff --git a/test/e2e/stop_test.go b/test/e2e/stop_test.go
index 10c3de406f..6c01ad452c 100644
--- a/test/e2e/stop_test.go
+++ b/test/e2e/stop_test.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"strings"
 
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
@@ -20,12 +21,12 @@ var _ = Describe("Podman stop", func() {
 	It("podman stop --ignore bogus container", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"stop", "--ignore", "foobar", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		output := session.OutputToString()
 		Expect(output).To(ContainSubstring(cid))
 	})
@@ -33,103 +34,103 @@ var _ = Describe("Podman stop", func() {
 	It("podman stop container by id", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 		session = podmanTest.Podman([]string{"stop", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
 		finalCtrs.WaitWithDefaultTimeout()
-		Expect(finalCtrs).Should(Exit(0))
+		Expect(finalCtrs).Should(ExitCleanly())
 		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
 	})
 
 	It("podman stop single container by short id", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 		shortID := cid[0:10]
 
 		session = podmanTest.Podman([]string{"stop", shortID})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Equal(shortID))
 	})
 
 	It("podman stop container by name", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"stop", "test1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
 		finalCtrs.WaitWithDefaultTimeout()
-		Expect(finalCtrs).Should(Exit(0))
+		Expect(finalCtrs).Should(ExitCleanly())
 		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
 	})
 
 	It("podman container stop by name", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"container", "stop", "test1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
 		finalCtrs.WaitWithDefaultTimeout()
-		Expect(finalCtrs).Should(Exit(0))
+		Expect(finalCtrs).Should(ExitCleanly())
 		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
 	})
 
 	It("podman stop stopped container", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session2 := podmanTest.Podman([]string{"stop", "test1"})
 		session2.WaitWithDefaultTimeout()
-		Expect(session2).Should(Exit(0))
+		Expect(session2).Should(ExitCleanly())
 
 		session3 := podmanTest.Podman([]string{"stop", "test1"})
 		session3.WaitWithDefaultTimeout()
-		Expect(session3).Should(Exit(0))
+		Expect(session3).Should(ExitCleanly())
 
 		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
 		finalCtrs.WaitWithDefaultTimeout()
-		Expect(finalCtrs).Should(Exit(0))
+		Expect(finalCtrs).Should(ExitCleanly())
 		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
 
 		// make sure we only have one cleanup event for this container
 		events := podmanTest.Podman([]string{"events", "--since=30s", "--stream=false"})
 		events.WaitWithDefaultTimeout()
-		Expect(events).Should(Exit(0))
+		Expect(events).Should(ExitCleanly())
 		Expect(strings.Count(events.OutputToString(), "container cleanup")).To(Equal(1), "cleanup event should show up exactly once")
 	})
 
 	It("podman stop all containers -t", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid1 := session.OutputToString()
 
 		session = podmanTest.RunTopContainer("test2")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid2 := session.OutputToString()
 
 		session = podmanTest.RunTopContainer("test3")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid3 := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"stop", "-a", "-t", "1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		output := session.OutputToString()
 		Expect(output).To(ContainSubstring(cid1))
 		Expect(output).To(ContainSubstring(cid2))
@@ -137,42 +138,42 @@ var _ = Describe("Podman stop", func() {
 
 		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
 		finalCtrs.WaitWithDefaultTimeout()
-		Expect(finalCtrs).Should(Exit(0))
+		Expect(finalCtrs).Should(ExitCleanly())
 		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
 	})
 
 	It("podman stop container --time", func() {
 		session := podmanTest.RunTopContainer("test4")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"stop", "--time", "0", "test4"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		output := session.OutputToString()
 		Expect(output).To(ContainSubstring("test4"))
 
 		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
 		finalCtrs.WaitWithDefaultTimeout()
-		Expect(finalCtrs).Should(Exit(0))
+		Expect(finalCtrs).Should(ExitCleanly())
 		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
 	})
 
 	It("podman stop container --timeout", func() {
 		session := podmanTest.Podman([]string{"run", "-d", "--name", "test5", ALPINE, "sleep", "100"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"stop", "--timeout", "0", "test5"})
 		// Without timeout container stops in 10 seconds
 		// If not stopped in 5 seconds, then --timeout did not work
 		session.Wait(5)
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		output := session.OutputToString()
 		Expect(output).To(ContainSubstring("test5"))
 
 		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
 		finalCtrs.WaitWithDefaultTimeout()
-		Expect(finalCtrs).Should(Exit(0))
+		Expect(finalCtrs).Should(ExitCleanly())
 		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
 	})
 
@@ -180,10 +181,10 @@ var _ = Describe("Podman stop", func() {
 		SkipIfRemote("warning will happen only on server side")
 		session := podmanTest.Podman([]string{"run", "-d", "--name", "test5", ALPINE, "sleep", "100"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"stop", "--timeout", "1", "test5"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		warning := session.ErrorToString()
 		Expect(warning).To(ContainSubstring("StopSignal SIGTERM failed to stop container test5 in 1 seconds, resorting to SIGKILL"))
 	})
@@ -192,56 +193,56 @@ var _ = Describe("Podman stop", func() {
 		SkipIfRemote("--latest flag n/a")
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		session = podmanTest.Podman([]string{"stop", "-l", "-t", "1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(Equal(cid))
 
 		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
 		finalCtrs.WaitWithDefaultTimeout()
-		Expect(finalCtrs).Should(Exit(0))
+		Expect(finalCtrs).Should(ExitCleanly())
 		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
 	})
 
 	It("podman stop all containers with one stopped", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session2 := podmanTest.RunTopContainer("test2")
 		session2.WaitWithDefaultTimeout()
-		Expect(session2).Should(Exit(0))
+		Expect(session2).Should(ExitCleanly())
 		cid := "-l"
 		if IsRemote() {
 			cid = "test2"
 		}
 		session3 := podmanTest.Podman([]string{"stop", cid, "-t", "1"})
 		session3.WaitWithDefaultTimeout()
-		Expect(session3).Should(Exit(0))
+		Expect(session3).Should(ExitCleanly())
 		session4 := podmanTest.Podman([]string{"stop", "-a", "-t", "1"})
 		session4.WaitWithDefaultTimeout()
-		Expect(session4).Should(Exit(0))
+		Expect(session4).Should(ExitCleanly())
 		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
 		finalCtrs.WaitWithDefaultTimeout()
-		Expect(finalCtrs).Should(Exit(0))
+		Expect(finalCtrs).Should(ExitCleanly())
 		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
 	})
 
 	It("podman stop all containers with one created", func() {
 		session := podmanTest.RunTopContainer("test1")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session2 := podmanTest.Podman([]string{"create", ALPINE, "/bin/sh"})
 		session2.WaitWithDefaultTimeout()
-		Expect(session2).Should(Exit(0))
+		Expect(session2).Should(ExitCleanly())
 		session3 := podmanTest.Podman([]string{"stop", "-a", "-t", "1"})
 		session3.WaitWithDefaultTimeout()
-		Expect(session3).Should(Exit(0))
+		Expect(session3).Should(ExitCleanly())
 		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
 		finalCtrs.WaitWithDefaultTimeout()
-		Expect(finalCtrs).Should(Exit(0))
+		Expect(finalCtrs).Should(ExitCleanly())
 		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
 	})
 
@@ -250,10 +251,10 @@ var _ = Describe("Podman stop", func() {
 		// so we return success and assume that it is stopped
 		session2 := podmanTest.Podman([]string{"create", "--name", "stopctr", ALPINE, "/bin/sh"})
 		session2.WaitWithDefaultTimeout()
-		Expect(session2).Should(Exit(0))
+		Expect(session2).Should(ExitCleanly())
 		session3 := podmanTest.Podman([]string{"stop", "stopctr"})
 		session3.WaitWithDefaultTimeout()
-		Expect(session3).Should(Exit(0))
+		Expect(session3).Should(ExitCleanly())
 	})
 
 	It("podman stop --cidfile", func() {
@@ -262,16 +263,16 @@ var _ = Describe("Podman stop", func() {
 
 		session := podmanTest.Podman([]string{"create", "--cidfile", tmpFile, ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToStringArray()[0]
 
 		session = podmanTest.Podman([]string{"start", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"stop", "--cidfile", tmpFile})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		output := result.OutputToString()
 		Expect(output).To(ContainSubstring(cid))
 	})
@@ -283,19 +284,19 @@ var _ = Describe("Podman stop", func() {
 
 		session := podmanTest.Podman([]string{"run", "--cidfile", tmpFile1, "-d", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid1 := session.OutputToStringArray()[0]
 		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
 
 		session = podmanTest.Podman([]string{"run", "--cidfile", tmpFile2, "-d", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid2 := session.OutputToStringArray()[0]
 		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
 
 		result := podmanTest.Podman([]string{"stop", "--cidfile", tmpFile1, "--cidfile", tmpFile2})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		output := result.OutputToString()
 		Expect(output).To(ContainSubstring(cid1))
 		Expect(output).To(ContainSubstring(cid2))
@@ -325,24 +326,24 @@ var _ = Describe("Podman stop", func() {
 	It("podman stop --all", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 
 		session = podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2))
 
 		session = podmanTest.Podman([]string{"stop", "--all"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
 	It("podman stop --ignore", func() {
 		session := podmanTest.RunTopContainer("")
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
 
@@ -352,35 +353,35 @@ var _ = Describe("Podman stop", func() {
 
 		session = podmanTest.Podman([]string{"stop", "--ignore", "bogus", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
 	})
 
 	It("podman stop --filter", func() {
 		session1 := podmanTest.Podman([]string{"container", "create", ALPINE})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid1 := session1.OutputToString()
 
 		session1 = podmanTest.Podman([]string{"container", "create", ALPINE})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid2 := session1.OutputToString()
 
 		session1 = podmanTest.Podman([]string{"container", "create", ALPINE})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid3 := session1.OutputToString()
 		shortCid3 := cid3[0:5]
 
 		session1 = podmanTest.Podman([]string{"container", "create", "--label", "test=with,comma", ALPINE})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		cid4 := session1.OutputToString()
 
 		session1 = podmanTest.Podman([]string{"start", "--all"})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 
 		session1 = podmanTest.Podman([]string{"stop", cid1, "-f", "status=running"})
 		session1.WaitWithDefaultTimeout()
@@ -388,22 +389,22 @@ var _ = Describe("Podman stop", func() {
 
 		session1 = podmanTest.Podman([]string{"stop", "-a", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEmpty())
 
 		session1 = podmanTest.Podman([]string{"stop", "-a", "--filter", fmt.Sprintf("id=%s", shortCid3)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
 
 		session1 = podmanTest.Podman([]string{"stop", "-a", "--filter", "label=test=with,comma"})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid4))
 
 		session1 = podmanTest.Podman([]string{"stop", "-f", fmt.Sprintf("id=%s", cid2)})
 		session1.WaitWithDefaultTimeout()
-		Expect(session1).Should(Exit(0))
+		Expect(session1).Should(ExitCleanly())
 		Expect(session1.OutputToString()).To(BeEquivalentTo(cid2))
 	})
 })
diff --git a/test/e2e/system_df_test.go b/test/e2e/system_df_test.go
index 0a0c80fff4..11ec4864e8 100644
--- a/test/e2e/system_df_test.go
+++ b/test/e2e/system_df_test.go
@@ -7,7 +7,6 @@ import (
 	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("podman system df", func() {
@@ -15,30 +14,30 @@ var _ = Describe("podman system df", func() {
 	It("podman system df", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// run two containers with volumes to create something in the volume
 		session = podmanTest.Podman([]string{"run", "-v", "data1:/data", "--name", "container1", BB, "sh", "-c", "echo test > /data/1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"run", "-v", "data2:/data", "--name", "container2", BB, "sh", "-c", "echo test > /data/1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// remove one container, we keep the volume
 		session = podmanTest.Podman([]string{"rm", "container2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"images", "-q"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		totImages := strconv.Itoa(len(session.OutputToStringArray()))
 
 		session = podmanTest.Podman([]string{"system", "df"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(HaveLen(4))
 		images := strings.Fields(session.OutputToStringArray()[1])
 		containers := strings.Fields(session.OutputToStringArray()[2])
@@ -50,10 +49,10 @@ var _ = Describe("podman system df", func() {
 
 		session = podmanTest.Podman([]string{"rm", "container1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"system", "df"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		volumes = strings.Fields(session.OutputToStringArray()[3])
 		// percentages on volumes were being calculated incorrectly. Make sure we only report 100% and not above
 		Expect(volumes[6]).To(Equal("(100%)"), "percentage usage expected")
@@ -64,25 +63,25 @@ var _ = Describe("podman system df", func() {
 		podmanTest.AddImageToRWStore(ALPINE)
 		session := podmanTest.Podman([]string{"create", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"image", "untag", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"system", "df"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman system df --format \"{{ json . }}\"", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"system", "df", "--format", "{{ json . }}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("Size"))
 		Expect(session.OutputToString()).To(ContainSubstring("Reclaimable"))
 
@@ -103,11 +102,11 @@ var _ = Describe("podman system df", func() {
 	It("podman system df --format json", func() {
 		session := podmanTest.Podman([]string{"create", ALPINE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"system", "df", "--format", "json"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToString()).To(ContainSubstring("Size"))
 		Expect(session.OutputToString()).To(ContainSubstring("Reclaimable"))
 		Expect(session.OutputToString()).To(BeValidJSON())
diff --git a/test/e2e/tag_test.go b/test/e2e/tag_test.go
index 19b984ab23..235075542b 100644
--- a/test/e2e/tag_test.go
+++ b/test/e2e/tag_test.go
@@ -1,9 +1,9 @@
 package integration
 
 import (
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("Podman tag", func() {
@@ -15,11 +15,11 @@ var _ = Describe("Podman tag", func() {
 	It("podman tag shortname:latest", func() {
 		session := podmanTest.Podman([]string{"tag", ALPINE, "foobar:latest"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		results := podmanTest.Podman([]string{"inspect", "foobar:latest"})
 		results.WaitWithDefaultTimeout()
-		Expect(results).Should(Exit(0))
+		Expect(results).Should(ExitCleanly())
 		inspectData := results.InspectImageJSON()
 		Expect(inspectData[0].RepoTags).To(ContainElement("quay.io/libpod/alpine:latest"))
 		Expect(inspectData[0].RepoTags).To(ContainElement("localhost/foobar:latest"))
@@ -28,11 +28,11 @@ var _ = Describe("Podman tag", func() {
 	It("podman tag shortname", func() {
 		session := podmanTest.Podman([]string{"tag", ALPINE, "foobar"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		results := podmanTest.Podman([]string{"inspect", "foobar:latest"})
 		results.WaitWithDefaultTimeout()
-		Expect(results).Should(Exit(0))
+		Expect(results).Should(ExitCleanly())
 		inspectData := results.InspectImageJSON()
 		Expect(inspectData[0].RepoTags).To(ContainElement("quay.io/libpod/alpine:latest"))
 		Expect(inspectData[0].RepoTags).To(ContainElement("localhost/foobar:latest"))
@@ -41,11 +41,11 @@ var _ = Describe("Podman tag", func() {
 	It("podman tag shortname:tag", func() {
 		session := podmanTest.Podman([]string{"tag", ALPINE, "foobar:new"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		results := podmanTest.Podman([]string{"inspect", "foobar:new"})
 		results.WaitWithDefaultTimeout()
-		Expect(results).Should(Exit(0))
+		Expect(results).Should(ExitCleanly())
 		inspectData := results.InspectImageJSON()
 		Expect(inspectData[0].RepoTags).To(ContainElement("quay.io/libpod/alpine:latest"))
 		Expect(inspectData[0].RepoTags).To(ContainElement("localhost/foobar:new"))
@@ -54,14 +54,14 @@ var _ = Describe("Podman tag", func() {
 	It("podman tag shortname image no tag", func() {
 		session := podmanTest.Podman([]string{"tag", ALPINE, "foobar"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		results := podmanTest.Podman([]string{"tag", "foobar", "barfoo"})
 		results.WaitWithDefaultTimeout()
-		Expect(results).Should(Exit(0))
+		Expect(results).Should(ExitCleanly())
 
 		verify := podmanTest.Podman([]string{"inspect", "barfoo"})
 		verify.WaitWithDefaultTimeout()
-		Expect(verify).Should(Exit(0))
+		Expect(verify).Should(ExitCleanly())
 	})
 })
diff --git a/test/e2e/top_test.go b/test/e2e/top_test.go
index 02600218e2..f876ded44b 100644
--- a/test/e2e/top_test.go
+++ b/test/e2e/top_test.go
@@ -4,6 +4,7 @@ import (
 	"os"
 	"os/user"
 
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
@@ -34,44 +35,44 @@ var _ = Describe("Podman top", func() {
 	It("podman top on container", func() {
 		session := podmanTest.Podman([]string{"run", "--name", "test", "-d", ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"top", "test"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(len(result.OutputToStringArray())).To(BeNumerically(">", 1))
 	})
 
 	It("podman container top on container", func() {
 		session := podmanTest.Podman([]string{"container", "run", "--name", "test", "-d", ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"container", "top", "test"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(len(result.OutputToStringArray())).To(BeNumerically(">", 1))
 
 		// Just a smoke test since groups may change over time.
 		result = podmanTest.Podman([]string{"container", "top", "test", "groups", "hgroups"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(len(result.OutputToStringArray())).To(BeNumerically(">", 1))
 	})
 
 	It("podman top with options", func() {
 		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"top", session.OutputToString(), "pid", "%C", "args"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(len(result.OutputToStringArray())).To(BeNumerically(">", 1))
 
 		result = podmanTest.Podman([]string{"container", "top", session.OutputToString(), "uid"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(len(result.OutputToStringArray())).To(BeNumerically(">", 1))
 		Expect(result.OutputToStringArray()[1]).To(Equal("0"))
 
@@ -82,7 +83,7 @@ var _ = Describe("Podman top", func() {
 
 		result = podmanTest.Podman([]string{"container", "top", session.OutputToString(), "huid"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(len(result.OutputToStringArray())).To(BeNumerically(">", 1))
 		Expect(result.OutputToStringArray()[1]).To(Equal(user.Uid))
 	})
@@ -90,22 +91,22 @@ var _ = Describe("Podman top", func() {
 	It("podman top with ps(1) options", func() {
 		session := podmanTest.Podman([]string{"run", "-d", fedoraMinimal, "sleep", "inf"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"top", session.OutputToString(), "aux"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(len(result.OutputToStringArray())).To(BeNumerically(">", 1))
 
 		result = podmanTest.Podman([]string{"top", session.OutputToString(), "ax -o args"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).To(Equal([]string{"COMMAND", "sleep inf"}))
 
 		// Now make sure we use ps in the container with CAP_SYS_PTRACE
 		session = podmanTest.Podman([]string{"run", "-d", "--cap-add=SYS_PTRACE", fedoraMinimal, "sleep", "inf"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Because the image does not contain this must fail and we know we use the correct podman exec fallback.
 		exec := podmanTest.Podman([]string{"top", session.OutputToString(), "aux"})
@@ -117,18 +118,18 @@ var _ = Describe("Podman top", func() {
 	It("podman top with comma-separated options", func() {
 		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "top", "-d", "2"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		result := podmanTest.Podman([]string{"top", session.OutputToString(), "user,pid,comm"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(len(result.OutputToStringArray())).To(BeNumerically(">", 1))
 	})
 
 	It("podman top on container invalid options", func() {
 		top := podmanTest.RunTopContainer("")
 		top.WaitWithDefaultTimeout()
-		Expect(top).Should(Exit(0))
+		Expect(top).Should(ExitCleanly())
 		cid := top.OutputToString()
 
 		// We need to pass -eo to force executing ps in the Alpine container.
@@ -143,12 +144,12 @@ var _ = Describe("Podman top", func() {
 	It("podman top on privileged container", func() {
 		session := podmanTest.Podman([]string{"run", "--privileged", "-d", ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid := session.OutputToString()
 
 		result := podmanTest.Podman([]string{"top", cid, "capeff"})
 		result.WaitWithDefaultTimeout()
-		Expect(result).Should(Exit(0))
+		Expect(result).Should(ExitCleanly())
 		Expect(result.OutputToStringArray()).To(Equal([]string{"EFFECTIVE CAPS", "full"}))
 	})
 })
diff --git a/test/e2e/tree_test.go b/test/e2e/tree_test.go
index 52eae4511d..119a25def8 100644
--- a/test/e2e/tree_test.go
+++ b/test/e2e/tree_test.go
@@ -1,9 +1,9 @@
 package integration
 
 import (
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gexec"
 )
 
 var _ = Describe("Podman image tree", func() {
@@ -24,16 +24,16 @@ ENV foo=bar
 
 		session := podmanTest.Podman([]string{"image", "tree", "test:latest"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"image", "tree", "--whatrequires", "quay.io/libpod/cirros:latest"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"rmi", "test:latest"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"rmi", "quay.io/libpod/cirros:latest"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 })
diff --git a/test/e2e/untag_test.go b/test/e2e/untag_test.go
index e0b0fe26f0..060b1168c4 100644
--- a/test/e2e/untag_test.go
+++ b/test/e2e/untag_test.go
@@ -1,6 +1,7 @@
 package integration
 
 import (
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
@@ -16,19 +17,19 @@ var _ = Describe("Podman untag", func() {
 		cmd = append(cmd, tags...)
 		session := podmanTest.Podman(cmd)
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Make sure that all tags exists.
 		for _, t := range tags {
 			session = podmanTest.Podman([]string{"image", "exists", t})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 		}
 
 		// No arguments -> remove all tags.
 		session = podmanTest.Podman([]string{"untag", CIRROS_IMAGE})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		// Make sure that none of tags exists anymore.
 		for _, t := range tags {
@@ -55,15 +56,15 @@ var _ = Describe("Podman untag", func() {
 		for _, tt := range tests {
 			session := podmanTest.Podman([]string{"tag", CIRROS_IMAGE, tt.tag})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 
 			session = podmanTest.Podman([]string{"image", "exists", tt.normalized})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 
 			session = podmanTest.Podman([]string{"untag", CIRROS_IMAGE, tt.tag})
 			session.WaitWithDefaultTimeout()
-			Expect(session).Should(Exit(0))
+			Expect(session).Should(ExitCleanly())
 
 			session = podmanTest.Podman([]string{"image", "exists", tt.normalized})
 			session.WaitWithDefaultTimeout()
diff --git a/test/e2e/version_test.go b/test/e2e/version_test.go
index c946f0636a..aaf4211d4c 100644
--- a/test/e2e/version_test.go
+++ b/test/e2e/version_test.go
@@ -3,6 +3,7 @@ package integration
 import (
 	"fmt"
 
+	. "github.com/containers/podman/v4/test/utils"
 	"github.com/containers/podman/v4/version"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -14,21 +15,21 @@ var _ = Describe("Podman version", func() {
 	It("podman version", func() {
 		session := podmanTest.Podman([]string{"version"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.Out.Contents()).Should(ContainSubstring(version.Version.String()))
 	})
 
 	It("podman -v", func() {
 		session := podmanTest.Podman([]string{"-v"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.Out.Contents()).Should(ContainSubstring(version.Version.String()))
 	})
 
 	It("podman --version", func() {
 		session := podmanTest.Podman([]string{"--version"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.Out.Contents()).Should(ContainSubstring(version.Version.String()))
 	})
 
@@ -63,29 +64,29 @@ var _ = Describe("Podman version", func() {
 	It("podman version --format GO template", func() {
 		session := podmanTest.Podman([]string{"version", "--format", "{{ .Client.Version }}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"version", "--format", "{{ .Client.Os }}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"version", "--format", "{{ .Server.Version }}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"version", "--format", "{{ .Server.Os }}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 
 		session = podmanTest.Podman([]string{"version", "--format", "{{ .Version }}"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman help", func() {
 		session := podmanTest.Podman([]string{"help"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.Out.Contents()).Should(
 			ContainSubstring("Display the Podman version information"),
 		)
diff --git a/test/e2e/wait_test.go b/test/e2e/wait_test.go
index 28dc35dd5f..2620d235d9 100644
--- a/test/e2e/wait_test.go
+++ b/test/e2e/wait_test.go
@@ -1,6 +1,7 @@
 package integration
 
 import (
+	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
@@ -19,70 +20,70 @@ var _ = Describe("Podman wait", func() {
 		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "ls"})
 		session.Wait(10)
 		cid := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"wait", cid})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman wait on a sleeping container", func() {
 		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "sleep", "1"})
 		session.Wait(20)
 		cid := session.OutputToString()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"wait", cid})
 		session.Wait(20)
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman wait on latest container", func() {
 		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "sleep", "1"})
 		session.Wait(20)
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		if IsRemote() {
 			session = podmanTest.Podman([]string{"wait", session.OutputToString()})
 		} else {
 			session = podmanTest.Podman([]string{"wait", "-l"})
 		}
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman container wait on latest container", func() {
 		session := podmanTest.Podman([]string{"container", "run", "-d", ALPINE, "sleep", "1"})
 		session.Wait(20)
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		if IsRemote() {
 			session = podmanTest.Podman([]string{"container", "wait", session.OutputToString()})
 		} else {
 			session = podmanTest.Podman([]string{"container", "wait", "-l"})
 		}
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman container wait on latest container with --interval flag", func() {
 		session := podmanTest.Podman([]string{"container", "run", "-d", ALPINE, "sleep", "1"})
 		session.Wait(20)
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"container", "wait", "-i", "5000", session.OutputToString()})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman container wait on latest container with --interval flag", func() {
 		session := podmanTest.Podman([]string{"container", "run", "-d", ALPINE, "sleep", "1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"container", "wait", "--interval", "1s", session.OutputToString()})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 	})
 
 	It("podman container wait on container with bogus --interval", func() {
 		session := podmanTest.Podman([]string{"container", "run", "-d", ALPINE, "sleep", "1"})
 		session.WaitWithDefaultTimeout()
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		session = podmanTest.Podman([]string{"container", "wait", "--interval", "100days", session.OutputToString()})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(125))
@@ -91,19 +92,19 @@ var _ = Describe("Podman wait", func() {
 	It("podman wait on three containers", func() {
 		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "sleep", "1"})
 		session.Wait(20)
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid1 := session.OutputToString()
 		session = podmanTest.Podman([]string{"run", "-d", ALPINE, "sleep", "1"})
 		session.Wait(20)
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid2 := session.OutputToString()
 		session = podmanTest.Podman([]string{"run", "-d", ALPINE, "sleep", "1"})
 		session.Wait(20)
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		cid3 := session.OutputToString()
 		session = podmanTest.Podman([]string{"wait", cid1, cid2, cid3})
 		session.Wait(20)
-		Expect(session).Should(Exit(0))
+		Expect(session).Should(ExitCleanly())
 		Expect(session.OutputToStringArray()).To(Equal([]string{"0", "0", "0"}))
 	})
 })