}
		// Allocate until full.
		var cidrs []*net.IPNet
		for {
			cidr, err := set.AllocateNext()
			if err != nil {
				if err == cidrset.ErrCIDRRangeNoCIDRsRemaining {
					break
				}
				t.Errorf("set.AllocateNext() = %v, want %v", err, cidrset.ErrCIDRRangeNoCIDRsRemaining)
				continue TestCase
			}
			cidrs = append(cidrs, cidr)
		}
		// No allocated CIDR range should intersect with serviceCIDR.

	cidrSet := &CidrSet{
		clusterCIDR:     clusterCIDR,
		nodeMask:        net.CIDRMask(subNetMaskSize, bits),
		clusterMaskSize: clusterMaskSize,
		maxCIDRs:        maxCIDRs,
		nodeMaskSize:    subNetMaskSize,
		label:           clusterCIDR.String(),
	}
	cidrSetMaxCidrs.WithLabelValues(cidrSet.label).Set(float64(maxCIDRs))

	return cidrSet, nil
}

	// create a cidrSet for each cidr we operate on
	// cidrSet are mapped to clusterCIDR by index
	cidrSets := make([]*cidrset.CidrSet, len(allocatorParams.ClusterCIDRs))
	for idx, cidr := range allocatorParams.ClusterCIDRs {
		cidrSet, err := cidrset.NewCIDRSet(cidr, allocatorParams.NodeCIDRMaskSizes[idx])
		if err != nil {
			return nil, err
		}
		cidrSets[idx] = cidrSet
	}

	ra := &rangeAllocator{

import (
	"context"
	"fmt"
	"net"
	"reflect"
	"testing"
	"time"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/klog/v2"
	"k8s.io/klog/v2/ktesting"
	"k8s.io/kubernetes/pkg/controller/nodeipam/ipam/cidrset"
	"k8s.io/kubernetes/pkg/controller/nodeipam/ipam/test"
	netutils "k8s.io/utils/net"

	v1 "k8s.io/api/core/v1"
)

var (
	_, clusterCIDRRange, _ = netutils.ParseCIDRSloppy("10.1.0.0/16")
)

}

func TestCidrSetMetricsDual(t *testing.T) {
	// create IPv4 cidrSet
	cidrIPv4 := "10.0.0.0/16"
	_, clusterCIDRv4, _ := netutils.ParseCIDRSloppy(cidrIPv4)
	clearMetrics(map[string]string{"clusterCIDR": cidrIPv4})

	a, err := NewCIDRSet(clusterCIDRv4, 24)
	if err != nil {
		t.Fatalf("unexpected error creating CidrSet: %v", err)
	}

	clusterMaskSize, _ := clusterCIDRv4.Mask.Size()

		outCIDRs[idx] = inCIDR.String()
	}
	return outCIDRs
}

// occupyServiceCIDR removes the service CIDR range from the cluster CIDR if it
// intersects.
func occupyServiceCIDR(set *cidrset.CidrSet, clusterCIDR, serviceCIDR *net.IPNet) error {
	if clusterCIDR.Contains(serviceCIDR.IP) || serviceCIDR.Contains(clusterCIDR.IP) {
		if err := set.Occupy(serviceCIDR); err != nil {
			return err
		}
	}
	return nil

	kubeAPI    kubeAPI
	mode       NodeSyncMode
	nodeName   string
	opChan     chan syncOp
	set        *cidrset.CidrSet
}

// New returns a new syncer for a given node.
func New(c controller, cloudAlias cloudAlias, kubeAPI kubeAPI, mode NodeSyncMode, nodeName string, set *cidrset.CidrSet) *NodeSync {
	return &NodeSync{
		c:          c,
		cloudAlias: cloudAlias,
		kubeAPI:    kubeAPI,
		mode:       mode,

      - k8s.io/kubernetes/pkg/controller/nodeipam
      - k8s.io/kubernetes/pkg/controller/nodeipam/config
      - k8s.io/kubernetes/pkg/controller/nodeipam/ipam
      - k8s.io/kubernetes/pkg/controller/nodeipam/ipam/cidrset
      - k8s.io/kubernetes/pkg/controller/nodeipam/ipam/sync
      - k8s.io/kubernetes/pkg/controller/nodeipam/ipam/test
      - k8s.io/kubernetes/pkg/controller/testutil
      - k8s.io/kubernetes/pkg/controller/util/node

	if err != nil {
		t.Fatalf("unexpected error creating CidrSet: %v", err)
	}
	a.EnableMetrics()
	// create IPv6 allocator
	cidrIPv6 := "2001:db8::/112"
	_, clusterCIDRv6, _ := netutils.ParseCIDRSloppy(cidrIPv6)
	b, err := NewInMemory(clusterCIDRv6)
	b.EnableMetrics()
	if err != nil {
		t.Fatalf("unexpected error creating CidrSet: %v", err)
	}

	// Check initial state
	em := testMetrics{

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package cidrset

import (
	"sync"

	"k8s.io/component-base/metrics"
	"k8s.io/component-base/metrics/legacyregistry"
)

const nodeIpamSubsystem = "node_ipam_controller"

var (