// Make sure we block the executor until it has been stopped
            stoppedLatch.await()
        }

        when:
        def executor = factory.createScheduled('<display-name>', 1)
        executor.schedule(action, 0, TimeUnit.SECONDS)
        operation.stop {
            stopLatch.await()
            try {
                executor.stop(50, TimeUnit.MILLISECONDS)
            } finally {

      // SequentialExecutor by the time the barrier is satisfied
      barrier.await(1, TimeUnit.SECONDS);
      executor.execute(barrierTask);
      // timeout means the second task wasn't even tried
      barrier.await(1, TimeUnit.SECONDS);
    } finally {
      service.shutdown();
    }
  }

            import java.util.concurrent.TimeUnit;

            public class Block {
                public static void main(String[] args) throws InterruptedException {
                    new CountDownLatch(1).await(90, TimeUnit.SECONDS);
                }
            }
        """
        buildFile << """
            apply plugin: 'java'
            task block(type: JavaExec) {

          call: Call,
          inetSocketAddress: InetSocketAddress,
          proxy: Proxy,
        ) {
          try {
            // Wait for request2 to guarantee we make 2 separate connections to the server.
            latch1.await()
          } catch (e: InterruptedException) {
            throw AssertionError(e)
          }
        }

        override fun connectionAcquired(

      // SequentialExecutor by the time the barrier is satisfied
      barrier.await(1, TimeUnit.SECONDS);
      executor.execute(barrierTask);
      // timeout means the second task wasn't even tried
      barrier.await(1, TimeUnit.SECONDS);
    } finally {
      service.shutdown();
    }
  }

              }
            })
        .start();

    // wait for the computingEntry to be created
    computationStarted.await();
    cache.invalidateAll();
    // let the computation proceed
    computingLatch.countDown();
    // don't check cache.size() until we know the get("b") call is complete
    computationComplete.await();

                    submitWorkItem("workItem1")
                    submitWorkItem("workItem2")

                    if (${waitForResults}) {
                        workerExecutor.await()
                    }
                }
            }
        """
        blockingHttpServer.expectConcurrent("workItem0", "workItem1", "workItem2")

        expect:
        args("--max-workers=3")

        }

        // Need to wait for work to complete, so release worker lease while waiting
        workerLeases.blocking(() -> {
            lock.lock();
            try {
                // Wait for any work still running in other threads
                while (pendingOperations > 0) {
                    try {
                        operationsComplete.await();
                    } catch (InterruptedException e) {

                        }
                    }
                }
            }
        }
        when:
        latch.await(5, TimeUnit.SECONDS)
        10_000.times {
            defaultSerializerRegistry.build(SerializableParent)
        }
        then:
        noExceptionThrown()
        conditions.await(5.0)
        where:
        // Rerun this test 10 times
        testIteration << (0..9)
    }

                            client.inputStream.skip(client.inputStream.available())
                        }
                        client.shutdownOutput()
                        latch.await() // wait for the end of the test before closing the connection
                        println("Closing client ${client.remoteSocketAddress}")
                    }
                } catch (SocketException e) {