@@ -386,7 +386,8 @@ func (s *DockerSwarmSuite) TestSwarmContainerAttachByNetworkId(c *testing.T) {

 	out, err = d.Cmd("run", "-d", "--net", networkID, "busybox", "top")

 	assert.NilError(c, err, out)

 	cID := strings.TrimSpace(out)

-	d.WaitRun(cID)

+	err = d.WaitRun(cID)

+	assert.NilError(c, err)

 	out, err = d.Cmd("rm", "-f", cID)

 	assert.NilError(c, err, out)

@@ -640,16 +641,18 @@ const (

 	globalIPAMPlugin    = "global-ipam-plugin"

 )

-func setupRemoteGlobalNetworkPlugin(c *testing.T, mux *http.ServeMux, url, netDrv, ipamDrv string) {

+func setupRemoteGlobalNetworkPlugin(t *testing.T, mux *http.ServeMux, url, netDrv, ipamDrv string) {

 	mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) {

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

-		fmt.Fprintf(w, `{"Implements": ["%s", "%s"]}`, driverapi.NetworkPluginEndpointType, ipamapi.PluginEndpointType)

+		_, err := fmt.Fprintf(w, `{"Implements": ["%s", "%s"]}`, driverapi.NetworkPluginEndpointType, ipamapi.PluginEndpointType)

+		assert.NilError(t, err)

 	})

 	// Network driver implementation

 	mux.HandleFunc(fmt.Sprintf("/%s.GetCapabilities", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

-		fmt.Fprintf(w, `{"Scope":"global"}`)

+		_, err := fmt.Fprint(w, `{"Scope":"global"}`)

+		assert.NilError(t, err)

 	})

 	mux.HandleFunc(fmt.Sprintf("/%s.AllocateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

@@ -659,12 +662,14 @@ func setupRemoteGlobalNetworkPlugin(c *testing.T, mux *http.ServeMux, url, netDr

 			return

 		}

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

-		fmt.Fprintf(w, "null")

+		_, err = fmt.Fprint(w, "null")

+		assert.NilError(t, err)

 	})

 	mux.HandleFunc(fmt.Sprintf("/%s.FreeNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

-		fmt.Fprintf(w, "null")

+		_, err := fmt.Fprint(w, "null")

+		assert.NilError(t, err)

 	})

 	mux.HandleFunc(fmt.Sprintf("/%s.CreateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

@@ -674,17 +679,20 @@ func setupRemoteGlobalNetworkPlugin(c *testing.T, mux *http.ServeMux, url, netDr

 			return

 		}

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

-		fmt.Fprintf(w, "null")

+		_, err = fmt.Fprint(w, "null")

+		assert.NilError(t, err)

 	})

 	mux.HandleFunc(fmt.Sprintf("/%s.DeleteNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

-		fmt.Fprintf(w, "null")

+		_, err := fmt.Fprint(w, "null")

+		assert.NilError(t, err)

 	})

 	mux.HandleFunc(fmt.Sprintf("/%s.CreateEndpoint", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

-		fmt.Fprintf(w, `{"Interface":{"MacAddress":"a0:b1:c2:d3:e4:f5"}}`)

+		_, err := fmt.Fprint(w, `{"Interface":{"MacAddress":"a0:b1:c2:d3:e4:f5"}}`)

+		assert.NilError(t, err)

 	})

 	mux.HandleFunc(fmt.Sprintf("/%s.Join", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

@@ -694,23 +702,28 @@ func setupRemoteGlobalNetworkPlugin(c *testing.T, mux *http.ServeMux, url, netDr

 			LinkAttrs: netlink.LinkAttrs{Name: "randomIfName", TxQLen: 0}, PeerName: "cnt0",

 		}

 		if err := netlink.LinkAdd(veth); err != nil {

-			fmt.Fprintf(w, `{"Error":"failed to add veth pair: `+err.Error()+`"}`)

+			_, err = fmt.Fprint(w, `{"Error":"failed to add veth pair: `+err.Error()+`"}`)

+			assert.NilError(t, err)

 		} else {

-			fmt.Fprintf(w, `{"InterfaceName":{ "SrcName":"cnt0", "DstPrefix":"veth"}}`)

+			_, err = fmt.Fprint(w, `{"InterfaceName":{ "SrcName":"cnt0", "DstPrefix":"veth"}}`)

+			assert.NilError(t, err)

 		}

 	})

 	mux.HandleFunc(fmt.Sprintf("/%s.Leave", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

-		fmt.Fprintf(w, "null")

+		_, err := fmt.Fprint(w, "null")

+		assert.NilError(t, err)

 	})

 	mux.HandleFunc(fmt.Sprintf("/%s.DeleteEndpoint", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

 		if link, err := netlink.LinkByName("cnt0"); err == nil {

-			netlink.LinkDel(link)

+			err := netlink.LinkDel(link)

+			assert.NilError(t, err)

 		}

-		fmt.Fprintf(w, "null")

+		_, err := fmt.Fprint(w, "null")

+		assert.NilError(t, err)

 	})

 	// IPAM Driver implementation

@@ -719,16 +732,19 @@ func setupRemoteGlobalNetworkPlugin(c *testing.T, mux *http.ServeMux, url, netDr

 		poolReleaseReq    remoteipam.ReleasePoolRequest

 		addressRequest    remoteipam.RequestAddressRequest

 		addressReleaseReq remoteipam.ReleaseAddressRequest

-		lAS               = "localAS"

-		gAS               = "globalAS"

-		pool              = "172.28.0.0/16"

-		poolID            = lAS + "/" + pool

-		gw                = "172.28.255.254/16"

+	)

+	const (

+		lAS    = "localAS"

+		gAS    = "globalAS"

+		pool   = "172.28.0.0/16"

+		poolID = lAS + "/" + pool

+		gw     = "172.28.255.254/16"

 	)

 	mux.HandleFunc(fmt.Sprintf("/%s.GetDefaultAddressSpaces", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

-		fmt.Fprintf(w, `{"LocalDefaultAddressSpace":"`+lAS+`", "GlobalDefaultAddressSpace": "`+gAS+`"}`)

+		_, err := fmt.Fprint(w, `{"LocalDefaultAddressSpace":"`+lAS+`", "GlobalDefaultAddressSpace": "`+gAS+`"}`)

+		assert.NilError(t, err)

 	})

 	mux.HandleFunc(fmt.Sprintf("/%s.RequestPool", ipamapi.PluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

@@ -739,11 +755,14 @@ func setupRemoteGlobalNetworkPlugin(c *testing.T, mux *http.ServeMux, url, netDr

 		}

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

 		if poolRequest.AddressSpace != lAS && poolRequest.AddressSpace != gAS {

-			fmt.Fprintf(w, `{"Error":"Unknown address space in pool request: `+poolRequest.AddressSpace+`"}`)

+			_, err := fmt.Fprint(w, `{"Error":"Unknown address space in pool request: `+poolRequest.AddressSpace+`"}`)

+			assert.NilError(t, err)

 		} else if poolRequest.Pool != "" && poolRequest.Pool != pool {

-			fmt.Fprintf(w, `{"Error":"Cannot handle explicit pool requests yet"}`)

+			_, err := fmt.Fprint(w, `{"Error":"Cannot handle explicit pool requests yet"}`)

+			assert.NilError(t, err)

 		} else {

-			fmt.Fprintf(w, `{"PoolID":"`+poolID+`", "Pool":"`+pool+`"}`)

+			_, err := fmt.Fprint(w, `{"PoolID":"`+poolID+`", "Pool":"`+pool+`"}`)

+			assert.NilError(t, err)

 		}

 	})

@@ -756,11 +775,14 @@ func setupRemoteGlobalNetworkPlugin(c *testing.T, mux *http.ServeMux, url, netDr

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

 		// make sure libnetwork is now querying on the expected pool id

 		if addressRequest.PoolID != poolID {

-			fmt.Fprintf(w, `{"Error":"unknown pool id"}`)

+			_, err := fmt.Fprint(w, `{"Error":"unknown pool id"}`)

+			assert.NilError(t, err)

 		} else if addressRequest.Address != "" {

-			fmt.Fprintf(w, `{"Error":"Cannot handle explicit address requests yet"}`)

+			_, err := fmt.Fprint(w, `{"Error":"Cannot handle explicit address requests yet"}`)

+			assert.NilError(t, err)

 		} else {

-			fmt.Fprintf(w, `{"Address":"`+gw+`"}`)

+			_, err := fmt.Fprint(w, `{"Address":"`+gw+`"}`)

+			assert.NilError(t, err)

 		}

 	})

