}

type PortAllocator struct {
	portRange net.PortRange

	alloc allocator.Interface

	// metrics is a metrics recorder that can be disabled
	metrics metricsRecorderInterface
}

// PortAllocator implements Interface and Snapshottable
var _ Interface = &PortAllocator{}

// New creates a PortAllocator over a net.PortRange, calling allocatorFactory to construct the backing store.

	type args struct {
		pr net.PortRange
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		{
			name: "default node port range",
			args: args{
				pr: net.PortRange{
					Base: 30000,
					Size: 2768,
				},
			},
			want: 86,
		},
		{
			name: "very small node port range",
			args: args{
				pr: net.PortRange{
					Base: 30000,
					Size: 10,

	if serverDebugLog {
		fmt.Printf("%s < %d %s\n", sessionID, code, message)
	}
}

func startFTPServer(args []string) {
	var (
		port          int
		publicIP      string
		portRange     string
		tlsPrivateKey string
		tlsPublicCert string
	)

	var err error
	for _, arg := range args {
		tokens := strings.SplitN(arg, "=", 2)
		if len(tokens) != 2 {

  verbosity: 0
metricsBindAddress: 127.0.0.1:10249
mode: ""
nftables:
  masqueradeAll: false
  masqueradeBit: 14
  minSyncPeriod: 1s
  syncPeriod: 30s
nodePortAddresses: null
oomScoreAdj: -999
portRange: ""
showHiddenMetricsForVersion: ""
winkernel:
  enableDSR: false
  forwardHealthCheckVip: false
  networkName: ""
  rootHnsEndpointName: ""

			}
		})
	}
}

func makeOptionsWithPort(kubernetesServiceNodePort int, base int, size int) *ServerRunOptions {
	var portRange = utilnet.PortRange{
		Base: base,
		Size: size,
	}
	return &ServerRunOptions{
		Extra: Extra{
			ServiceNodePortRange:      portRange,
			KubernetesServiceNodePort: kubernetesServiceNodePort,
		},
	}
}

func TestValidateMaxCIDRRange(t *testing.T) {

		d()
		server.Terminate(t)
	}
	return server, storage, backing, s, destroyFunc
}

func validNewRangeAllocation() *api.RangeAllocation {
	portRange := fmt.Sprintf("%d-%d", basePortRange, basePortRange+sizePortRange-1)
	return &api.RangeAllocation{
		Range: portRange,
	}
}

func key() string {
	return "/ranges/servicenodeports"
}

  verbosity: 0
metricsBindAddress: 127.0.0.1:10249
mode: ""
nftables:
  masqueradeAll: false
  masqueradeBit: 14
  minSyncPeriod: 1s
  syncPeriod: 30s
nodePortAddresses: null
oomScoreAdj: -999
portRange: ""
showHiddenMetricsForVersion: ""
winkernel:
  enableDSR: false
  forwardHealthCheckVip: false
  networkName: ""
  rootHnsEndpointName: ""

			}
		}
	}

	if _, err := utilnet.ParsePortRange(config.PortRange); err != nil {
		allErrs = append(allErrs, field.Invalid(newPath.Child("PortRange"), config.PortRange, "must be a valid port range (e.g. 300-2000)"))
	}

	allErrs = append(allErrs, validateKubeProxyNodePortAddress(config.NodePortAddresses, newPath.Child("NodePortAddresses"))...)

	// configSyncPeriod is how often configuration from the apiserver is refreshed. Must be greater
	// than 0.
	ConfigSyncPeriod metav1.Duration

	// portRange was previously used to configure the userspace proxy, but is now unused.
	PortRange string
}

// ProxyMode represents modes used by the Kubernetes proxy server.
//
// Currently, three modes of proxy are available on Linux platforms: 'iptables', 'ipvs',

	PrimaryServiceClusterIPRange   net.IPNet
	SecondaryServiceClusterIPRange net.IPNet
	// APIServerServiceIP is the first valid IP from PrimaryServiceClusterIPRange
	APIServerServiceIP net.IP

	ServiceNodePortRange utilnet.PortRange

	EndpointReconcilerType string

	MasterCount int
}

// NewServerRunOptions creates a new ServerRunOptions object with default parameters
func NewServerRunOptions() *ServerRunOptions {
	s := ServerRunOptions{