private val socksProxy = SocksProxy()

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
    socksProxy.play()
  }

  @AfterEach
  fun tearDown() {
    socksProxy.shutdown()
  }

  @Test
  fun proxy() {
    server.enqueue(MockResponse.Builder().body("abc").build())
    server.enqueue(MockResponse.Builder().body("def").build())
    val client =

                renderNow();
                return;
            }

            if (newEvent instanceof EndOutputEvent) {
                // Flush and clean up
                renderNow();
                executor.shutdown();
            }

            // Else, wait for the next update event
        }
    }

    private void renderNow() {
        // Remove event only as it is handled, and leave unhandled events in the queue

        this.provider = provider
        this.webapp = new WebAppContext()
        // The following code is because of a problem under Windows: the file descriptors are kept open under JDK 11
        // even after server shutdown, which prevents from deleting the test directory
        this.webapp.setInitParameter("org.eclipse.jetty.servlet.Default.useFileMappedBuffer", "false")
    }

    TestFile getCacheDir() {

                Map.Entry<ClassPath, Cleanup> entry = cleanups.entrySet().iterator().next();
                removeCacheEntry(entry.getKey(), entry.getValue(), CLOSE_CLASSLOADER);
            }
            LOG.debug("Completed shutdown");
        } finally {
            lock.unlock();
        }
    }

    public void putCleanup(ClassPath key, Cleanup cleanup) {
        cleanups.put(key, cleanup);
    }

		},
	})

	return c
}

func (c *crdRegistrationController) Run(workers int, stopCh <-chan struct{}) {
	defer utilruntime.HandleCrash()
	// make sure the work queue is shutdown which will trigger workers to end
	defer c.queue.ShutDown()

	klog.Infof("Starting crd-autoregister controller")
	defer klog.Infof("Shutting down crd-autoregister controller")

	// wait for your secondary caches to fill before starting your work

        inputFile.text = "changed"
        pending.waitForAllPendingCalls()
        pending.releaseAll()
        and:
        // command the gate keeper to open the gate and shutdown
        command.releaseAll()
        server.expect(server.get("command").send("stop"))
        then:
        // waits for build to start and finish
        buildTriggeredAndSucceeded()

        executorServiceTypeOnCurrentJvm() | Executor         | "java.util.concurrent.Executors.newSingleThreadExecutor().tap { shutdown() }"
        ByteArrayInputStream              | InputStream      | "new java.io.ByteArrayInputStream([] as byte[])"
        ByteArrayOutputStream             | OutputStream     | "new java.io.ByteArrayOutputStream()"

		// including shutting down its storage layer.
		cancel(errors.New("tearing down"))

		// If the apiextensions apiserver was started, let's wait for
		// it to shutdown clearly.
		if errCh != nil {
			err, ok := <-errCh
			if ok && err != nil {
				klog.Errorf("Failed to shutdown test server clearly: %v", err)
			}
		}

		if len(result.TmpDir) != 0 {
			os.RemoveAll(result.TmpDir)
		}
	}
	defer func() {

		return false
	}
}

func TestSendPushesManyPushes(t *testing.T) {
	stopCh := make(chan struct{})
	defer close(stopCh)

	semaphore := make(chan struct{}, 2)
	queue := NewPushQueue()
	defer queue.ShutDown()

	proxies := createProxies(5)

	pushes := make(map[string]int)
	pushesMu := &sync.Mutex{}

	for _, proxy := range proxies {
		proxy := proxy
		// Start receive thread
		go func() {
			for {

	}
	c := NewController(opts.Client, options)
	meshServiceController.AddRegistry(c)

	if opts.ServiceHandler != nil {
		c.AppendServiceHandler(opts.ServiceHandler)
	}

	t.Cleanup(func() {
		c.client.Shutdown()
	})
	if !opts.SkipRun {
		t.Cleanup(func() {
			assert.NoError(t, queue.WaitForClose(c.queue, time.Second*5))
		})
	}
	c.stop = stop
	if cleanupStop {
		t.Cleanup(func() {
			close(stop)