@@ -773,11 +795,14 @@ func setupRemoteGlobalNetworkPlugin(c *testing.T, mux *http.ServeMux, url, netDr

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

 		// make sure libnetwork is now asking to release the expected address from the expected poolid

 		if addressRequest.PoolID != poolID {

-			fmt.Fprintf(w, `{"Error":"unknown pool id"}`)

+			_, err := fmt.Fprint(w, `{"Error":"unknown pool id"}`)

+			assert.NilError(t, err)

 		} else if addressReleaseReq.Address != gw {

-			fmt.Fprintf(w, `{"Error":"unknown address"}`)

+			_, err := fmt.Fprint(w, `{"Error":"unknown address"}`)

+			assert.NilError(t, err)

 		} else {

-			fmt.Fprintf(w, "null")

+			_, err := fmt.Fprint(w, "null")

+			assert.NilError(t, err)

 		}

 	})

@@ -790,22 +815,24 @@ func setupRemoteGlobalNetworkPlugin(c *testing.T, mux *http.ServeMux, url, netDr

 		w.Header().Set("Content-Type", plugins.VersionMimetype)

 		// make sure libnetwork is now asking to release the expected poolid

 		if addressRequest.PoolID != poolID {

-			fmt.Fprintf(w, `{"Error":"unknown pool id"}`)

+			_, err := fmt.Fprint(w, `{"Error":"unknown pool id"}`)

+			assert.NilError(t, err)

 		} else {

-			fmt.Fprintf(w, "null")

+			_, err := fmt.Fprint(w, "null")

+			assert.NilError(t, err)

 		}

 	})

 	err := os.MkdirAll("/etc/docker/plugins", 0o755)

-	assert.NilError(c, err)

+	assert.NilError(t, err)

 	fileName := fmt.Sprintf("/etc/docker/plugins/%s.spec", netDrv)

 	err = os.WriteFile(fileName, []byte(url), 0o644)

-	assert.NilError(c, err)

+	assert.NilError(t, err)

 	ipamFileName := fmt.Sprintf("/etc/docker/plugins/%s.spec", ipamDrv)

 	err = os.WriteFile(ipamFileName, []byte(url), 0o644)

-	assert.NilError(c, err)

+	assert.NilError(t, err)

 }

 func (s *DockerSwarmSuite) TestSwarmNetworkPlugin(c *testing.T) {