netavark e2e tests

enabled e2e tests for netavark

Signed-off-by: Brent Baude <bbaude@redhat.com>

17 files changed, 326 insertions, 190 deletions

diff --git a/test/e2e/common_test.go b/test/e2e/common_test.go
index 796ae8141..f843a8984 100644
--- a/test/e2e/common_test.go
+++ b/test/e2e/common_test.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"math/rand"
+	"net"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -46,7 +47,7 @@ type PodmanTestIntegration struct {
 	PodmanTest
 	ConmonBinary        string
 	Root                string
-	CNIConfigDir        string
+	NetworkConfigDir    string
 	OCIRuntime          string
 	RunRoot             string
 	StorageOptions      string
@@ -199,6 +200,7 @@ func PodmanTestCreateUtil(tempDir string, remote bool) *PodmanTestIntegration {
 	host := GetHostDistributionInfo()
 	cwd, _ := os.Getwd()
 
+	root := filepath.Join(tempDir, "root")
 	podmanBinary := filepath.Join(cwd, "../../bin/podman")
 	if os.Getenv("PODMAN_BINARY") != "" {
 		podmanBinary = os.Getenv("PODMAN_BINARY")
@@ -235,11 +237,26 @@ func PodmanTestCreateUtil(tempDir string, remote bool) *PodmanTestIntegration {
 		ociRuntime = "crun"
 	}
 	os.Setenv("DISABLE_HC_SYSTEMD", "true")
-	CNIConfigDir := "/etc/cni/net.d"
+
+	networkBackend := CNI
+	networkConfigDir := "/etc/cni/net.d"
 	if rootless.IsRootless() {
-		CNIConfigDir = filepath.Join(os.Getenv("HOME"), ".config/cni/net.d")
+		networkConfigDir = filepath.Join(os.Getenv("HOME"), ".config/cni/net.d")
 	}
-	if err := os.MkdirAll(CNIConfigDir, 0755); err != nil {
+
+	if strings.ToLower(os.Getenv("NETWORK_BACKEND")) == "netavark" {
+		networkBackend = Netavark
+		networkConfigDir = "/etc/containers/networks"
+		if rootless.IsRootless() {
+			networkConfigDir = filepath.Join(root, "etc", "networks")
+		}
+	}
+
+	if err := os.MkdirAll(root, 0755); err != nil {
+		panic(err)
+	}
+
+	if err := os.MkdirAll(networkConfigDir, 0755); err != nil {
 		panic(err)
 	}
 
@@ -251,7 +268,6 @@ func PodmanTestCreateUtil(tempDir string, remote bool) *PodmanTestIntegration {
 		storageFs = os.Getenv("STORAGE_FS")
 		storageOptions = "--storage-driver " + storageFs
 	}
-
 	p := &PodmanTestIntegration{
 		PodmanTest: PodmanTest{
 			PodmanBinary:       podmanBinary,
@@ -260,11 +276,12 @@ func PodmanTestCreateUtil(tempDir string, remote bool) *PodmanTestIntegration {
 			RemoteTest:         remote,
 			ImageCacheFS:       storageFs,
 			ImageCacheDir:      ImageCacheDir,
+			NetworkBackend:     networkBackend,
 		},
 		ConmonBinary:        conmonBinary,
-		Root:                filepath.Join(tempDir, "root"),
+		Root:                root,
 		TmpDir:              tempDir,
-		CNIConfigDir:        CNIConfigDir,
+		NetworkConfigDir:    networkConfigDir,
 		OCIRuntime:          ociRuntime,
 		RunRoot:             filepath.Join(tempDir, "runroot"),
 		StorageOptions:      storageOptions,
@@ -754,6 +771,18 @@ func SkipIfNotActive(unit string, reason string) {
 	}
 }
 
+func SkipIfNetavark(p *PodmanTestIntegration) {
+	if p.NetworkBackend == Netavark {
+		Skip("This test is not compatible with the netavark network backend")
+	}
+}
+
+func SkipUntilAardvark(p *PodmanTestIntegration) {
+	if p.NetworkBackend == Netavark {
+		Skip("Re-enable when aardvark is functional")
+	}
+}
+
 // PodmanAsUser is the exec call to podman on the filesystem with the specified uid/gid and environment
 func (p *PodmanTestIntegration) PodmanAsUser(args []string, uid, gid uint32, cwd string, env []string) *PodmanSessionIntegration {
 	podmanSession := p.PodmanAsUserBase(args, uid, gid, cwd, env, false, false, nil, nil)
@@ -815,7 +844,9 @@ func (p *PodmanTestIntegration) makeOptions(args []string, noEvents, noCache boo
 	if p.RemoteTest {
 		return args
 	}
-	var debug string
+	var (
+		debug string
+	)
 	if _, ok := os.LookupEnv("DEBUG"); ok {
 		debug = "--log-level=debug --syslog=true "
 	}
@@ -825,12 +856,19 @@ func (p *PodmanTestIntegration) makeOptions(args []string, noEvents, noCache boo
 		eventsType = "none"
 	}
 
+	networkBackend := p.NetworkBackend.ToString()
+	networkDir := p.NetworkConfigDir
+	if p.NetworkBackend == Netavark {
+		networkDir = p.NetworkConfigDir
+	}
 	podmanOptions := strings.Split(fmt.Sprintf("%s--root %s --runroot %s --runtime %s --conmon %s --network-config-dir %s --cgroup-manager %s --tmpdir %s --events-backend %s",
-		debug, p.Root, p.RunRoot, p.OCIRuntime, p.ConmonBinary, p.CNIConfigDir, p.CgroupManager, p.TmpDir, eventsType), " ")
+		debug, p.Root, p.RunRoot, p.OCIRuntime, p.ConmonBinary, networkDir, p.CgroupManager, p.TmpDir, eventsType), " ")
 	if os.Getenv("HOOK_OPTION") != "" {
 		podmanOptions = append(podmanOptions, os.Getenv("HOOK_OPTION"))
 	}
 
+	podmanOptions = append(podmanOptions, "--network-backend", networkBackend)
+
 	podmanOptions = append(podmanOptions, strings.Split(p.StorageOptions, " ")...)
 	if !noCache {
 		cacheOptions := []string{"--storage-opt",
@@ -842,6 +880,11 @@ func (p *PodmanTestIntegration) makeOptions(args []string, noEvents, noCache boo
 }
 
 func writeConf(conf []byte, confPath string) {
+	if _, err := os.Stat(filepath.Dir(confPath)); os.IsNotExist(err) {
+		if err := os.MkdirAll(filepath.Dir(confPath), 777); err != nil {
+			fmt.Println(err)
+		}
+	}
 	if err := ioutil.WriteFile(confPath, conf, 777); err != nil {
 		fmt.Println(err)
 	}
@@ -856,10 +899,15 @@ func removeConf(confPath string) {
 // generateNetworkConfig generates a cni config with a random name
 // it returns the network name and the filepath
 func generateNetworkConfig(p *PodmanTestIntegration) (string, string) {
+	var (
+		path string
+		conf string
+	)
 	// generate a random name to prevent conflicts with other tests
 	name := "net" + stringid.GenerateNonCryptoID()
-	path := filepath.Join(p.CNIConfigDir, fmt.Sprintf("%s.conflist", name))
-	conf := fmt.Sprintf(`{
+	if p.NetworkBackend != Netavark {
+		path = filepath.Join(p.NetworkConfigDir, fmt.Sprintf("%s.conflist", name))
+		conf = fmt.Sprintf(`{
 		"cniVersion": "0.3.0",
 		"name": "%s",
 		"plugins": [
@@ -884,12 +932,35 @@ func generateNetworkConfig(p *PodmanTestIntegration) (string, string) {
 		  }
 		]
 	}`, name)
+	} else {
+		path = filepath.Join(p.NetworkConfigDir, fmt.Sprintf("%s.json", name))
+		conf = fmt.Sprintf(`
+{
+     "name": "%s",
+     "id": "e1ef2749024b88f5663ca693a9118e036d6bfc48bcfe460faf45e9614a513e5c",
+     "driver": "bridge",
+     "network_interface": "netavark1",
+     "created": "2022-01-05T14:15:10.975493521-06:00",
+     "subnets": [
+          {
+               "subnet": "10.100.0.0/16",
+               "gateway": "10.100.0.1"
+          }
+     ],
+     "ipv6_enabled": false,
+     "internal": false,
+     "dns_enabled": true,
+     "ipam_options": {
+          "driver": "host-local"
+     }
+}
+`, name)
+	}
 	writeConf([]byte(conf), path)
-
 	return name, path
 }
 
-func (p *PodmanTestIntegration) removeCNINetwork(name string) {
+func (p *PodmanTestIntegration) removeNetwork(name string) {
 	session := p.Podman([]string{"network", "rm", "-f", name})
 	session.WaitWithDefaultTimeout()
 	Expect(session.ExitCode()).To(BeNumerically("<=", 1), "Exit code must be 0 or 1")
@@ -937,3 +1008,33 @@ func writeYaml(content string, fileName string) error {
 
 	return nil
 }
+
+// GetPort finds an unused port on the system
+func GetPort() int {
+	a, err := net.ResolveTCPAddr("tcp", "localhost:0")
+	if err != nil {
+		Fail(fmt.Sprintf("unable to get free port: %v", err))
+	}
+
+	l, err := net.ListenTCP("tcp", a)
+	if err != nil {
+		Fail(fmt.Sprintf("unable to get free port: %v", err))
+	}
+	defer l.Close()
+	return l.Addr().(*net.TCPAddr).Port
+}
+
+func ncz(port int) bool {
+	timeout := 500 * time.Millisecond
+	for i := 0; i < 5; i++ {
+		ncCmd := []string{"-z", "localhost", fmt.Sprintf("%d", port)}
+		fmt.Printf("Running: nc %s\n", strings.Join(ncCmd, " "))
+		check := SystemExec("nc", ncCmd)
+		if check.ExitCode() == 0 {
+			return true
+		}
+		time.Sleep(timeout)
+		timeout++
+	}
+	return false
+}
diff --git a/test/e2e/create_staticip_test.go b/test/e2e/create_staticip_test.go
index 5d234d717..4a1d926e0 100644
--- a/test/e2e/create_staticip_test.go
+++ b/test/e2e/create_staticip_test.go
@@ -106,6 +106,10 @@ var _ = Describe("Podman create with --ip flag", func() {
 		result = podmanTest.Podman([]string{"start", "test2"})
 		result.WaitWithDefaultTimeout()
 		Expect(result).To(ExitWithError())
-		Expect(result.ErrorToString()).To(ContainSubstring("requested IP address " + ip + " is not available"))
+		if podmanTest.NetworkBackend == CNI {
+			Expect(result.ErrorToString()).To(ContainSubstring("requested IP address " + ip + " is not available"))
+		} else if podmanTest.NetworkBackend == Netavark {
+			Expect(result.ErrorToString()).To(ContainSubstring("requested ip address %s is already allocated", ip))
+		}
 	})
 })
diff --git a/test/e2e/create_staticmac_test.go b/test/e2e/create_staticmac_test.go
index c6694ff7f..5fd8e3bd6 100644
--- a/test/e2e/create_staticmac_test.go
+++ b/test/e2e/create_staticmac_test.go
@@ -52,7 +52,7 @@ var _ = Describe("Podman run with --mac-address flag", func() {
 		net := "n1" + stringid.GenerateNonCryptoID()
 		session := podmanTest.Podman([]string{"network", "create", net})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(session).Should(Exit(0))
 
 		result := podmanTest.Podman([]string{"run", "--network", net, "--mac-address", "92:d0:c6:00:29:34", ALPINE, "ip", "addr"})
diff --git a/test/e2e/create_test.go b/test/e2e/create_test.go
index addf0ded0..6a4a394ef 100644
--- a/test/e2e/create_test.go
+++ b/test/e2e/create_test.go
@@ -598,7 +598,7 @@ var _ = Describe("Podman create", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		session = podmanTest.Podman([]string{"create", "--pod", name, "--network", netName, ALPINE, "top"})
 		session.WaitWithDefaultTimeout()
diff --git a/test/e2e/libpod_suite_remote_test.go b/test/e2e/libpod_suite_remote_test.go
index 4c5e9955f..b4a59c54d 100644
--- a/test/e2e/libpod_suite_remote_test.go
+++ b/test/e2e/libpod_suite_remote_test.go
@@ -153,8 +153,9 @@ func (p *PodmanTestIntegration) StopRemoteService() {
 
 // MakeOptions assembles all the podman main options
 func getRemoteOptions(p *PodmanTestIntegration, args []string) []string {
+	networkDir := p.NetworkConfigDir
 	podmanOptions := strings.Split(fmt.Sprintf("--root %s --runroot %s --runtime %s --conmon %s --network-config-dir %s --cgroup-manager %s",
-		p.Root, p.RunRoot, p.OCIRuntime, p.ConmonBinary, p.CNIConfigDir, p.CgroupManager), " ")
+		p.Root, p.RunRoot, p.OCIRuntime, p.ConmonBinary, networkDir, p.CgroupManager), " ")
 	if os.Getenv("HOOK_OPTION") != "" {
 		podmanOptions = append(podmanOptions, os.Getenv("HOOK_OPTION"))
 	}
diff --git a/test/e2e/login_logout_test.go b/test/e2e/login_logout_test.go
index 3d0f44dc1..1280b3e83 100644
--- a/test/e2e/login_logout_test.go
+++ b/test/e2e/login_logout_test.go
@@ -11,7 +11,6 @@ import (
 
 	. "github.com/containers/podman/v4/test/utils"
 	. "github.com/onsi/ginkgo"
-	"github.com/onsi/ginkgo/config"
 	. "github.com/onsi/gomega"
 	. "github.com/onsi/gomega/gexec"
 )
@@ -24,7 +23,6 @@ var _ = Describe("Podman login and logout", func() {
 		authPath                 string
 		certPath                 string
 		certDirPath              string
-		port                     int
 		server                   string
 		testImg                  string
 		registriesConfWithSearch []byte
@@ -62,7 +60,7 @@ var _ = Describe("Podman login and logout", func() {
 
 		f.WriteString(session.OutputToString())
 		f.Sync()
-		port = 4999 + config.GinkgoConfig.ParallelNode
+		port := GetPort()
 		server = strings.Join([]string{"localhost", strconv.Itoa(port)}, ":")
 
 		registriesConfWithSearch = []byte(fmt.Sprintf("[registries.search]\nregistries = ['%s']", server))
diff --git a/test/e2e/network_connect_disconnect_test.go b/test/e2e/network_connect_disconnect_test.go
index 82b9dcd09..baef142ba 100644
--- a/test/e2e/network_connect_disconnect_test.go
+++ b/test/e2e/network_connect_disconnect_test.go
@@ -45,7 +45,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		dis := podmanTest.Podman([]string{"network", "disconnect", netName, "foobar"})
 		dis.WaitWithDefaultTimeout()
@@ -57,12 +57,12 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		session = podmanTest.Podman([]string{"create", "--name", "test", "--network", "slirp4netns", ALPINE})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		con := podmanTest.Podman([]string{"network", "disconnect", netName, "test"})
 		con.WaitWithDefaultTimeout()
@@ -75,7 +75,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		ctr := podmanTest.Podman([]string{"run", "-dt", "--name", "test", "--network", netName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
@@ -111,7 +111,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		dis := podmanTest.Podman([]string{"network", "connect", netName, "foobar"})
 		dis.WaitWithDefaultTimeout()
@@ -123,12 +123,12 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		session = podmanTest.Podman([]string{"create", "--name", "test", "--network", "slirp4netns", ALPINE})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		con := podmanTest.Podman([]string{"network", "connect", netName, "test"})
 		con.WaitWithDefaultTimeout()
@@ -141,7 +141,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		ctr := podmanTest.Podman([]string{"create", "--name", "test", "--network", netName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
@@ -164,7 +164,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		ctr := podmanTest.Podman([]string{"run", "-dt", "--name", "test", "--network", netName, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
@@ -180,7 +180,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session = podmanTest.Podman([]string{"network", "create", newNetName, "--subnet", "10.11.100.0/24"})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(newNetName)
+		defer podmanTest.removeNetwork(newNetName)
 
 		ip := "10.11.100.99"
 		mac := "44:11:44:11:44:11"
@@ -218,13 +218,13 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName1})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName1)
+		defer podmanTest.removeNetwork(netName1)
 
 		netName2 := "connect2" + stringid.GenerateNonCryptoID()
 		session = podmanTest.Podman([]string{"network", "create", netName2})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName2)
+		defer podmanTest.removeNetwork(netName2)
 
 		ctr := podmanTest.Podman([]string{"create", "--name", "test", "--network", netName1, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
@@ -257,7 +257,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		session = podmanTest.Podman([]string{"network", "ls", "--format", "{{.ID}}", "--filter", "name=" + netName})
 		session.WaitWithDefaultTimeout()
@@ -277,7 +277,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session = podmanTest.Podman([]string{"network", "create", newNetName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(newNetName)
+		defer podmanTest.removeNetwork(newNetName)
 
 		session = podmanTest.Podman([]string{"network", "ls", "--format", "{{.ID}}", "--filter", "name=" + newNetName})
 		session.WaitWithDefaultTimeout()
@@ -304,13 +304,13 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName1})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName1)
+		defer podmanTest.removeNetwork(netName1)
 
 		netName2 := "aliasTest" + stringid.GenerateNonCryptoID()
 		session2 := podmanTest.Podman([]string{"network", "create", netName2})
 		session2.WaitWithDefaultTimeout()
 		Expect(session2).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName2)
+		defer podmanTest.removeNetwork(netName2)
 
 		ctr := podmanTest.Podman([]string{"create", "--name", "test", "--network", netName1 + "," + netName2, ALPINE, "top"})
 		ctr.WaitWithDefaultTimeout()
@@ -349,7 +349,7 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		session = podmanTest.Podman([]string{"network", "ls", "--format", "{{.ID}}", "--filter", "name=" + netName})
 		session.WaitWithDefaultTimeout()
diff --git a/test/e2e/network_create_test.go b/test/e2e/network_create_test.go
index 4a8a24ad7..7589adaab 100644
--- a/test/e2e/network_create_test.go
+++ b/test/e2e/network_create_test.go
@@ -45,7 +45,7 @@ var _ = Describe("Podman network create", func() {
 		netName := "subnet-" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "--subnet", "10.11.12.0/24", "--ip-range", "10.11.12.0/26", netName})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 		Expect(nc).Should(Exit(0))
 
 		// Inspect the network configuration
@@ -88,7 +88,7 @@ var _ = Describe("Podman network create", func() {
 		netName := "ipv6-" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "--subnet", "fd00:1:2:3:4::/64", netName})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 		Expect(nc).Should(Exit(0))
 
 		// Inspect the network configuration
@@ -127,7 +127,7 @@ var _ = Describe("Podman network create", func() {
 		netName := "dual-" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "--subnet", "fd00:4:3:2::/64", "--ipv6", netName})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 		Expect(nc).Should(Exit(0))
 
 		// Inspect the network configuration
@@ -160,7 +160,7 @@ var _ = Describe("Podman network create", func() {
 		netName2 := "dual-" + stringid.GenerateNonCryptoID()
 		nc = podmanTest.Podman([]string{"network", "create", "--subnet", "fd00:10:3:2::/64", "--ipv6", netName2})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName2)
+		defer podmanTest.removeNetwork(netName2)
 		Expect(nc).Should(Exit(0))
 
 		// Inspect the network configuration
@@ -215,7 +215,7 @@ var _ = Describe("Podman network create", func() {
 		nc := podmanTest.Podman([]string{"network", "create", "--subnet", "10.11.12.0/24", "--ipv6", name})
 		nc.WaitWithDefaultTimeout()
 		Expect(nc).To(Exit(0))
-		defer podmanTest.removeCNINetwork(name)
+		defer podmanTest.removeNetwork(name)
 
 		nc = podmanTest.Podman([]string{"network", "inspect", name})
 		nc.WaitWithDefaultTimeout()
@@ -229,7 +229,7 @@ var _ = Describe("Podman network create", func() {
 		nc := podmanTest.Podman([]string{"network", "create", "--ipv6", name})
 		nc.WaitWithDefaultTimeout()
 		Expect(nc).To(Exit(0))
-		defer podmanTest.removeCNINetwork(name)
+		defer podmanTest.removeNetwork(name)
 
 		nc = podmanTest.Podman([]string{"network", "inspect", name})
 		nc.WaitWithDefaultTimeout()
@@ -254,7 +254,7 @@ var _ = Describe("Podman network create", func() {
 		netName := "same-" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", netName})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 		Expect(nc).Should(Exit(0))
 
 		ncFail := podmanTest.Podman([]string{"network", "create", netName})
@@ -266,13 +266,13 @@ var _ = Describe("Podman network create", func() {
 		netName1 := "sub1-" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "--subnet", "10.11.13.0/24", netName1})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName1)
+		defer podmanTest.removeNetwork(netName1)
 		Expect(nc).Should(Exit(0))
 
 		netName2 := "sub2-" + stringid.GenerateNonCryptoID()
 		ncFail := podmanTest.Podman([]string{"network", "create", "--subnet", "10.11.13.0/24", netName2})
 		ncFail.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName2)
+		defer podmanTest.removeNetwork(netName2)
 		Expect(ncFail).To(ExitWithError())
 	})
 
@@ -280,13 +280,13 @@ var _ = Describe("Podman network create", func() {
 		netName1 := "subipv61-" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "--subnet", "fd00:4:4:4:4::/64", "--ipv6", netName1})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName1)
+		defer podmanTest.removeNetwork(netName1)
 		Expect(nc).Should(Exit(0))
 
 		netName2 := "subipv62-" + stringid.GenerateNonCryptoID()
 		ncFail := podmanTest.Podman([]string{"network", "create", "--subnet", "fd00:4:4:4:4::/64", "--ipv6", netName2})
 		ncFail.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName2)
+		defer podmanTest.removeNetwork(netName2)
 		Expect(ncFail).To(ExitWithError())
 	})
 
@@ -300,7 +300,7 @@ var _ = Describe("Podman network create", func() {
 		net := "mtu-test" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "--opt", "mtu=9000", net})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(nc).Should(Exit(0))
 
 		nc = podmanTest.Podman([]string{"network", "inspect", net})
@@ -313,7 +313,7 @@ var _ = Describe("Podman network create", func() {
 		net := "vlan-test" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "--opt", "vlan=9", net})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(nc).Should(Exit(0))
 
 		nc = podmanTest.Podman([]string{"network", "inspect", net})
@@ -326,15 +326,16 @@ var _ = Describe("Podman network create", func() {
 		net := "invalid-test" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "--opt", "foo=bar", net})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(nc).To(ExitWithError())
 	})
 
 	It("podman network create with internal should not have dnsname", func() {
+		SkipUntilAardvark(podmanTest)
 		net := "internal-test" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "--internal", net})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(nc).Should(Exit(0))
 		// Not performing this check on remote tests because it is a logrus error which does
 		// not come back via stderr on the remote client.
@@ -362,7 +363,7 @@ var _ = Describe("Podman network create", func() {
 		subnet2 := "10.10.1.0/24"
 		nc := podmanTest.Podman([]string{"network", "create", "--subnet", subnet1, "--subnet", subnet2, name})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(name)
+		defer podmanTest.removeNetwork(name)
 		Expect(nc).To(Exit(0))
 		Expect(nc.OutputToString()).To(Equal(name))
 
@@ -380,7 +381,7 @@ var _ = Describe("Podman network create", func() {
 		subnet2 := "fd52:2a5a:747e:3acd::/64"
 		nc := podmanTest.Podman([]string{"network", "create", "--subnet", subnet1, "--subnet", subnet2, name})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(name)
+		defer podmanTest.removeNetwork(name)
 		Expect(nc).To(Exit(0))
 		Expect(nc.OutputToString()).To(Equal(name))
 
@@ -401,7 +402,7 @@ var _ = Describe("Podman network create", func() {
 		gw2 := "fd52:2a5a:747e:3acd::10"
 		nc := podmanTest.Podman([]string{"network", "create", "--subnet", subnet1, "--gateway", gw1, "--ip-range", range1, "--subnet", subnet2, "--gateway", gw2, name})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(name)
+		defer podmanTest.removeNetwork(name)
 		Expect(nc).To(Exit(0))
 		Expect(nc.OutputToString()).To(Equal(name))
 
diff --git a/test/e2e/network_test.go b/test/e2e/network_test.go
index 70793fc32..bd30a1f5d 100644
--- a/test/e2e/network_test.go
+++ b/test/e2e/network_test.go
@@ -118,13 +118,13 @@ var _ = Describe("Podman network", func() {
 		label2 := "abcdef"
 		session := podmanTest.Podman([]string{"network", "create", "--label", label1, net1})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net1)
+		defer podmanTest.removeNetwork(net1)
 		Expect(session).Should(Exit(0))
 
 		net2 := "labelnet" + stringid.GenerateNonCryptoID()
 		session = podmanTest.Podman([]string{"network", "create", "--label", label1, "--label", label2, net2})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net2)
+		defer podmanTest.removeNetwork(net2)
 		Expect(session).Should(Exit(0))
 
 		session = podmanTest.Podman([]string{"network", "ls", "--filter", "label=" + label1})
@@ -144,7 +144,7 @@ var _ = Describe("Podman network", func() {
 		net := "net" + stringid.GenerateNonCryptoID()
 		session := podmanTest.Podman([]string{"network", "create", net})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(session).Should(Exit(0))
 
 		session = podmanTest.Podman([]string{"network", "ls", "--filter", "namr=ab"})
@@ -169,9 +169,16 @@ var _ = Describe("Podman network", func() {
 		netID := "6073aefe03cdf8f29be5b23ea9795c431868a3a22066a6290b187691614fee84"
 		session := podmanTest.Podman([]string{"network", "create", net})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(session).Should(Exit(0))
 
+		if podmanTest.NetworkBackend == Netavark {
+			// netavark uses a different algo for determining the id and it is not repeatable
+			getid := podmanTest.Podman([]string{"network", "inspect", net, "--format", "{{.ID}}"})
+			getid.WaitWithDefaultTimeout()
+			Expect(getid).Should(Exit(0))
+			netID = getid.OutputToString()
+		}
 		// Tests Default Table Output
 		session = podmanTest.Podman([]string{"network", "ls", "--filter", "id=" + netID})
 		session.WaitWithDefaultTimeout()
@@ -270,7 +277,7 @@ var _ = Describe("Podman network", func() {
 		netName := "net-" + stringid.GenerateNonCryptoID()
 		network := podmanTest.Podman([]string{"network", "create", "--subnet", "10.50.50.0/24", netName})
 		network.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 		Expect(network).Should(Exit(0))
 
 		ctrName := "testCtr"
@@ -300,13 +307,13 @@ var _ = Describe("Podman network", func() {
 		netName1 := "net1-" + stringid.GenerateNonCryptoID()
 		network1 := podmanTest.Podman([]string{"network", "create", netName1})
 		network1.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName1)
+		defer podmanTest.removeNetwork(netName1)
 		Expect(network1).Should(Exit(0))
 
 		netName2 := "net2-" + stringid.GenerateNonCryptoID()
 		network2 := podmanTest.Podman([]string{"network", "create", netName2})
 		network2.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName2)
+		defer podmanTest.removeNetwork(netName2)
 		Expect(network2).Should(Exit(0))
 
 		ctrName := "testCtr"
@@ -337,13 +344,13 @@ var _ = Describe("Podman network", func() {
 		netName1 := "net1-" + stringid.GenerateNonCryptoID()
 		network1 := podmanTest.Podman([]string{"network", "create", "--subnet", "10.50.51.0/25", netName1})
 		network1.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName1)
+		defer podmanTest.removeNetwork(netName1)
 		Expect(network1).Should(Exit(0))
 
 		netName2 := "net2-" + stringid.GenerateNonCryptoID()
 		network2 := podmanTest.Podman([]string{"network", "create", "--subnet", "10.50.51.128/26", netName2})
 		network2.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName2)
+		defer podmanTest.removeNetwork(netName2)
 		Expect(network2).Should(Exit(0))
 
 		ctrName := "testCtr"
@@ -380,7 +387,7 @@ var _ = Describe("Podman network", func() {
 
 		session := podmanTest.Podman([]string{"network", "create", network})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(network)
+		defer podmanTest.removeNetwork(network)
 		Expect(session).Should(Exit(0))
 
 		session = podmanTest.Podman([]string{"run", "--name", container, "--network", network, "-d", ALPINE, "top"})
@@ -406,7 +413,7 @@ var _ = Describe("Podman network", func() {
 		netName := "net-" + stringid.GenerateNonCryptoID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 		Expect(session).Should(Exit(0))
 
 		session = podmanTest.Podman([]string{"pod", "create", "--network", netName})
@@ -442,13 +449,13 @@ var _ = Describe("Podman network", func() {
 		netName1 := "net1-" + stringid.GenerateNonCryptoID()
 		session := podmanTest.Podman([]string{"network", "create", netName1})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName1)
+		defer podmanTest.removeNetwork(netName1)
 		Expect(session).Should(Exit(0))
 
 		netName2 := "net2-" + stringid.GenerateNonCryptoID()
 		session = podmanTest.Podman([]string{"network", "create", netName2})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName2)
+		defer podmanTest.removeNetwork(netName2)
 		Expect(session).Should(Exit(0))
 
 		session = podmanTest.Podman([]string{"network", "rm", netName1, netName2})
@@ -460,11 +467,12 @@ var _ = Describe("Podman network", func() {
 	})
 
 	It("podman network with multiple aliases", func() {
+		SkipUntilAardvark(podmanTest)
 		var worked bool
 		netName := "aliasTest" + stringid.GenerateNonCryptoID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 		Expect(session).Should(Exit(0))
 
 		interval := time.Duration(250 * time.Millisecond)
@@ -510,10 +518,12 @@ var _ = Describe("Podman network", func() {
 	})
 
 	It("podman network create/remove macvlan", func() {
+		// Netavark currently does not do dhcp so the this test fails
+		SkipIfNetavark(podmanTest)
 		net := "macvlan" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "--macvlan", "lo", net})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(nc).Should(Exit(0))
 
 		nc = podmanTest.Podman([]string{"network", "rm", net})
@@ -522,10 +532,12 @@ var _ = Describe("Podman network", func() {
 	})
 
 	It("podman network create/remove macvlan as driver (-d) no device name", func() {
+		// Netavark currently does not do dhcp so the this test fails
+		SkipIfNetavark(podmanTest)
 		net := "macvlan" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "-d", "macvlan", net})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(nc).Should(Exit(0))
 
 		inspect := podmanTest.Podman([]string{"network", "inspect", net})
@@ -547,10 +559,12 @@ var _ = Describe("Podman network", func() {
 	})
 
 	It("podman network create/remove macvlan as driver (-d) with device name", func() {
+		// Netavark currently does not do dhcp so the this test fails
+		SkipIfNetavark(podmanTest)
 		net := "macvlan" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "-d", "macvlan", "-o", "parent=lo", net})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(nc).Should(Exit(0))
 
 		inspect := podmanTest.Podman([]string{"network", "inspect", net})
@@ -577,7 +591,7 @@ var _ = Describe("Podman network", func() {
 		net := "net" + stringid.GenerateNonCryptoID()
 		session := podmanTest.Podman([]string{"network", "create", net})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(session).Should(Exit(0))
 
 		session = podmanTest.Podman([]string{"network", "exists", net})
@@ -593,7 +607,7 @@ var _ = Describe("Podman network", func() {
 		net := "macvlan" + stringid.GenerateNonCryptoID()
 		nc := podmanTest.Podman([]string{"network", "create", "-d", "macvlan", "-o", "parent=lo", "-o", "mtu=1500", "--gateway", "192.168.1.254", "--subnet", "192.168.1.0/24", net})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(nc).Should(Exit(0))
 
 		inspect := podmanTest.Podman([]string{"network", "inspect", net})
@@ -622,7 +636,7 @@ var _ = Describe("Podman network", func() {
 
 	It("podman network prune --filter", func() {
 		// set custom cni directory to prevent flakes
-		podmanTest.CNIConfigDir = tempdir
+		podmanTest.NetworkConfigDir = tempdir
 		if IsRemote() {
 			podmanTest.RestartRemoteService()
 		}
@@ -630,7 +644,7 @@ var _ = Describe("Podman network", func() {
 
 		nc := podmanTest.Podman([]string{"network", "create", net1})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net1)
+		defer podmanTest.removeNetwork(net1)
 		Expect(nc).Should(Exit(0))
 
 		list := podmanTest.Podman([]string{"network", "ls", "--format", "{{.Name}}"})
@@ -670,7 +684,7 @@ var _ = Describe("Podman network", func() {
 
 	It("podman network prune", func() {
 		// set custom cni directory to prevent flakes
-		podmanTest.CNIConfigDir = tempdir
+		podmanTest.NetworkConfigDir = tempdir
 		if IsRemote() {
 			podmanTest.RestartRemoteService()
 		}
@@ -684,12 +698,12 @@ var _ = Describe("Podman network", func() {
 		net2 := net + "2"
 		nc := podmanTest.Podman([]string{"network", "create", net1})
 		nc.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net1)
+		defer podmanTest.removeNetwork(net1)
 		Expect(nc).Should(Exit(0))
 
 		nc2 := podmanTest.Podman([]string{"network", "create", net2})
 		nc2.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net2)
+		defer podmanTest.removeNetwork(net2)
 		Expect(nc2).Should(Exit(0))
 
 		list := podmanTest.Podman([]string{"network", "ls", "--format", "{{.Name}}"})
diff --git a/test/e2e/play_kube_test.go b/test/e2e/play_kube_test.go
index b5e64fcbc..c0c71652e 100644
--- a/test/e2e/play_kube_test.go
+++ b/test/e2e/play_kube_test.go
@@ -2190,7 +2190,7 @@ spec:
 		net := "playkube" + stringid.GenerateNonCryptoID()
 		session := podmanTest.Podman([]string{"network", "create", "--subnet", "10.25.31.0/24", net})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(session).Should(Exit(0))
 
 		ips := []string{"10.25.31.5", "10.25.31.10", "10.25.31.15"}
@@ -2234,12 +2234,12 @@ spec:
 
 		net := podmanTest.Podman([]string{"network", "create", "--subnet", "10.0.11.0/24", net1})
 		net.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net1)
+		defer podmanTest.removeNetwork(net1)
 		Expect(net).Should(Exit(0))
 
 		net = podmanTest.Podman([]string{"network", "create", "--subnet", "10.0.12.0/24", net2})
 		net.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net2)
+		defer podmanTest.removeNetwork(net2)
 		Expect(net).Should(Exit(0))
 
 		ip1 := "10.0.11.5"
diff --git a/test/e2e/pod_create_test.go b/test/e2e/pod_create_test.go
index f0abfd80c..c3f77857e 100644
--- a/test/e2e/pod_create_test.go
+++ b/test/e2e/pod_create_test.go
@@ -109,7 +109,8 @@ var _ = Describe("Podman pod create", func() {
 
 	It("podman create pod with network portbindings", func() {
 		name := "test"
-		session := podmanTest.Podman([]string{"pod", "create", "--name", name, "-p", "8081:80"})
+		port := GetPort()
+		session := podmanTest.Podman([]string{"pod", "create", "--name", name, "-p", fmt.Sprintf("%d:80", port)})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
 		pod := session.OutputToString()
@@ -117,24 +118,21 @@ var _ = Describe("Podman pod create", func() {
 		webserver := podmanTest.Podman([]string{"run", "--pod", pod, "-dt", nginx})
 		webserver.WaitWithDefaultTimeout()
 		Expect(webserver).Should(Exit(0))
-
-		check := SystemExec("nc", []string{"-z", "localhost", "8081"})
-		Expect(check).Should(Exit(0))
+		Expect(ncz(port)).To(BeTrue())
 	})
 
 	It("podman create pod with id file with network portbindings", func() {
 		file := filepath.Join(podmanTest.TempDir, "pod.id")
 		name := "test"
-		session := podmanTest.Podman([]string{"pod", "create", "--name", name, "--pod-id-file", file, "-p", "8082:80"})
+		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))
 
 		webserver := podmanTest.Podman([]string{"run", "--pod-id-file", file, "-dt", nginx})
 		webserver.WaitWithDefaultTimeout()
 		Expect(webserver).Should(Exit(0))
-
-		check := SystemExec("nc", []string{"-z", "localhost", "8082"})
-		Expect(check).Should(Exit(0))
+		Expect(ncz(port)).To(BeTrue())
 	})
 
 	It("podman create pod with no infra but portbindings should fail", func() {
diff --git a/test/e2e/pod_ps_test.go b/test/e2e/pod_ps_test.go
index 29ee73d35..a0a1e1438 100644
--- a/test/e2e/pod_ps_test.go
+++ b/test/e2e/pod_ps_test.go
@@ -299,7 +299,7 @@ var _ = Describe("Podman ps", func() {
 		session := podmanTest.Podman([]string{"network", "create", net})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 
 		session = podmanTest.Podman([]string{"pod", "create", "--network", net})
 		session.WaitWithDefaultTimeout()
@@ -338,12 +338,12 @@ var _ = Describe("Podman ps", func() {
 		session = podmanTest.Podman([]string{"network", "create", net1})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(net1)
+		defer podmanTest.removeNetwork(net1)
 		net2 := stringid.GenerateNonCryptoID()
 		session = podmanTest.Podman([]string{"network", "create", net2})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(net2)
+		defer podmanTest.removeNetwork(net2)
 
 		session = podmanTest.Podman([]string{"pod", "create", "--network", net1 + "," + net2})
 		session.WaitWithDefaultTimeout()
diff --git a/test/e2e/ps_test.go b/test/e2e/ps_test.go
index 0c93c430b..021ebc30b 100644
--- a/test/e2e/ps_test.go
+++ b/test/e2e/ps_test.go
@@ -822,7 +822,7 @@ var _ = Describe("Podman ps", func() {
 		session := podmanTest.Podman([]string{"network", "create", net})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 
 		session = podmanTest.Podman([]string{"create", "--network", net, ALPINE})
 		session.WaitWithDefaultTimeout()
@@ -865,12 +865,12 @@ var _ = Describe("Podman ps", func() {
 		session = podmanTest.Podman([]string{"network", "create", net1})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(net1)
+		defer podmanTest.removeNetwork(net1)
 		net2 := stringid.GenerateNonCryptoID()
 		session = podmanTest.Podman([]string{"network", "create", net2})
 		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(net2)
+		defer podmanTest.removeNetwork(net2)
 
 		session = podmanTest.Podman([]string{"create", "--network", net1 + "," + net2, ALPINE})
 		session.WaitWithDefaultTimeout()
diff --git a/test/e2e/run_networking_test.go b/test/e2e/run_networking_test.go
index 4868fbd01..4c056df10 100644
--- a/test/e2e/run_networking_test.go
+++ b/test/e2e/run_networking_test.go
@@ -78,9 +78,9 @@ var _ = Describe("Podman run networking", func() {
 	It("podman run network expose port 222", func() {
 		SkipIfRootless("iptables is not supported for rootless users")
 		session := podmanTest.Podman([]string{"run", "-dt", "--expose", "222-223", "-P", ALPINE, "/bin/sh"})
-		session.Wait(30)
+		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
-		results := SystemExec("iptables", []string{"-t", "nat", "-L"})
+		results := SystemExec("iptables", []string{"-t", "nat", "-nvL"})
 		Expect(results).Should(Exit(0))
 		Expect(results.OutputToString()).To(ContainSubstring("222"))
 		Expect(results.OutputToString()).To(ContainSubstring("223"))
@@ -371,31 +371,35 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 		Expect(inspectOut[0].NetworkSettings.Ports["80/tcp"][0].HostIP).To(Equal(""))
 	})
 
-	It("podman run network expose host port 80 to container port 8000", func() {
+	It("podman run network expose host port 80 to container port", func() {
 		SkipIfRootless("iptables is not supported for rootless users")
-		session := podmanTest.Podman([]string{"run", "-dt", "-p", "80:8000", ALPINE, "/bin/sh"})
-		session.Wait(30)
+		port1 := GetPort()
+		port2 := GetPort()
+		session := podmanTest.Podman([]string{"run", "-dt", "-p", fmt.Sprintf("%d:%d", port1, port2), ALPINE, "/bin/sh"})
+		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
 		results := SystemExec("iptables", []string{"-t", "nat", "-L"})
 		Expect(results).Should(Exit(0))
-		Expect(results.OutputToString()).To(ContainSubstring("8000"))
+		Expect(results.OutputToString()).To(ContainSubstring(fmt.Sprintf("%d", port2)))
 
-		ncBusy := SystemExec("nc", []string{"-l", "-p", "80"})
+		ncBusy := SystemExec("nc", []string{"-l", "-p", fmt.Sprintf("%d", port1)})
 		Expect(ncBusy).To(ExitWithError())
 	})
 
 	It("podman run network expose host port 18081 to container port 8000 using rootlesskit port handler", func() {
-		session := podmanTest.Podman([]string{"run", "--network", "slirp4netns:port_handler=rootlesskit", "-dt", "-p", "18081:8000", ALPINE, "/bin/sh"})
-		session.Wait(30)
+		port1 := GetPort()
+		port2 := GetPort()
+		session := podmanTest.Podman([]string{"run", "--network", "slirp4netns:port_handler=rootlesskit", "-dt", "-p", fmt.Sprintf("%d:%d", port2, port1), ALPINE, "/bin/sh"})
+		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
 
-		ncBusy := SystemExec("nc", []string{"-l", "-p", "18081"})
+		ncBusy := SystemExec("nc", []string{"-l", "-p", fmt.Sprintf("%d", port2)})
 		Expect(ncBusy).To(ExitWithError())
 	})
 
 	It("podman run slirp4netns verify net.ipv6.conf.default.accept_dad=0", func() {
 		session := podmanTest.Podman([]string{"run", "--network", "slirp4netns:enable_ipv6=true", ALPINE, "ip", "addr"})
-		session.Wait(30)
+		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
 		// check the ipv6 setup id done without delay (https://github.com/containers/podman/issues/11062)
 		Expect(session.OutputToString()).To(ContainSubstring("inet6 fd00::"))
@@ -403,12 +407,12 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 		const ipv6ConfDefaultAcceptDadSysctl = "/proc/sys/net/ipv6/conf/all/accept_dad"
 
 		cat := SystemExec("cat", []string{ipv6ConfDefaultAcceptDadSysctl})
-		cat.Wait(30)
+		cat.WaitWithDefaultTimeout()
 		Expect(cat).Should(Exit(0))
 		sysctlValue := cat.OutputToString()
 
 		session = podmanTest.Podman([]string{"run", "--network", "slirp4netns:enable_ipv6=true", ALPINE, "cat", ipv6ConfDefaultAcceptDadSysctl})
-		session.Wait(30)
+		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
 		Expect(session.OutputToString()).To(Equal(sysctlValue))
 	})
@@ -460,19 +464,20 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 		slirp4netnsHelp := SystemExec("slirp4netns", []string{"--help"})
 		Expect(slirp4netnsHelp).Should(Exit(0))
 		networkConfiguration := "slirp4netns:outbound_addr=127.0.0.1,allow_host_loopback=true"
+		port := GetPort()
 
 		if strings.Contains(slirp4netnsHelp.OutputToString(), "outbound-addr") {
-			ncListener := StartSystemExec("nc", []string{"-v", "-n", "-l", "-p", "8083"})
-			session := podmanTest.Podman([]string{"run", "--network", networkConfiguration, "-dt", ALPINE, "nc", "-w", "2", "10.0.2.2", "8083"})
-			session.Wait(30)
-			ncListener.Wait(30)
+			ncListener := StartSystemExec("nc", []string{"-v", "-n", "-l", "-p", fmt.Sprintf("%d", port)})
+			session := podmanTest.Podman([]string{"run", "--network", networkConfiguration, "-dt", ALPINE, "nc", "-w", "2", "10.0.2.2", fmt.Sprintf("%d", port)})
+			session.WaitWithDefaultTimeout()
+			ncListener.WaitWithDefaultTimeout()
 
 			Expect(session).Should(Exit(0))
 			Expect(ncListener).Should(Exit(0))
 			Expect(ncListener.ErrorToString()).To(ContainSubstring("127.0.0.1"))
 		} else {
-			session := podmanTest.Podman([]string{"run", "--network", networkConfiguration, "-dt", ALPINE, "nc", "-w", "2", "10.0.2.2", "8083"})
-			session.Wait(30)
+			session := podmanTest.Podman([]string{"run", "--network", networkConfiguration, "-dt", ALPINE, "nc", "-w", "2", "10.0.2.2", fmt.Sprintf("%d", port)})
+			session.WaitWithDefaultTimeout()
 			Expect(session).To(ExitWithError())
 			Expect(session.ErrorToString()).To(ContainSubstring("outbound_addr not supported"))
 		}
@@ -481,14 +486,15 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 	It("podman run network bind to HostIP", func() {
 		ip, err := utils.HostIP()
 		Expect(err).To(BeNil())
+		port := GetPort()
 
 		slirp4netnsHelp := SystemExec("slirp4netns", []string{"--help"})
 		Expect(slirp4netnsHelp).Should(Exit(0))
 		networkConfiguration := fmt.Sprintf("slirp4netns:outbound_addr=%s,allow_host_loopback=true", ip.String())
 
 		if strings.Contains(slirp4netnsHelp.OutputToString(), "outbound-addr") {
-			ncListener := StartSystemExec("nc", []string{"-v", "-n", "-l", "-p", "8084"})
-			session := podmanTest.Podman([]string{"run", "--network", networkConfiguration, "-dt", ALPINE, "nc", "-w", "2", "10.0.2.2", "8084"})
+			ncListener := StartSystemExec("nc", []string{"-v", "-n", "-l", "-p", fmt.Sprintf("%d", port)})
+			session := podmanTest.Podman([]string{"run", "--network", networkConfiguration, "-dt", ALPINE, "nc", "-w", "2", "10.0.2.2", fmt.Sprintf("%d", port)})
 			session.Wait(30)
 			ncListener.Wait(30)
 
@@ -496,7 +502,7 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 			Expect(ncListener).Should(Exit(0))
 			Expect(ncListener.ErrorToString()).To(ContainSubstring(ip.String()))
 		} else {
-			session := podmanTest.Podman([]string{"run", "--network", networkConfiguration, "-dt", ALPINE, "nc", "-w", "2", "10.0.2.2", "8084"})
+			session := podmanTest.Podman([]string{"run", "--network", networkConfiguration, "-dt", ALPINE, "nc", "-w", "2", "10.0.2.2", fmt.Sprintf("%d", port)})
 			session.Wait(30)
 			Expect(session).To(ExitWithError())
 			Expect(session.ErrorToString()).To(ContainSubstring("outbound_addr not supported"))
@@ -505,10 +511,10 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 
 	It("podman run network expose ports in image metadata", func() {
 		session := podmanTest.Podman([]string{"create", "--name", "test", "-t", "-P", nginx})
-		session.Wait(90)
+		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
 		results := podmanTest.Podman([]string{"inspect", "test"})
-		results.Wait(30)
+		results.WaitWithDefaultTimeout()
 		Expect(results).Should(Exit(0))
 		Expect(results.OutputToString()).To(ContainSubstring(`"80/tcp":`))
 	})
@@ -533,7 +539,7 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 	It("podman run forward sctp protocol", func() {
 		SkipIfRootless("sctp protocol only works as root")
 		session := podmanTest.Podman([]string{"--log-level=info", "run", "--name=test", "-p", "80/sctp", "-p", "81/sctp", ALPINE})
-		session.Wait(90)
+		session.WaitWithDefaultTimeout()
 		Expect(session).Should(Exit(0))
 		// we can only check logrus on local podman
 		if !IsRemote() {
@@ -541,7 +547,7 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 			Expect(strings.Count(session.ErrorToString(), "Port reservation for SCTP is not supported")).To(Equal(1), "`Port reservation for SCTP is not supported` is not displayed exactly one time in the logrus logs")
 		}
 		results := podmanTest.Podman([]string{"inspect", "test"})
-		results.Wait(30)
+		results.WaitWithDefaultTimeout()
 		Expect(results).Should(Exit(0))
 		Expect(results.OutputToString()).To(ContainSubstring(`"80/sctp":`))
 		Expect(results.OutputToString()).To(ContainSubstring(`"81/sctp":`))
@@ -701,7 +707,7 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 		create := podmanTest.Podman([]string{"network", "create", "--subnet", "10.25.30.0/24", netName})
 		create.WaitWithDefaultTimeout()
 		Expect(create).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		run := podmanTest.Podman([]string{"run", "-t", "-i", "--rm", "--net", netName, "--ip", ipAddr, ALPINE, "ip", "addr"})
 		run.WaitWithDefaultTimeout()
@@ -710,11 +716,12 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 	})
 
 	It("podman cni network works across user ns", func() {
+		SkipUntilAardvark(podmanTest)
 		netName := stringid.GenerateNonCryptoID()
 		create := podmanTest.Podman([]string{"network", "create", netName})
 		create.WaitWithDefaultTimeout()
 		Expect(create).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		name := "nc-server"
 		run := podmanTest.Podman([]string{"run", "--log-driver", "k8s-file", "-d", "--name", name, "--net", netName, ALPINE, "nc", "-l", "-p", "9480"})
@@ -740,7 +747,7 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 		create := podmanTest.Podman([]string{"network", "create", "--subnet", "10.25.40.0/24", netName})
 		create.WaitWithDefaultTimeout()
 		Expect(create).Should(Exit(0))
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 
 		run := podmanTest.Podman([]string{"run", "-t", "-i", "--rm", "--pod", "new:" + podname, "--net", netName, "--ip", ipAddr, ALPINE, "ip", "addr"})
 		run.WaitWithDefaultTimeout()
@@ -808,6 +815,7 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 	})
 
 	It("podman run check dnsname plugin", func() {
+		SkipUntilAardvark(podmanTest)
 		pod := "testpod"
 		session := podmanTest.Podman([]string{"pod", "create", "--name", pod})
 		session.WaitWithDefaultTimeout()
@@ -816,7 +824,7 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 		net := "IntTest" + stringid.GenerateNonCryptoID()
 		session = podmanTest.Podman([]string{"network", "create", net})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(session).Should(Exit(0))
 
 		pod2 := "testpod2"
@@ -843,10 +851,11 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 	})
 
 	It("podman run check dnsname adds dns search domain", func() {
+		SkipUntilAardvark(podmanTest)
 		net := "dnsname" + stringid.GenerateNonCryptoID()
 		session := podmanTest.Podman([]string{"network", "create", net})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(session).Should(Exit(0))
 
 		session = podmanTest.Podman([]string{"run", "--network", net, ALPINE, "cat", "/etc/resolv.conf"})
@@ -873,7 +882,7 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 		net := "dns" + stringid.GenerateNonCryptoID()
 		session := podmanTest.Podman([]string{"network", "create", "--disable-dns", net})
 		session.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(net)
+		defer podmanTest.removeNetwork(net)
 		Expect(session).Should(Exit(0))
 
 		session = podmanTest.Podman([]string{"run", "--network", net, "--network-alias", "abcdef", ALPINE, "true"})
diff --git a/test/e2e/run_staticip_test.go b/test/e2e/run_staticip_test.go
index cf014d46e..b78a37495 100644
--- a/test/e2e/run_staticip_test.go
+++ b/test/e2e/run_staticip_test.go
@@ -71,7 +71,7 @@ var _ = Describe("Podman run with --ip flag", func() {
 		ipv6 := "fd46:db93:aa76:ac37::10"
 		net := podmanTest.Podman([]string{"network", "create", "--subnet", "fd46:db93:aa76:ac37::/64", netName})
 		net.WaitWithDefaultTimeout()
-		defer podmanTest.removeCNINetwork(netName)
+		defer podmanTest.removeNetwork(netName)
 		Expect(net).To(Exit(0))
 
 		result := podmanTest.Podman([]string{"run", "-ti", "--network", netName, "--ip6", ipv6, ALPINE, "ip", "addr"})
diff --git a/test/e2e/search_test.go b/test/e2e/search_test.go
index f8d6019b0..07198d799 100644
--- a/test/e2e/search_test.go
+++ b/test/e2e/search_test.go
@@ -32,18 +32,6 @@ var _ = Describe("Podman search", func() {
 		podmanTest *PodmanTestIntegration
 	)
 
-	var registryEndpoints = []endpoint{
-		{"localhost", "5001"},
-		{"localhost", "5002"},
-		{"localhost", "5003"},
-		{"localhost", "5004"},
-		{"localhost", "5005"},
-		{"localhost", "5006"},
-		{"localhost", "5007"},
-		{"localhost", "5008"},
-		{"localhost", "5009"},
-	}
-
 	const regFileContents = `
 [registries.search]
 registries = ['{{.Host}}:{{.Port}}']
@@ -217,21 +205,19 @@ registries = ['{{.Host}}:{{.Port}}']`
 		if podmanTest.Host.Arch == "ppc64le" {
 			Skip("No registry image for ppc64le")
 		}
-		lock := GetPortLock(registryEndpoints[0].Port)
-		defer lock.Unlock()
-
+		port := GetPort()
 		fakereg := podmanTest.Podman([]string{"run", "-d", "--name", "registry",
-			"-p", fmt.Sprintf("%s:5000", registryEndpoints[0].Port),
+			"-p", fmt.Sprintf("%d:5000", port),
 			registry, "/entrypoint.sh", "/etc/docker/registry/config.yml"})
 		fakereg.WaitWithDefaultTimeout()
 		Expect(fakereg).Should(Exit(0))
 
 		if !WaitContainerReady(podmanTest, "registry", "listening on", 20, 1) {
-			Skip("Cannot start docker registry.")
+			Fail("Cannot start docker registry on port %s", port)
 		}
-
+		ep := endpoint{Port: fmt.Sprintf("%d", port), Host: "localhost"}
 		search := podmanTest.Podman([]string{"search",
-			fmt.Sprintf("%s/fake/image:andtag", registryEndpoints[0].Address()), "--tls-verify=false"})
+			fmt.Sprintf("%s/fake/image:andtag", ep.Address()), "--tls-verify=false"})
 		search.WaitWithDefaultTimeout()
 
 		// if this test succeeded, there will be no output (there is no entry named fake/image:andtag in an empty registry)
@@ -245,20 +231,19 @@ registries = ['{{.Host}}:{{.Port}}']`
 		if podmanTest.Host.Arch == "ppc64le" {
 			Skip("No registry image for ppc64le")
 		}
-		lock := GetPortLock(registryEndpoints[3].Port)
-		defer lock.Unlock()
+		port := GetPort()
 		registry := podmanTest.Podman([]string{"run", "-d", "--name", "registry3",
-			"-p", fmt.Sprintf("%s:5000", registryEndpoints[3].Port), registry,
+			"-p", fmt.Sprintf("%d:5000", port), registry,
 			"/entrypoint.sh", "/etc/docker/registry/config.yml"})
 		registry.WaitWithDefaultTimeout()
 		Expect(registry).Should(Exit(0))
 
 		if !WaitContainerReady(podmanTest, "registry3", "listening on", 20, 1) {
-			Skip("Cannot start docker registry.")
+			Fail("Cannot start docker registry on port %s", port)
 		}
-
+		ep := endpoint{Port: fmt.Sprintf("%d", port), Host: "localhost"}
 		podmanTest.RestoreArtifact(ALPINE)
-		image := fmt.Sprintf("%s/my-alpine", registryEndpoints[3].Address())
+		image := fmt.Sprintf("%s/my-alpine", ep.Address())
 		push := podmanTest.Podman([]string{"push", "--tls-verify=false", "--remove-signatures", ALPINE, image})
 		push.WaitWithDefaultTimeout()
 		Expect(push).Should(Exit(0))
@@ -269,7 +254,7 @@ registries = ['{{.Host}}:{{.Port}}']`
 		Expect(search.OutputToString()).ShouldNot(BeEmpty())
 
 		// podman search v2 registry with empty query
-		searchEmpty := podmanTest.Podman([]string{"search", fmt.Sprintf("%s/", registryEndpoints[3].Address()), "--tls-verify=false"})
+		searchEmpty := podmanTest.Podman([]string{"search", fmt.Sprintf("%s/", ep.Address()), "--tls-verify=false"})
 		searchEmpty.WaitWithDefaultTimeout()
 		Expect(searchEmpty).Should(Exit(0))
 		Expect(len(searchEmpty.OutputToStringArray())).To(BeNumerically(">=", 1))
@@ -281,26 +266,26 @@ registries = ['{{.Host}}:{{.Port}}']`
 			Skip("No registry image for ppc64le")
 		}
 
-		lock := GetPortLock(registryEndpoints[4].Port)
-		defer lock.Unlock()
-		registry := podmanTest.Podman([]string{"run", "-d", "-p", fmt.Sprintf("%s:5000", registryEndpoints[4].Port),
+		port := GetPort()
+		ep := endpoint{Port: fmt.Sprintf("%d", port), Host: "localhost"}
+		registry := podmanTest.Podman([]string{"run", "-d", "-p", fmt.Sprintf("%d:5000", port),
 			"--name", "registry4", registry, "/entrypoint.sh", "/etc/docker/registry/config.yml"})
 		registry.WaitWithDefaultTimeout()
 		Expect(registry).Should(Exit(0))
 
 		if !WaitContainerReady(podmanTest, "registry4", "listening on", 20, 1) {
-			Skip("Cannot start docker registry.")
+			Fail("unable to start registry on port %s", port)
 		}
 
 		podmanTest.RestoreArtifact(ALPINE)
-		image := fmt.Sprintf("%s/my-alpine", registryEndpoints[4].Address())
+		image := fmt.Sprintf("%s/my-alpine", ep.Address())
 		push := podmanTest.Podman([]string{"push", "--tls-verify=false", "--remove-signatures", ALPINE, image})
 		push.WaitWithDefaultTimeout()
 		Expect(push).Should(Exit(0))
 
 		// registries.conf set up
 		var buffer bytes.Buffer
-		registryFileTmpl.Execute(&buffer, registryEndpoints[4])
+		registryFileTmpl.Execute(&buffer, ep)
 		podmanTest.setRegistriesConfigEnv(buffer.Bytes())
 		ioutil.WriteFile(fmt.Sprintf("%s/registry4.conf", tempdir), buffer.Bytes(), 0644)
 		if IsRemote() {
@@ -323,25 +308,25 @@ registries = ['{{.Host}}:{{.Port}}']`
 		if podmanTest.Host.Arch == "ppc64le" {
 			Skip("No registry image for ppc64le")
 		}
-		lock := GetPortLock(registryEndpoints[5].Port)
-		defer lock.Unlock()
-		registry := podmanTest.Podman([]string{"run", "-d", "-p", fmt.Sprintf("%s:5000", registryEndpoints[5].Port),
+		port := GetPort()
+		ep := endpoint{Port: fmt.Sprintf("%d", port), Host: "localhost"}
+		registry := podmanTest.Podman([]string{"run", "-d", "-p", fmt.Sprintf("%d:5000", port),
 			"--name", "registry5", registry})
 		registry.WaitWithDefaultTimeout()
 		Expect(registry).Should(Exit(0))
 
 		if !WaitContainerReady(podmanTest, "registry5", "listening on", 20, 1) {
-			Skip("Cannot start docker registry.")
+			Fail("Cannot start docker registry on port %s", port)
 		}
 
 		podmanTest.RestoreArtifact(ALPINE)
-		image := fmt.Sprintf("%s/my-alpine", registryEndpoints[5].Address())
+		image := fmt.Sprintf("%s/my-alpine", ep.Address())
 		push := podmanTest.Podman([]string{"push", "--tls-verify=false", "--remove-signatures", ALPINE, image})
 		push.WaitWithDefaultTimeout()
 		Expect(push).Should(Exit(0))
 
 		var buffer bytes.Buffer
-		registryFileTmpl.Execute(&buffer, registryEndpoints[5])
+		registryFileTmpl.Execute(&buffer, ep)
 		podmanTest.setRegistriesConfigEnv(buffer.Bytes())
 		ioutil.WriteFile(fmt.Sprintf("%s/registry5.conf", tempdir), buffer.Bytes(), 0644)
 
@@ -360,25 +345,25 @@ registries = ['{{.Host}}:{{.Port}}']`
 		if podmanTest.Host.Arch == "ppc64le" {
 			Skip("No registry image for ppc64le")
 		}
-		lock := GetPortLock(registryEndpoints[6].Port)
-		defer lock.Unlock()
-		registry := podmanTest.Podman([]string{"run", "-d", "-p", fmt.Sprintf("%s:5000", registryEndpoints[6].Port),
+		port := GetPort()
+		ep := endpoint{Port: fmt.Sprintf("%d", port), Host: "localhost"}
+		registry := podmanTest.Podman([]string{"run", "-d", "-p", fmt.Sprintf("%d:5000", port),
 			"--name", "registry6", registry})
 		registry.WaitWithDefaultTimeout()
 		Expect(registry).Should(Exit(0))
 
 		if !WaitContainerReady(podmanTest, "registry6", "listening on", 20, 1) {
-			Skip("Cannot start docker registry.")
+			Fail("Cannot start docker registry on port %s", port)
 		}
 
 		podmanTest.RestoreArtifact(ALPINE)
-		image := fmt.Sprintf("%s/my-alpine", registryEndpoints[6].Address())
+		image := fmt.Sprintf("%s/my-alpine", ep.Address())
 		push := podmanTest.Podman([]string{"push", "--tls-verify=false", "--remove-signatures", ALPINE, image})
 		push.WaitWithDefaultTimeout()
 		Expect(push).Should(Exit(0))
 
 		var buffer bytes.Buffer
-		registryFileBadTmpl.Execute(&buffer, registryEndpoints[6])
+		registryFileBadTmpl.Execute(&buffer, ep)
 		podmanTest.setRegistriesConfigEnv(buffer.Bytes())
 		ioutil.WriteFile(fmt.Sprintf("%s/registry6.conf", tempdir), buffer.Bytes(), 0644)
 
@@ -402,36 +387,36 @@ registries = ['{{.Host}}:{{.Port}}']`
 		if podmanTest.Host.Arch == "ppc64le" {
 			Skip("No registry image for ppc64le")
 		}
-		lock7 := GetPortLock(registryEndpoints[7].Port)
-		defer lock7.Unlock()
-		lock8 := GetPortLock("6000")
-		defer lock8.Unlock()
+		port1 := GetPort()
+		port2 := GetPort()
+		port3 := GetPort()
+		ep3 := endpoint{Port: fmt.Sprintf("%d", port3), Host: "localhost"}
 
-		registryLocal := podmanTest.Podman([]string{"run", "-d", "--net=host", "-p", fmt.Sprintf("%s:5000", registryEndpoints[7].Port),
+		registryLocal := podmanTest.Podman([]string{"run", "-d", "-p", fmt.Sprintf("%d", port1),
 			"--name", "registry7", registry})
 		registryLocal.WaitWithDefaultTimeout()
 		Expect(registryLocal).Should(Exit(0))
 
 		if !WaitContainerReady(podmanTest, "registry7", "listening on", 20, 1) {
-			Skip("Cannot start docker registry.")
+			Fail("Cannot start docker registry on port %s", port1)
 		}
 
-		registryLocal = podmanTest.Podman([]string{"run", "-d", "-p", "6000:5000", "--name", "registry8", registry})
+		registryLocal = podmanTest.Podman([]string{"run", "-d", "-p", fmt.Sprintf("%d:5000", port2), "--name", "registry8", registry})
 		registryLocal.WaitWithDefaultTimeout()
 		Expect(registryLocal).Should(Exit(0))
 
 		if !WaitContainerReady(podmanTest, "registry8", "listening on", 20, 1) {
-			Skip("Cannot start docker registry.")
+			Fail("Cannot start docker registry on port %s", port2)
 		}
 
 		podmanTest.RestoreArtifact(ALPINE)
-		push := podmanTest.Podman([]string{"push", "--tls-verify=false", "--remove-signatures", ALPINE, "localhost:6000/my-alpine"})
+		push := podmanTest.Podman([]string{"push", "--tls-verify=false", "--remove-signatures", ALPINE, fmt.Sprintf("localhost:%d/my-alpine", port2)})
 		push.WaitWithDefaultTimeout()
 		Expect(push).Should(Exit(0))
 
 		// registries.conf set up
 		var buffer bytes.Buffer
-		registryFileTwoTmpl.Execute(&buffer, registryEndpoints[8])
+		registryFileTwoTmpl.Execute(&buffer, ep3)
 		podmanTest.setRegistriesConfigEnv(buffer.Bytes())
 		ioutil.WriteFile(fmt.Sprintf("%s/registry8.conf", tempdir), buffer.Bytes(), 0644)
 
diff --git a/test/utils/utils.go b/test/utils/utils.go
index 1f5067950..14092a2a5 100644
--- a/test/utils/utils.go
+++ b/test/utils/utils.go
@@ -12,12 +12,34 @@ import (
 	"strings"
 	"time"
 
+	"github.com/sirupsen/logrus"
+
 	"github.com/containers/storage/pkg/parsers/kernel"
 	. "github.com/onsi/ginkgo"       //nolint:golint,stylecheck
 	. "github.com/onsi/gomega"       //nolint:golint,stylecheck
 	. "github.com/onsi/gomega/gexec" //nolint:golint,stylecheck
 )
 
+type NetworkBackend int
+
+const (
+	// Container Networking backend
+	CNI NetworkBackend = iota
+	// Netavark network backend
+	Netavark NetworkBackend = iota
+)
+
+func (n NetworkBackend) ToString() string {
+	switch n {
+	case CNI:
+		return "cni"
+	case Netavark:
+		return "netavark"
+	}
+	logrus.Errorf("unknown network backend: %q", n)
+	return ""
+}
+
 var (
 	DefaultWaitTimeout   = 90
 	OSReleasePath        = "/etc/os-release"
@@ -34,17 +56,18 @@ type PodmanTestCommon interface {
 
 // PodmanTest struct for command line options
 type PodmanTest struct {
-	PodmanMakeOptions  func(args []string, noEvents, noCache bool) []string
+	ImageCacheDir      string
+	ImageCacheFS       string
+	NetworkBackend     NetworkBackend
 	PodmanBinary       string
-	TempDir            string
-	RemoteTest         bool
+	PodmanMakeOptions  func(args []string, noEvents, noCache bool) []string
+	RemoteCommand      *exec.Cmd
 	RemotePodmanBinary string
 	RemoteSession      *os.Process
 	RemoteSocket       string
 	RemoteSocketLock   string // If not "", should be removed _after_ RemoteSocket is removed
-	RemoteCommand      *exec.Cmd
-	ImageCacheDir      string
-	ImageCacheFS       string
+	RemoteTest         bool
+	TempDir            string
 }
 
 // PodmanSession wraps the gexec.session so we can extend it
@@ -73,8 +96,10 @@ func (p *PodmanTest) PodmanAsUserBase(args []string, uid, gid uint32, cwd string
 	if p.RemoteTest {
 		podmanBinary = p.RemotePodmanBinary
 	}
-
 	runCmd := append(wrapper, podmanBinary)
+	if p.NetworkBackend == Netavark {
+		runCmd = append(runCmd, []string{"--network-backend", "netavark"}...)
+	}
 	if p.RemoteTest {
 		podmanOptions = append([]string{"--remote", "--url", p.RemoteSocket}, podmanOptions...)
 	}