if _, ok := tree.GetPrefix(ipnet2); ok {
		t.Errorf("CIDR %s not expected", ipnet2)
	}

	// check insert existing prefix updates the value
	ok = tree.InsertPrefix(ipnet2, 2)
	if ok {
		t.Errorf("should not exist: %s", ipnet2)
	}

	ok = tree.InsertPrefix(ipnet2, 3)
	if !ok {
		t.Errorf("should be updated: %s", ipnet2)
	}

	if v, ok := tree.GetPrefix(ipnet2); !ok || v != 3 {

	}

	if n != nil && n.public && n.prefix == prefix {
		return n.prefix, n.val, true
	}
	return netip.Prefix{}, zeroT, false
}

// InsertPrefix is used to add a new entry or update
// an existing entry. Returns true if updated.
func (t *Tree[T]) InsertPrefix(prefix netip.Prefix, v T) bool {
	n := t.rootV4
	if prefix.Addr().Is6() {
		n = t.rootV6
	}
	var parent *node[T]

		return nil, ErrMismatchedNetwork
	}
	return allocator, nil
}

func (c *MetaAllocator) addAllocator(cidr netip.Prefix, allocator *Allocator) {
	c.muTree.Lock()
	defer c.muTree.Unlock()
	c.tree.InsertPrefix(cidr, allocator)
}

func (c *MetaAllocator) deleteAllocator(cidr netip.Prefix) {
	c.muTree.Lock()
	defer c.muTree.Unlock()
	ok := c.tree.DeletePrefix(cidr)
	if ok {

				// if the prefix already exist append the new ServiceCIDR name
				v, ok := tree.GetPrefix(prefix)
				if !ok {
					v = sets.Set[string]{}
				}
				v.Insert(serviceCIDR.Name)
				tree.InsertPrefix(prefix, v)
			}
		}
	}

	c.muTree.Lock()
	defer c.muTree.Unlock()
	c.tree = tree
	return nil
}

func (c *Controller) sync(ctx context.Context, key string) error {

	for _, serviceCIDR := range serviceCIDRList {
		for _, cidr := range serviceCIDR.Spec.CIDRs {
			if prefix, err := netip.ParsePrefix(cidr); err == nil { // it can not fail since is already validated
				tree.InsertPrefix(prefix, serviceCIDR.Name)
			}
		}
	}
	r.muTree.Lock()
	defer r.muTree.Unlock()
	r.tree = tree
	return nil
}

func newIPAddress(name string, svc *v1.Service) *networkingv1alpha1.IPAddress {