when:
        handler.reservePort()
        handler.start(10, {})
        handler.start(11, {})
        handler.start(12, {})

        then:
        2 * factory.create(_ as String) >> Mock(ManagedExecutor)
    }

    def "cannot start contention handling when the handler was stopped"() {
        handler.stop()

        when:
        handler.start(10, {})

        then:

	}
	return false
}

// NewServer starts and returns a new [Server].
// The caller should call Close when finished, to shut it down.
func NewServer(handler http.Handler) *Server {
	ts := NewUnstartedServer(handler)
	ts.Start()
	return ts
}

// NewUnstartedServer returns a new [Server] but doesn't start it.
//
// After changing its configuration, the caller should call Start or
// StartTLS.
//

		pos++
	}
	return p.output[start:pos]
}

func (p *printer) commentTextAt(start int) string {
	if start < len(p.output) && p.output[start] == tabwriter.Escape {
		start++
	}
	pos := start
	for pos < len(p.output) && p.output[pos] != tabwriter.Escape && !isNL(p.output[pos]) {
		pos++
	}
	return string(p.output[start:pos])
}

func isNL(b byte) bool {
	return b == '\n' || b == '\f'

        this.file = file;
        bufferedInputStream = new ResettableBufferedInputStream(new RandomAccessFileInputStream(file));
    }

    /**
     * Starts reading from the given offset.
     */
    public DataInputStream start(long offset) throws IOException {
        file.seek(offset);
        bufferedInputStream.clear();
        countingInputStream = new CountingInputStream(bufferedInputStream);

 * <p>
 * A server connector should only be used by one daemon, and has a single use lifecycle.
 * Implementations must be threadsafe so that start/stop can be called from different threads.
 */
public interface DaemonServerConnector extends Stoppable {

    /**
     * Starts accepting connections, passing any established connections to the given handler.
     * <p>

	traceEvGoCreateBlocked // goroutine creation (starts blocked) [timestamp, new goroutine ID, new stack ID, stack ID]

	// GoStatus with stack.
	traceEvGoStatusStack // goroutine status at the start of a generation, with a stack [timestamp, goroutine ID, M ID, status, stack ID]

	// Batch event for an experimental batch with a custom format.

				Failed:          fstats.toMetric(),
				FailStats:       fstats,
				ReplicatedSize:  stat.ReplicatedSize + oldst.ReplicatedSize,
				ReplicatedCount: stat.ReplicatedCount + oldst.ReplicatedCount,
				Latency:         stat.Latency.merge(oldst.Latency),
				XferRateLrg:     &lrg,
				XferRateSml:     &sml,
			}
			totReplicatedSize += stat.ReplicatedSize
			totReplicatedCount += stat.ReplicatedCount

func (b *pallocBits) summarize() pallocSum {
	var start, most, cur uint
	const notSetYet = ^uint(0) // sentinel for start value
	start = notSetYet
	for i := 0; i < len(b); i++ {
		x := b[i]
		if x == 0 {
			cur += 64
			continue
		}
		t := uint(sys.TrailingZeros64(x))
		l := uint(sys.LeadingZeros64(x))

		// Finish any region spanning the uint64s
		cur += t
		if start == notSetYet {
			start = cur
		}

go build -x -pgo=prof -o triv.exe triv.go
stderr 'preprofile.*-i.*prof'
stderr 'compile.*-pgoprofile=.*triv.go'

# check that PGO appears in build info
# N.B. we can't start the stdout check with -pgo because the script assumes that
# if the first arg starts with - it is a grep flag.
go version -m triv.exe
stdout 'build\s+-pgo=.*'${/}'prof'

# store the build ID
go list -export -json=BuildID -pgo=prof triv.go

	activeConnectionsURL := fmt.Sprintf("http://%s/stats?usedonly&filter=downstream_cx_active$", adminHost)
	stats, err := http.DoHTTPGetWithTimeout(activeConnectionsURL, 2*time.Second)
	if err != nil {
		return -1, fmt.Errorf("unable to get listener stats from Envoy : %v", err)
	}
	if stats.Len() == 0 {
		return -1, nil
	}
	activeConnections := 0
	for stats.Len() > 0 {
		line, _ := stats.ReadString('\n')