{
			name: "graceful delete, no connections results in deleting the real server immediatetly",
			vs: &utilipvs.VirtualServer{
				Address:  netutils.ParseIPSloppy("1.1.1.1"),
				Protocol: "tcp",
				Port:     uint16(80),
			},
			rs: &utilipvs.RealServer{
				Address:      netutils.ParseIPSloppy("10.0.0.1"),
				Port:         uint16(80),
				Weight:       100,
				ActiveConn:   0,
				InactiveConn: 0,
			},

				Address: netutils.ParseIPSloppy("1.2.3.4"),
				Port:    3080,
			},
			rsB: &RealServer{
				Address: netutils.ParseIPSloppy("1.2.3.4"),
				Port:    3080,
			},
			equal:  true,
			reason: "All fields equal",
		},
		{
			rsA: &RealServer{
				Address: netutils.ParseIPSloppy("2012::beef"),
				Port:    3080,
			},
			rsB: &RealServer{
				Address: netutils.ParseIPSloppy("2012::beef"),
				Port:    3080,

				Weight:          1,
				Address:         netutils.ParseIPSloppy("1.2.3.4"),
			},
			RealServer{
				Address: netutils.ParseIPSloppy("1.2.3.4"),
				Port:    54321,
				Weight:  1,
			},
		},
		{
			libipvs.Destination{
				Port:            53,
				ConnectionFlags: 0,
				Weight:          1,
				Address:         netutils.ParseIPSloppy("2002::cafe"),
			},
			RealServer{

					addrs: []net.Addr{
						&net.IPNet{IP: netutils.ParseIPSloppy("1.2.3.4"), Mask: net.CIDRMask(30, 32)},
						&net.IPNet{IP: netutils.ParseIPSloppy("2001:db8::1"), Mask: net.CIDRMask(64, 128)},
					},
				},
				{
					itf: net.Interface{Index: 1, MTU: 0, Name: "lo", HardwareAddr: nil, Flags: 0},
					addrs: []net.Addr{
						&net.IPNet{IP: netutils.ParseIPSloppy("127.0.0.1"), Mask: net.CIDRMask(8, 32)},

	defer destroyFunc()
	if err := storage.Allocate(netutils.ParseIPSloppy("192.168.1.2")); !strings.Contains(err.Error(), "cannot allocate resources of type serviceipallocations at this time") {
		t.Fatal(err)
	}
}

func TestErrors(t *testing.T) {
	_, storage, _, _, destroyFunc := newStorage(t)
	defer destroyFunc()
	err := storage.Allocate(netutils.ParseIPSloppy("192.168.0.0"))
	if _, ok := err.(*ipallocator.ErrNotInRange); !ok {

		testOptions *ServerRunOptions
		expectErr   string
	}{
		{
			name: "Test when MaxRequestsInFlight is negative value",
			testOptions: &ServerRunOptions{
				AdvertiseAddress:            netutils.ParseIPSloppy("192.168.10.10"),
				CorsAllowedOriginList:       []string{"10.10.10.100", "10.10.10.200"},
				MaxRequestsInFlight:         -400,
				MaxMutatingRequestsInFlight: 200,

	upIntf       = makeIntf(1, "eth3", flagUp)
)

var (
	ipv4Route = Route{Interface: "eth3", Destination: netutils.ParseIPSloppy("0.0.0.0"), Gateway: netutils.ParseIPSloppy("10.254.0.1"), Family: familyIPv4}
	ipv6Route = Route{Interface: "eth3", Destination: netutils.ParseIPSloppy("::"), Gateway: netutils.ParseIPSloppy("2001:1::1"), Family: familyIPv6}
)

var (
	noRoutes   = []Route{}
	routeV4    = []Route{ipv4Route}

	vs := &utilipvs.VirtualServer{
		Address:  netutils.ParseIPSloppy("10.20.30.40"),
		Port:     uint16(80),
		Protocol: string("TCP"),
	}
	rss := []*utilipvs.RealServer{
		{Address: netutils.ParseIPSloppy("172.16.2.1"), Port: 8080, Weight: 1},
		{Address: netutils.ParseIPSloppy("172.16.2.2"), Port: 8080, Weight: 2},
		{Address: netutils.ParseIPSloppy("172.16.2.3"), Port: 8080, Weight: 3},
	}

			},
			expectIPs: []net.IP{netutils.ParseIPSloppy("1.2.3.4")},
		},
		{
			name: "IPv4-only, external-first",
			addresses: []v1.NodeAddress{
				{Type: v1.NodeExternalIP, Address: "4.3.2.1"},
				{Type: v1.NodeExternalIP, Address: "4.3.2.2"},
				{Type: v1.NodeInternalIP, Address: "1.2.3.4"},
			},
			expectIPs: []net.IP{netutils.ParseIPSloppy("1.2.3.4")},
		},
		{
			name: "IPv4-only, no internal",

		allocator, err := r.getAllocator(netutils.ParseIPSloppy("10.0.0.11"))
		if err != nil {
			return false, nil
		}
		allocator.ipAddressSynced = func() bool { return true }
		return allocator.ready.Load(), nil
	})
	if err != nil {
		t.Fatal(err)
	}
	// allocate one IP from the new allocator
	err = r.Allocate(netutils.ParseIPSloppy("10.0.0.11"))
	if err != nil {