@@ -4,6 +4,7 @@ import (

 	"time"

 	dockerspec "github.com/moby/docker-image-spec/specs-go/v1"

+	"github.com/moby/moby/api/types/network"

 )

 // MinimumDuration puts a minimum on user configured duration.

@@ -28,7 +29,7 @@ type Config struct {

 	AttachStdin     bool                // Attach the standard input, makes possible user interaction

 	AttachStdout    bool                // Attach the standard output

 	AttachStderr    bool                // Attach the standard error

-	ExposedPorts    PortSet             `json:",omitempty"` // List of exposed ports

+	ExposedPorts    network.PortSet     `json:",omitempty"` // List of exposed ports

 	Tty             bool                // Attach standard streams to a tty, including stdin if it is not closed.

 	OpenStdin       bool                // Open stdin

 	StdinOnce       bool                // If true, close stdin after the 1 attached client disconnects.

@@ -421,7 +421,7 @@ type HostConfig struct {

 	ContainerIDFile string            // File (path) where the containerId is written

 	LogConfig       LogConfig         // Configuration of the logs for this container

 	NetworkMode     NetworkMode       // Network mode to use for the container

-	PortBindings    PortMap           // Port mapping between the exposed port (container) and the host

+	PortBindings    network.PortMap   // Port mapping between the exposed port (container) and the host

 	RestartPolicy   RestartPolicy     // Restart policy to be used for the container

 	AutoRemove      bool              // Automatically remove container when it exits

 	VolumeDriver    string            // Name of the volume driver used to mount volumes

deleted file mode 100644

@@ -1,346 +0,0 @@

-package container

-

-import (

-	"errors"

-	"fmt"

-	"iter"

-	"net/netip"

-	"strconv"

-	"strings"

-	"unique"

-)

-

-// NetworkProtocol represents a network protocol for a port.

-type NetworkProtocol string

-

-const (

-	TCP  NetworkProtocol = "tcp"

-	UDP  NetworkProtocol = "udp"

-	SCTP NetworkProtocol = "sctp"

-)

-

-// Sentinel port proto value for zero Port and PortRange values.

-var protoZero unique.Handle[NetworkProtocol]

-

-// Port is a type representing a single port number and protocol in the format "<portnum>/[<proto>]".

-//

-// The zero port value, i.e. Port{}, is invalid; use [ParsePort] to create a valid Port value.

-type Port struct {

-	num   uint16

-	proto unique.Handle[NetworkProtocol]

-}

-

-// ParsePort parses s as a [Port].

-//

-// It normalizes the provided protocol such that "80/tcp", "80/TCP", and "80/tCp" are equivalent.

-// If a port number is provided, but no protocol, the default ("tcp") protocol is returned.

-func ParsePort(s string) (Port, error) {

-	if s == "" {

-		return Port{}, errors.New("invalid port: value is empty")

-	}

-

-	port, proto, _ := strings.Cut(s, "/")

-

-	portNum, err := parsePortNumber(port)

-	if err != nil {

-		return Port{}, fmt.Errorf("invalid port '%s': %w", port, err)

-	}

-

-	normalizedPortProto := normalizePortProto(proto)

-	return Port{num: portNum, proto: normalizedPortProto}, nil

-}

-

-// MustParsePort calls [ParsePort](s) and panics on error.

-//

-// It is intended for use in tests with hard-coded strings.

-func MustParsePort(s string) Port {

-	p, err := ParsePort(s)

-	if err != nil {

-		panic(err)

-	}

-	return p

-}

-

-// PortFrom returns a [Port] with the given number and protocol.

-//

-// If no protocol is specified (i.e. proto == ""), then PortFrom returns Port{}, false.

-func PortFrom(num uint16, proto NetworkProtocol) (p Port, ok bool) {

-	if proto == "" {

-		return Port{}, false

-	}

-	normalized := normalizePortProto(string(proto))

-	return Port{num: num, proto: normalized}, true

-}

-

-// Num returns p's port number.

-func (p Port) Num() uint16 {

-	return p.num

-}

-

-// Proto returns p's network protocol.

-func (p Port) Proto() NetworkProtocol {

-	return p.proto.Value()

-}

-

-// IsZero reports whether p is the zero value.

-func (p Port) IsZero() bool {

-	return p.proto == protoZero

-}

-

-// IsValid reports whether p is an initialized valid port (not the zero value).

-func (p Port) IsValid() bool {

-	return p.proto != protoZero

-}

-

-// String returns a string representation of the port in the format "<portnum>/<proto>".

-// If the port is the zero value, it returns "invalid port".

-func (p Port) String() string {

-	switch p.proto {

-	case protoZero:

-		return "invalid port"

-	default:

-		return string(p.AppendTo(nil))

-	}

-}

-

-// AppendText implements [encoding.TextAppender] interface.

-// It is the same as [Port.AppendTo] but returns an error to satisfy the interface.

-func (p Port) AppendText(b []byte) ([]byte, error) {

-	return p.AppendTo(b), nil

-}

-

-// AppendTo appends a text encoding of p to b and returns the extended buffer.

-func (p Port) AppendTo(b []byte) []byte {

-	if p.IsZero() {

-		return b

-	}

-	return fmt.Appendf(b, "%d/%s", p.num, p.proto.Value())

-}

-

-// MarshalText implements [encoding.TextMarshaler] interface.

-func (p Port) MarshalText() ([]byte, error) {

-	return p.AppendText(nil)

-}

-

-// UnmarshalText implements [encoding.TextUnmarshaler] interface.

-func (p *Port) UnmarshalText(text []byte) error {

-	if len(text) == 0 {

-		*p = Port{}

-		return nil

-	}

-

-	port, err := ParsePort(string(text))

-	if err != nil {

-		return err

-	}

-

-	*p = port

-	return nil

-}

-

-// Range returns a [PortRange] representing the single port.

-func (p Port) Range() PortRange {

-	return PortRange{start: p.num, end: p.num, proto: p.proto}

-}

-

-// PortSet is a collection of structs indexed by [Port].

-type PortSet = map[Port]struct{}

-

-// PortBinding represents a binding between a Host IP address and a Host Port.

-type PortBinding struct {

-	// HostIP is the host IP Address

-	HostIP netip.Addr `json:"HostIp"`

-	// HostPort is the host port number

-	HostPort string `json:"HostPort"`

-}

-

-// PortMap is a collection of [PortBinding] indexed by [Port].

-type PortMap = map[Port][]PortBinding

-

-// PortRange represents a range of port numbers and a protocol in the format "8000-9000/tcp".

-//

-// The zero port range value, i.e. PortRange{}, is invalid; use [ParsePortRange] to create a valid PortRange value.

-type PortRange struct {

-	start uint16

-	end   uint16

-	proto unique.Handle[NetworkProtocol]

-}

-

-// ParsePortRange parses s as a [PortRange].

-//

-// It normalizes the provided protocol such that "80-90/tcp", "80-90/TCP", and "80-90/tCp" are equivalent.

-// If a port number range is provided, but no protocol, the default ("tcp") protocol is returned.

-func ParsePortRange(s string) (PortRange, error) {

-	if s == "" {

-		return PortRange{}, errors.New("invalid port range: value is empty")

-	}

-

-	portRange, proto, _ := strings.Cut(s, "/")

-

-	start, end, ok := strings.Cut(portRange, "-")

-	startVal, err := parsePortNumber(start)

-	if err != nil {

-		return PortRange{}, fmt.Errorf("invalid start port '%s': %w", start, err)

-	}

-

-	portProto := normalizePortProto(proto)

-

-	if !ok || start == end {

-		return PortRange{start: startVal, end: startVal, proto: portProto}, nil

-	}

-

-	endVal, err := parsePortNumber(end)

-	if err != nil {

-		return PortRange{}, fmt.Errorf("invalid end port '%s': %w", end, err)

-	}

-	if endVal < startVal {

-		return PortRange{}, errors.New("invalid port range: " + s)

-	}

-	return PortRange{start: startVal, end: endVal, proto: portProto}, nil

-}

-

-// MustParsePortRange calls [ParsePortRange](s) and panics on error.

-// It is intended for use in tests with hard-coded strings.

-func MustParsePortRange(s string) PortRange {

-	pr, err := ParsePortRange(s)

-	if err != nil {

-		panic(err)

-	}

-	return pr

-}

-

-// PortRangeFrom returns a [PortRange] with the given start and end port numbers and protocol.

-//

-// If end < start or no protocol is specified (i.e. proto == ""), then PortRangeFrom returns PortRange{}, false.

-func PortRangeFrom(start, end uint16, proto NetworkProtocol) (pr PortRange, ok bool) {

-	if end < start || proto == "" {

-		return PortRange{}, false

-	}

-	normalized := normalizePortProto(string(proto))

-	return PortRange{start: start, end: end, proto: normalized}, true

-}

-

-// Start returns pr's start port number.

-func (pr PortRange) Start() uint16 {

-	return pr.start

-}

-

-// End returns pr's end port number.

-func (pr PortRange) End() uint16 {

-	return pr.end

-}

-

-// Proto returns pr's network protocol.

-func (pr PortRange) Proto() NetworkProtocol {

-	return pr.proto.Value()

-}

-

-// IsZero reports whether pr is the zero value.

-func (pr PortRange) IsZero() bool {

-	return pr.proto == protoZero

-}

-

-// IsValid reports whether pr is an initialized valid port range (not the zero value).

-func (pr PortRange) IsValid() bool {

-	return pr.proto != protoZero

-}

-

-// String returns a string representation of the port range in the format "<start>-<end>/<proto>" or "<portnum>/<proto>" if start == end.

-// If the port range is the zero value, it returns "invalid port range".

-func (pr PortRange) String() string {

-	switch pr.proto {

-	case protoZero:

-		return "invalid port range"

-	default:

-		return string(pr.AppendTo(nil))

-	}

-}

-

-// AppendText implements [encoding.TextAppender] interface.

-// It is the same as [PortRange.AppendTo] but returns an error to satisfy the interface.

-func (pr PortRange) AppendText(b []byte) ([]byte, error) {

-	return pr.AppendTo(b), nil

-}

-

-// AppendTo appends a text encoding of pr to b and returns the extended buffer.

-func (pr PortRange) AppendTo(b []byte) []byte {

-	if pr.IsZero() {

-		return b

-	}

-	if pr.start == pr.end {

-		return fmt.Appendf(b, "%d/%s", pr.start, pr.proto.Value())

-	}

-	return fmt.Appendf(b, "%d-%d/%s", pr.start, pr.end, pr.proto.Value())

-}

-

-// MarshalText implements [encoding.TextMarshaler] interface.

-func (pr PortRange) MarshalText() ([]byte, error) {

-	return pr.AppendText(nil)

-}

-

-// UnmarshalText implements [encoding.TextUnmarshaler] interface.

-func (pr *PortRange) UnmarshalText(text []byte) error {

-	if len(text) == 0 {

-		*pr = PortRange{}

-		return nil

-	}

-

-	portRange, err := ParsePortRange(string(text))

-	if err != nil {

-		return err

-	}

-	*pr = portRange

-	return nil

-}

-

-// Range returns pr.

-func (pr PortRange) Range() PortRange {

-	return pr

-}

-

-// All returns an iterator over all the individual ports in the range.

-//

-// For example:

-//

-//	for port := range pr.All() {

-//	    // ...

-//	}

-func (pr PortRange) All() iter.Seq[Port] {

-	return func(yield func(Port) bool) {

-		for i := uint32(pr.Start()); i <= uint32(pr.End()); i++ {

-			if !yield(Port{num: uint16(i), proto: pr.proto}) {

-				return

-			}

-		}

-	}

-}

-

-// parsePortNumber parses rawPort into an int, unwrapping strconv errors

-// and returning a single "out of range" error for any value outside 0–65535.

-func parsePortNumber(rawPort string) (uint16, error) {

-	if rawPort == "" {

-		return 0, errors.New("value is empty")

-	}

-	port, err := strconv.ParseUint(rawPort, 10, 16)

-	if err != nil {

-		var numErr *strconv.NumError

-		if errors.As(err, &numErr) {

-			err = numErr.Err

-		}

-		return 0, err

-	}

-

-	return uint16(port), nil

-}

-

-// normalizePortProto normalizes the protocol string such that "tcp", "TCP", and "tCp" are equivalent.

-// If proto is not specified, it defaults to "tcp".

-func normalizePortProto(proto string) unique.Handle[NetworkProtocol] {

-	if proto == "" {

-		return unique.Make(TCP)

-	}

-

-	proto = strings.ToLower(proto)

-

-	return unique.Make(NetworkProtocol(proto))

-}

@@ -6,10 +6,13 @@ import (

 // NetworkSettings exposes the network settings in the api

 type NetworkSettings struct {

-	SandboxID  string  // SandboxID uniquely represents a container's network stack

-	SandboxKey string  // SandboxKey identifies the sandbox

-	Ports      PortMap // Ports is a collection of PortBinding indexed by Port

-	Networks   map[string]*network.EndpointSettings

+	SandboxID  string // SandboxID uniquely represents a container's network stack

+	SandboxKey string // SandboxKey identifies the sandbox

+

+	// Ports is a collection of [network.PortBinding] indexed by [network.Port]

+	Ports network.PortMap

+

+	Networks map[string]*network.EndpointSettings

 }

 // NetworkSettingsSummary provides a summary of container's networks

deleted file mode 100644

@@ -1,600 +0,0 @@

-package container

-

-import (

-	"encoding/json"

-	"fmt"

-	"reflect"

-	"slices"

-	"strings"

-	"testing"

-

-	"gotest.tools/v3/assert"

-)

-

-type TestRanger interface {

-	Range() PortRange

-}

-

-var _ TestRanger = Port{}

-var _ TestRanger = PortRange{}

-

-func TestPort(t *testing.T) {

-	t.Run("Zero Value", func(t *testing.T) {

-		var p Port

-		assert.Check(t, p.IsZero())

-		assert.Check(t, !p.IsValid())

-		assert.Equal(t, p.String(), "invalid port")

-

-		t.Run("Marshal Unmarshal", func(t *testing.T) {

-			var p Port

-			bytes, err := p.MarshalText()

-			assert.NilError(t, err)

-			assert.Check(t, len(bytes) == 0)

-

-			err = p.UnmarshalText([]byte(""))

-			assert.NilError(t, err)

-			assert.Equal(t, p, Port{})

-		})

-

-		t.Run("JSON Marshal Unmarshal", func(t *testing.T) {

-			var p Port

-			bytes, err := json.Marshal(p)

-			assert.NilError(t, err)

-			assert.Equal(t, string(bytes), `""`)

-

-			err = json.Unmarshal([]byte(`""`), &p)

-			assert.NilError(t, err)

-			assert.Equal(t, p, Port{})

-		})

-	})

-

-	t.Run("PortFrom", func(t *testing.T) {

-		tests := []struct {

-			num   uint16

-			proto NetworkProtocol

-		}{

-			{0, TCP},

-			{80, TCP},

-			{8080, TCP},

-			{65535, TCP},

-			{80, UDP},

-			{8080, SCTP},

-		}

-

-		for _, tc := range tests {

-			t.Run(fmt.Sprintf("%d_%s", tc.num, tc.proto), func(t *testing.T) {

-				p, ok := PortFrom(tc.num, tc.proto)

-				assert.Check(t, ok)

-				assert.Equal(t, p.Num(), tc.num)

-				assert.Equal(t, p.Proto(), tc.proto)

-			})

-		}

-

-		t.Run("Normalize Protocol", func(t *testing.T) {

-			pr1 := portFrom(1234, "tcp")

-			pr2 := portFrom(1234, "TCP")

-			pr3 := portFrom(1234, "tCp")

-			assert.Equal(t, pr1, pr2)

-			assert.Equal(t, pr2, pr3)

-		})

-

-		negativeTests := []struct {

-			num   uint16

-			proto NetworkProtocol

-		}{

-			{0, ""},

-			{80, ""},

-		}

-		for _, tc := range negativeTests {

-			t.Run(fmt.Sprintf("%d_%s", tc.num, tc.proto), func(t *testing.T) {

-				p, ok := PortFrom(tc.num, tc.proto)

-				assert.Check(t, !ok)

-				assert.Check(t, p.IsZero())

-				assert.Check(t, !p.IsValid())

-				assert.Equal(t, p.String(), "invalid port")

-			})

-		}

-	})

-

-	t.Run("ParsePort", func(t *testing.T) {

-		tests := []struct {

-			in        string

-			port      Port      // output of ParsePort()

-			str       string    // output of String().

-			portRange PortRange // output of Range()

-		}{

-			// Zero port

-			{

-				in:        "0/tcp",

-				port:      portFrom(0, TCP),

-				str:       "0/tcp",

-				portRange: portRangeFrom(0, 0, TCP),

-			},

-			// Max valid port

-			{

-				in:        "65535/tcp",

-				port:      portFrom(65535, TCP),

-				str:       "65535/tcp",

-				portRange: portRangeFrom(65535, 65535, TCP),

-			},

-			// Simple valid ports

-			{

-				in:        "1234/tcp",

-				port:      portFrom(1234, TCP),

-				str:       "1234/tcp",

-				portRange: portRangeFrom(1234, 1234, TCP),

-			},

-			{

-				in:        "1234/udp",

-				port:      portFrom(1234, UDP),

-				str:       "1234/udp",

-				portRange: portRangeFrom(1234, 1234, UDP),

-			},

-			{

-				in:        "1234/sctp",

-				port:      portFrom(1234, SCTP),

-				str:       "1234/sctp",

-				portRange: portRangeFrom(1234, 1234, SCTP),

-			},

-			// Default protocol is tcp

-			{

-				in:        "1234",

-				port:      portFrom(1234, TCP),

-				str:       "1234/tcp",

-				portRange: portRangeFrom(1234, 1234, TCP),

-			},

-			// Default protocol is tcp

-			{

-				in:        "1234/",

-				port:      portFrom(1234, TCP),

-				str:       "1234/tcp",

-				portRange: portRangeFrom(1234, 1234, TCP),

-			},

-			{

-				in:        "1234/tcp:ipv6only",

-				port:      portFrom(1234, "tcp:ipv6only"),

-				str:       "1234/tcp:ipv6only",

-				portRange: portRangeFrom(1234, 1234, "tcp:ipv6only"),

-			},

-		}

-

-		for _, tc := range tests {

-			t.Run(strings.ReplaceAll(tc.in, "/", "_"), func(t *testing.T) {

-				got, err := ParsePort(tc.in)

-				assert.NilError(t, err)

-				assert.Equal(t, got, tc.port)

-

-				MustParsePort(tc.in) // should not panic

-

-				assert.Check(t, !got.IsZero())

-				assert.Check(t, got.IsValid())

-

-				// Check that ParsePort is a pure function.

-				got2, err := ParsePort(tc.in)

-				assert.NilError(t, err)

-				assert.Equal(t, got2, got)

-

-				// Check that ParsePort(port.String()) is the identity function.

-				got3, err := ParsePort(got.String())

-				assert.NilError(t, err)

-				assert.Equal(t, got3, got)

-

-				// Check String() output

-				s := got.String()

-				wants := tc.str

-				if wants == "" {

-					wants = tc.in

-				}

-				assert.Equal(t, s, wants)

-

-				js := `"` + tc.in + `"`

-				var jsgot Port

-				err = json.Unmarshal([]byte(js), &jsgot)

-				assert.NilError(t, err)

-				assert.Equal(t, jsgot, got)

-

-				jsb, err := json.Marshal(jsgot)

-				assert.NilError(t, err)

-

-				jswant := `"` + wants + `"`

-				assert.Equal(t, string(jsb), jswant)

-

-				// Check Range() output

-				r := got.Range()

-				assert.Equal(t, r, tc.portRange)

-			})

-		}

-

-		t.Run("Normalize Protocol", func(t *testing.T) {

-			p1 := MustParsePort("1234/tcp")

-			p2 := MustParsePort("1234/TCP")

-			p3 := MustParsePort("1234/tCp")

-			assert.Equal(t, p1, p2)

-			assert.Equal(t, p2, p3)

-		})

-

-		negativeTests := []string{

-			// Empty string

-			"",

-			// Whitespace-only string

-			" ",

-			// No port number

-			"/",

-			// No port number (protocol only)

-			"/tcp",

-			// Negative port

-			"-1",

-			// Too large port

-			"65536",

-			// Non-numeric port

-			"foo",

-			// Port range instead of single port

-			"1234-1240/udp",

-			// Port range instead of single port without protocol

-			"1234-1240",

-			// Garbage port

-			"asd1234/tcp",

-		}

-

-		for _, s := range negativeTests {

-			t.Run(strings.ReplaceAll(s, "/", "_"), func(t *testing.T) {

-				got, err := ParsePort(s)

-				assert.ErrorContains(t, err, "invalid port")

-				assert.Check(t, got.IsZero())

-				assert.Check(t, !got.IsValid())

-

-				// Skip JSON unmarshalling test for empty string as that should succeed.

-				// See test "Zero Value" above.

-				if s == "" {

-					return

-				}

-

-				var jsgot Port

-				js := []byte(`"` + s + `"`)

-				err = json.Unmarshal(js, &jsgot)

-				assert.ErrorContains(t, err, "invalid port")

-				assert.Equal(t, jsgot, Port{})

-			})

-		}

-	})

-}

-

-func TestPortRange(t *testing.T) {

-	t.Run("Zero Value", func(t *testing.T) {

-		var pr PortRange

-		assert.Check(t, pr.IsZero())

-		assert.Check(t, !pr.IsValid())

-		assert.Equal(t, pr.String(), "invalid port range")

-

-		t.Run("Marshal Unmarshal", func(t *testing.T) {

-			var pr PortRange

-			bytes, err := pr.MarshalText()

-			assert.NilError(t, err)

-			assert.Check(t, len(bytes) == 0)

-

-			err = pr.UnmarshalText([]byte(""))

-			assert.NilError(t, err)

-			assert.Equal(t, pr, PortRange{})

-		})

-

-		t.Run("JSON Marshal Unmarshal", func(t *testing.T) {

-			var pr PortRange

-			bytes, err := json.Marshal(pr)

-			assert.NilError(t, err)

-			assert.Equal(t, string(bytes), `""`)

-

-			err = json.Unmarshal([]byte(`""`), &pr)

-			assert.NilError(t, err)

-			assert.Equal(t, pr, PortRange{})

-		})

-	})

-

-	t.Run("PortRangeFrom", func(t *testing.T) {

-		tests := []struct {

-			start uint16

-			end   uint16

-			proto NetworkProtocol

-		}{

-			{0, 0, TCP},

-			{0, 1234, TCP},

-			{80, 80, TCP},

-			{80, 8080, TCP},

-			{1234, 65535, TCP},

-			{80, 80, UDP},

-			{80, 8080, SCTP},

-		}

-

-		for _, tc := range tests {

-			t.Run(fmt.Sprintf("%d_%d_%s", tc.start, tc.end, tc.proto), func(t *testing.T) {

-				pr, ok := PortRangeFrom(tc.start, tc.end, tc.proto)

-				assert.Check(t, ok)

-				assert.Equal(t, pr.Start(), tc.start)

-				assert.Equal(t, pr.End(), tc.end)

-				assert.Equal(t, pr.Proto(), tc.proto)

-			})

-		}

-

-		t.Run("Normalize Protocol", func(t *testing.T) {

-			pr1, _ := PortRangeFrom(1234, 5678, "tcp")

-			pr2, _ := PortRangeFrom(1234, 5678, "TCP")

-			pr3, _ := PortRangeFrom(1234, 5678, "tCp")

-			assert.Equal(t, pr1, pr2)

-			assert.Equal(t, pr2, pr3)

-		})

-

-		negativeTests := []struct {

-			start uint16

-			end   uint16

-			proto NetworkProtocol

-		}{

-			{1234, 80, TCP}, // end < start

-			{0, 0, ""},      // empty protocol

-		}

-		for _, tc := range negativeTests {

-			t.Run(fmt.Sprintf("%d_%d_%s", tc.start, tc.end, tc.proto), func(t *testing.T) {

-				pr, ok := PortRangeFrom(tc.start, tc.end, tc.proto)

-				assert.Check(t, !ok)

-				assert.Check(t, pr.IsZero())

-				assert.Check(t, !pr.IsValid())

-			})

-		}

-	})

-

-	t.Run("ParsePortRange", func(t *testing.T) {

-		tests := []struct {

-			in        string

-			portRange PortRange // output of ParsePortRange() and Range()

-			str       string    // output of String(). If "", use in.

-

-		}{

-			// Zero port

-			{

-				in:        "0-1234/tcp",

-				portRange: portRangeFrom(0, 1234, TCP),

-				str:       "0-1234/tcp",

-			},

-			// Max valid port

-			{

-				in:        "1234-65535/tcp",

-				portRange: portRangeFrom(1234, 65535, TCP),

-				str:       "1234-65535/tcp",

-			},

-			// Simple valid ports

-			{

-				in:        "1234-4567/tcp",

-				portRange: portRangeFrom(1234, 4567, TCP),

-				str:       "1234-4567/tcp",

-			},

-			{

-				in:        "1234-4567/udp",

-				portRange: portRangeFrom(1234, 4567, UDP),

-				str:       "1234-4567/udp",

-			},

-			// Default protocol is tcp

-			{

-				in:        "1234-4567",

-				portRange: portRangeFrom(1234, 4567, TCP),

-				str:       "1234-4567/tcp",

-			},

-			// Default protocol is tcp

-			{

-				in:        "1234-4567/",

-				portRange: portRangeFrom(1234, 4567, TCP),

-				str:       "1234-4567/tcp",

-			},

-			{

-				in:        "1234/tcp",

-				portRange: portRangeFrom(1234, 1234, TCP),

-				str:       "1234/tcp",

-			},

-			{

-				in:        "1234",

-				portRange: portRangeFrom(1234, 1234, TCP),

-				str:       "1234/tcp",

-			},

-			{

-				in:        "1234-5678/tcp:ipv6only",

-				portRange: portRangeFrom(1234, 5678, "tcp:ipv6only"),

-				str:       "1234-5678/tcp:ipv6only",

-			},

-		}

-

-		for _, tc := range tests {

-			t.Run(strings.ReplaceAll(tc.in, "/", "_"), func(t *testing.T) {

-				got, err := ParsePortRange(tc.in)

-				assert.NilError(t, err)

-				assert.Equal(t, got, tc.portRange)

-				assert.Check(t, !got.IsZero())

-				assert.Check(t, got.IsValid())

-

-				MustParsePortRange(tc.in) // should not panic

-

-				// Check that ParsePortRange is a pure function.

-				got2, err := ParsePortRange(tc.in)

-				assert.NilError(t, err)

-				assert.Equal(t, got2, got)

-

-				// Check that ParsePortRange(port.String()) is the identity function.

-				got3, err := ParsePortRange(got.String())

-				assert.NilError(t, err)

-				assert.Equal(t, got3, got)

-

-				// Check String() output

-				s := got.String()

-				wants := tc.str

-				if wants == "" {

-					wants = tc.in

-				}

-				assert.Equal(t, s, wants)

-

-				js := `"` + tc.in + `"`

-				var jsgot PortRange

-				err = json.Unmarshal([]byte(js), &jsgot)

-				assert.NilError(t, err)

-				assert.Equal(t, jsgot, got)

-

-				jsb, err := json.Marshal(jsgot)

-				assert.NilError(t, err)

-				jswant := `"` + wants + `"`

-				assert.Equal(t, string(jsb), jswant)

-

-				// Check Range() output

-				r := got.Range()

-				assert.Equal(t, r, tc.portRange)

-			})

-

-			t.Run("Normalize Protocol", func(t *testing.T) {

-				pr1 := MustParsePortRange("1234-5678/tcp")

-				pr2 := MustParsePortRange("1234-5678/TCP")

-				pr3 := MustParsePortRange("1234-5678/tCp")

-				assert.Equal(t, pr1, pr2)

-				assert.Equal(t, pr2, pr3)

-			})

-

-			negativeTests := []string{

-				// Empty string

-				"",

-				// Whitespace-only string

-				" ",

-				// No port number

-				"/",

-				// No port number (protocol only)

-				"/tcp",

-				// Negative start port

-				"-1-1234",

-				// Negative end port