private final Duration timeout;
    private final Lock lock;

    private ResponseProducer producer = new ResponseProducer() {
        @Override
        public void writeTo(int requestId, HttpExchange exchange) throws IOException {
            responseBody.writeTo(requestId, exchange);
        }
    };
    private ResponseProducer responseBody = new SendFixedContent(200, "hi");
    private BlockingRequest blockingRequest;

  private ReentrantReadWriteLock.ReadLock readLockB;
  private ReentrantReadWriteLock.ReadLock readLockC;
  private ReentrantReadWriteLock.WriteLock writeLockA;
  private ReentrantReadWriteLock.WriteLock writeLockB;
  private ReentrantReadWriteLock.WriteLock writeLockC;
  private ReentrantLock lock1;
  private ReentrantLock lock2;
  private ReentrantLock lock3;
  private ReentrantLock lock01;

  private ReentrantReadWriteLock.ReadLock readLockB;
  private ReentrantReadWriteLock.ReadLock readLockC;
  private ReentrantReadWriteLock.WriteLock writeLockA;
  private ReentrantReadWriteLock.WriteLock writeLockB;
  private ReentrantReadWriteLock.WriteLock writeLockC;
  private ReentrantLock lock1;
  private ReentrantLock lock2;
  private ReentrantLock lock3;
  private ReentrantLock lock01;

			expectedIOStats: IOStats{
				ReadIOs:        1432553,
				ReadMerges:     420084,
				ReadSectors:    66247626,
				ReadTicks:      2398227,
				WriteIOs:       7077314,
				WriteMerges:    8720147,
				WriteSectors:   157049224,
				WriteTicks:     7469810,
				CurrentIOs:     0,
				TotalTicks:     7580552,
				ReqTicks:       9869354,
				DiscardIOs:     46037,

        def output = new TestOutputStream()

        when:
        target.writeTo(output)

        then:
        output.closed
    }

    def "can write multiple times"() {
        given:
        def output = new TestOutputStream()

        when:
        target.writeTo(new ByteArrayOutputStream())
        target.writeTo(output)

        then:
        output.closed
    }

            case GradleDsl.GROOVY:
                new GroovyWriter().writeTo(projectDir.file("settings.gradle"))
                break
            case GradleDsl.KOTLIN:
                new KotlinWriter().writeTo(projectDir.file("settings.gradle.kts"))
                break
        }
    }

    private class GroovyWriter {
        void writeTo(TestFile settingsFile) {
            settingsFile << """

        throw new UnsupportedOperationException();
    }

    @Override
    public ExternalResourceReadResult<Void> writeTo(File destination) throws ResourceException {
        return localFile.writeTo(destination);
    }

    @Override
    @Nullable
    public ExternalResourceReadResult<Void> writeToIfPresent(File destination) throws ResourceException {

    assertOnFileDescriptor(content = "Hello") { fd ->
      val requestBody = fd.toRequestBody()

      val buffer = Buffer()
      requestBody.writeTo(buffer)
      assertThat(buffer.readUtf8()).isEqualTo("Hello")

      assertThrows(IOException::class.java) {
        requestBody.writeTo(Buffer())
      }
    }
  }

  @Test
  fun testFileDescriptorAfterClose() {

  /**
   * Returns the number of bytes that will be written to sink in a call to [writeTo],
   * or -1 if that count is unknown.
   */
  @Throws(IOException::class)
  open fun contentLength(): Long = commonContentLength()

  /** Writes the content of this request to [sink]. */
  @Throws(IOException::class)
  abstract fun writeTo(sink: BufferedSink)

  /**

//
// Entries are sorted by "call edge weight", from highest to lowest.

const serializationHeader = "GO PREPROFILE V1\n"

// WriteTo writes a serialized representation of Profile to w.
//
// FromSerialized can parse the format back to Profile.
//
// WriteTo implements io.WriterTo.Write.
func (d *Profile) WriteTo(w io.Writer) (int64, error) {
	bw := bufio.NewWriter(w)

	var written int64

	// Header