Name:     ptr.To(fmt.Sprintf("%d", epPort)),
			Port:     ptr.To(int32(epPort)),
			Protocol: ptr.To(v1.ProtocolTCP),
		}},
	}

	for j := 0; j < nEndpoints; j++ {
		ipEp := netutils.AddIPOffset(baseEp, j)
		eps.Endpoints = append(eps.Endpoints, discovery.Endpoint{
			Addresses: []string{ipEp.String()},
		})
	}

	if epsFunc != nil {
		epsFunc(eps)
	}

	// generate a base service object

	}
	// update metrics
	r.metrics.incrementAllocations(label.String(), "dynamic")
	r.metrics.setAllocated(label.String(), r.Used())
	r.metrics.setAvailable(label.String(), r.Free())

	return netutils.AddIPOffset(r.base, offset), nil
}

// Release releases the IP back to the pool. Releasing an
// unallocated IP or an IP out of the range is a no-op and
// returns no error.
func (r *Range) Release(ip net.IP) error {

}

func (dry dryRunAllocator) EnableMetrics() {
}

// addOffsetAddress returns the address at the provided offset within the subnet
// TODO: move it to k8s.io/utils/net, this is the same as current AddIPOffset()
// but using netip.Addr instead of net.IP
func addOffsetAddress(address netip.Addr, offset uint64) (netip.Addr, error) {
	addressBytes := address.AsSlice()
	addressBig := big.NewInt(0).SetBytes(addressBytes)

				t.Helper()
				if u := r.Used(); u != expect {
					t.Errorf("unexpected used count: got %d, wanted %d", u, expect)
				}
			}
			expectUsed(t, r, baseUsed)

			err = r.DryRun().Allocate(netutils.AddIPOffset(netutils.BigForIP(cidr.IP), 1))
			if err != nil {
				t.Fatalf("unexpected failure: %v", err)
			}
			expectUsed(t, r, baseUsed)

			_, err = r.DryRun().AllocateNext()
			if err != nil {