IsNarrowerThan(mask BitMask) bool
	IsLessThan(mask BitMask) bool
	IsGreaterThan(mask BitMask) bool
	String() string
	Count() int
	GetBits() []int
}

type bitMask uint64

// NewEmptyBitMask creates a new, empty BitMask
func NewEmptyBitMask() BitMask {
	s := bitMask(0)
	return &s
}

// NewBitMask creates a new BitMask
func NewBitMask(bits ...int) (BitMask, error) {
	s := bitMask(0)
	err := (&s).Add(bits...)

		NUMADistances: distances,
	}

	return numaInfo, nil
}

func (n *NUMAInfo) Narrowest(m1 bitmask.BitMask, m2 bitmask.BitMask) bitmask.BitMask {
	if m1.IsNarrowerThan(m2) {
		return m1
	}
	return m2
}

func (n *NUMAInfo) Closest(m1 bitmask.BitMask, m2 bitmask.BitMask) bitmask.BitMask {
	// If the length of both bitmasks aren't the same, choose the one that is narrowest.
	if m1.Count() != m2.Count() {

			t.Errorf("Expected result to equal %g, not %g", tcase.expectedAvg, result)
		}
	}

}

func TestClosest(t *testing.T) {
	tcases := []struct {
		description string
		current     bitmask.BitMask
		candidate   bitmask.BitMask
		expected    string
		numaInfo    *NUMAInfo
	}{
		{
			description: "current and candidate length is not the same, current narrower",
			current:     NewTestBitMask(0),

			masks:   [][]int{{0, 1, 2, 3}, {1, 2, 3}, {2, 3}, {3}},
			andMask: "1000",
		},
	}
	for _, tc := range tcases {
		var bitMasks []BitMask
		for i := range tc.masks {
			bitMask, _ := NewBitMask(tc.masks[i]...)
			bitMasks = append(bitMasks, bitMask)
		}
		resultMask := And(bitMasks[0], bitMasks...)
		if resultMask.String() != string(tc.andMask) {
			t.Errorf("Expected mask to be %v, got %v", tc.andMask, resultMask)
		}

			topo:            topoDualSocketHT,
			stAssignments:   state.ContainerCPUAssignments{},
			stDefaultCPUSet: cpuset.New(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
			numRequested:    2,
			socketMask: func() bitmask.BitMask {
				mask, _ := bitmask.NewBitMask(1)
				return mask
			}(),
			expCSet: cpuset.New(1, 7),
		},
		{
			description:     "Request 8 CPUs, BitMask on Socket 0",

// And atomically performs a bitwise AND operation on x using the bitmask
// provided as mask and returns the old value.
func (x *Int32) And(mask int32) (old int32) { return AndInt32(&x.v, mask) }

// Or atomically performs a bitwise OR operation on x using the bitmask
// provided as mask and returns the old value.
func (x *Int32) Or(mask int32) (old int32) { return OrInt32(&x.v, mask) }

// AndInt32 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask
// and returns the old value.
// Consider using the more ergonomic and less error-prone [Int32.And] instead.
func AndInt32(addr *int32, mask int32) (old int32)

// AndUint32 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask
// and returns the old value.

	cpuSetAcrossSocket, _ := cpuset.Parse("0-28,40-57")

	m0001, _ := bitmask.NewBitMask(0)
	m0011, _ := bitmask.NewBitMask(0, 1)
	m0101, _ := bitmask.NewBitMask(0, 2)
	m1001, _ := bitmask.NewBitMask(0, 3)
	m0111, _ := bitmask.NewBitMask(0, 1, 2)
	m1011, _ := bitmask.NewBitMask(0, 1, 3)
	m1101, _ := bitmask.NewBitMask(0, 2, 3)
	m1111, _ := bitmask.NewBitMask(0, 1, 2, 3)

	testCases := []struct {
		description   string

// are preferred.
func mergePermutation(defaultAffinity bitmask.BitMask, permutation []TopologyHint) TopologyHint {
	// Get the NUMANodeAffinity from each hint in the permutation and see if any
	// of them encode unpreferred allocations.
	preferred := true
	var numaAffinities []bitmask.BitMask
	for _, hint := range permutation {
		// Only consider hints that have an actual NUMANodeAffinity set.

		}
	}

	return false
}

func isNUMAAffinitiesEqual(numaAffinity1, numaAffinity2 []int) bool {
	bitMask1, err := bitmask.NewBitMask(numaAffinity1...)
	if err != nil {
		klog.ErrorS(err, "failed to create bit mask", "numaAffinity1", numaAffinity1)
		return false
	}

	bitMask2, err := bitmask.NewBitMask(numaAffinity2...)
	if err != nil {
		klog.ErrorS(err, "failed to create bit mask", "numaAffinity2", numaAffinity2)