// simply make sure the entry exists after connecting
		p1conn1 = makeConn(p, time.Now())
		c1.OnConnect(p1conn1)
		checkEntryOrFail(t, store, wgA, p, n, c1.instanceID)
	})
	t.Run("multinetwork same ip", func(t *testing.T) {
		// make sure we don't overrwrite a similar entry for a different network
		p2conn1 = makeConn(p2, time.Now())
		c2.OnConnect(p2conn1)
		checkEntryOrFail(t, store, wgA, p, n, c1.instanceID)

        when:
        workerProcess.setExecHandle(execHandle)
        workerProcess.startAccepting(acceptor)

        op.start {
            op.callbackLater {
                workerProcess.onConnect(connection)
            }
            workerProcess.start()
        }

        then:
        1 * execHandle.addListener(_)
        1 * execHandle.start()
        1 * acceptor.requestStop()
    }

        try {
            this.acceptor = acceptor;
        } finally {
            lock.unlock();
        }
    }

    public void onConnect(ObjectConnection connection) {
        onConnect(connection, null);
    }

    public void onConnect(ObjectConnection connection, Runnable connectionHandler) {
        AsyncStoppable stoppable;
        lock.lock();
        try {

// in the workloadentry package. It does so by setting
// up a workloadentry controller with a proxy with
// pseudo-random values.
// The fuzzer then uses the controller to test:
// 1: OnConnect
// 2: OnDisconnect
// 3: QueueWorkloadEntryHealth
func FuzzWE(data []byte) int {
	f := fuzz.NewConsumer(data)
	proxy := &model.Proxy{}
	err := f.GenerateStruct(proxy)
	if err != nil {
		return 0
	}

        then:
        2 * javaExecHandleBuilder.getMaxHeapSize() >> "1024m"

        when:
        process.start()

        then:
        1 * execHandle.start() >> process.delegate.onConnect(Stub(ObjectConnection))

        and:
        1 * memoryManager.requestFreeMemory(1024*1024*1024)
    }

        if (!healthResponse.isTimedOut()) {
            onConnectListenerList.forEach(l -> {
                try {
                    l.onConnect();
                } catch (final Exception e) {
                    logger.warn("Failed to invoke " + l, e);
                }
            });

            connected = true;
        } else {

        final DefaultWorkerProcess workerProcess = new DefaultWorkerProcess(connectTimeoutSeconds, TimeUnit.SECONDS, memoryStatus);
        ConnectionAcceptor acceptor = server.accept(connection ->
            workerProcess.onConnect(connection, () -> {
                DefaultWorkerLoggingProtocol defaultWorkerLoggingProtocol = new DefaultWorkerLoggingProtocol(outputEventListener);

            } else if (entry.getValue().length == 1) {
                curlRequest.param(entry.getKey(), entry.getValue()[0]);
            }
        });
        try (final CurlResponse curlResponse = curlRequest.onConnect((req, con) -> {
            con.setDoOutput(true);
            if (httpMethod != Method.GET && request.getContentLength() > 2) {

        if (body != null) {
            throw new CurlException("body method is already called.");
        }
        this.bodyStream = stream;
        return this;
    }

    public CurlRequest onConnect(final BiConsumer<CurlRequest, HttpURLConnection> connectionBuilder) {
        this.connectionBuilder = connectionBuilder;
        return this;
    }

    public CurlRequest param(final String key, final String value) {

	c.Annotations[annotation.IoIstioWorkloadController.Name] = controller
	c.Annotations[annotation.IoIstioConnectedAt.Name] = conTime.Format(timeFormat)
	delete(c.Annotations, annotation.IoIstioDisconnectedAt.Name)
}

// OnConnect determines whether a connecting proxy represents a non-Kubernetes
// workload and, if that's the case, initiates special processing required for that type
// of workloads, such as auto-registration, health status updates, etc.
//