John Howard <******@****.***> 1607394502 -0800

            range.allocate()
        }

        then:
        10 * portDetector.isAvailable(_) >> { true }

        and:
        range.allocate() == -1
    }

    def "ports are allocated in sequence" () {
        when:
        def port1 = range.allocate()
        def port2 = range.allocate()
        def port3 = range.allocate()

        then:
        port2 == next(port1)
        port3 == next(port2)

	// Allocate an item in the storage
	if _, err := storage.Allocate(2); err != nil {
		t.Fatal(err)
	}

	// Release the item in the local bitmap
	// emulating it's out of sync with the storage
	err := backing.Release(2)
	if err != nil {
		t.Fatal(err)
	}

	// It should fail trying to allocate it deespite it's free
	// in the local bitmap because it's not in the storage
	ok, err := storage.Allocate(2)

		t.Fatalf("unexpected error: %v", err)
	}

	// Allocate a port inside the valid port range
	if err := storage.Allocate(30100); err != nil {
		t.Fatal(err)
	}

	// Try to allocate the same port in the local bitmap
	// The local bitmap stores the offset of the port
	// offset = port - base (30100 - 30000 = 100)
	ok, err := backing.Allocate(100)
	if err != nil {
		t.Fatal(err)
	}

		return nil
	}

	return errors
}

// Allocates a port, and record it for future rollback
func (op *PortAllocationOperation) Allocate(port int) error {
	if op.dryRun {
		if op.pa.Has(port) {
			return ErrAllocated
		}
		for _, a := range op.allocated {
			if port == a {
				return ErrAllocated
			}
		}
		op.allocated = append(op.allocated, port)
		return nil
	}

	dynamicOffset := 16
	// just to double check off by one errors
	allocated := 0
	m := NewAllocationMapWithOffset(max, "test", dynamicOffset)
	// Allocate all possible values except the reserved
	for i := dynamicOffset; i < max; i++ {
		if ok, _ := m.Allocate(i); !ok {
			t.Errorf("error allocate i %v", i)
		} else {
			allocated++
		}
	}
	// Allocate all the values of the reserved block except one

		if !storage.Has(netutils.ParseIPSloppy(ip)) {
			t.Errorf("IP %s expected to be allocated", ip)
		}
	}

	// allocate all addresses on the static block
	for i := 0; i < dynamicOffset; i++ {
		ip := fmt.Sprintf("192.168.1.%d", i+1)
		if err := storage.Allocate(netutils.ParseIPSloppy(ip)); err != nil {
			t.Errorf("Unexpected error trying to allocate IP %s: %v", ip, err)
		}
	}
	if _, err := storage.AllocateNext(); err == nil {

	if err := r.Release(released); err != nil {
		t.Fatal(err)
	}

	err = r.Allocate(1)
	if _, ok := err.(*ErrNotInRange); !ok {
		t.Fatal(err)
	}

	if err := r.Allocate(10001); err != ErrAllocated {
		t.Fatal(err)
	}

	err = r.Allocate(20000)
	if _, ok := err.(*ErrNotInRange); !ok {
		t.Fatal(err)
	}

	err = r.Allocate(10201)
	if _, ok := err.(*ErrNotInRange); !ok {
		t.Fatal(err)
	}

	target := &Allocator{}

	for i := 0; i < iterations; i++ {
		bytesToAllocate := rand.Intn(maxBytes)
		buff := target.Allocate(uint64(bytesToAllocate))
		if cap(buff) < bytesToAllocate {
			t.Fatalf("expected the buffer to allocate: %v bytes whereas it allocated: %v bytes", bytesToAllocate, cap(buff))
		}
		if len(buff) != bytesToAllocate {

	if err != nil {
		t.Errorf("expected no error but got: %v", err)
	}

	// Try to allocate the returned port using the same operation
	if e, a := ErrAllocated, op.Allocate(port); e != a {
		t.Errorf("expected %v but got: %v", e, a)
	}

	// AllocateNext with a previously used dry run operation
	op = StartOperation(r, true)
	_ = op.Allocate(12345)
	port, err = op.AllocateNext()
	if port == 0 {