*            the configuration to use for this response
     * @param outputBuffer
     *            the buffer to receive the read data
     * @param outputBufferOffset
     *            the offset in the output buffer to start writing data
     */
    public Smb2ReadResponse(final Configuration config, final byte[] outputBuffer, final int outputBufferOffset) {
        super(config);
        this.outputBuffer = outputBuffer;

            }
            n = response.dataLength;
            if (n <= 0) {
                return (int) (fp - start > 0L ? fp - start : -1);
            }
            fp += n;
            len -= n;
            response.off += n;
        } while (len > 0 && n == r);

        return (int) (fp - start);
    }

    /**
     * This stream class is unbuffered. Therefore this method will always

### Starting and Stopping Containers

To start a stopped container, you can use the [`docker start`](https://docs.docker.com/engine/reference/commandline/start/) command.

```sh
docker start <container_id>
```

To stop a running container, you can use the [`docker stop`](https://docs.docker.com/engine/reference/commandline/stop/) command.

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        this.dialectIndex = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        if (this.dialectIndex > 10) {
            return bufferIndex - start;
        }
        this.server.securityMode = buffer[bufferIndex] & 0xFF;
        bufferIndex++;

                "Nightly Snapshot (from QuickFeedback) - Promote",
                "Publish Branch Snapshot (from Quick Feedback)",
                "Release - Milestone",
                "Start Release Cycle",
                "Start Release Cycle Test",
            ),
            model.buildTypes.map { it.name },
        )
    }

    @Test
    fun `promotion project has expected build types for other branches`() {

}

// MarshalXML - produces the xml representation of the Filter struct
// only one of Prefix, And and Tag should be present in the output.
func (f Filter) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	if err := e.EncodeToken(start); err != nil {
		return err
	}

	switch {
	case !f.And.isEmpty():
		if err := e.EncodeElement(f.And, xml.StartElement{Name: xml.Name{Local: "And"}}); err != nil {
			return err
		}

        return 0;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        dst[dstIndex] = (byte) 0x04;
        dstIndex++;
        dstIndex += writeString(path, dst, dstIndex);

        return dstIndex - start;
    }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

type Prefix struct {
	string
	set    bool
	Unused struct{} // Needed for GOB compatibility
}

// UnmarshalXML - decodes XML data.
func (p *Prefix) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
	var s string
	if err = d.DecodeElement(&s, &start); err != nil {
		return err
	}
	*p = Prefix{string: s, set: true}
	return nil
}

// MarshalXML - decodes XML data.

        dst[dstIndex++] = (byte) 0x00;
        SMBUtil.writeInt4(this.capabilities, dst, dstIndex);
        dstIndex += 4;

        return dstIndex - start;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        if (this.blob != null) {
            System.arraycopy(this.blob, 0, dst, dstIndex, this.blob.length);

      .build()

  private val server =
    MockWebServer()

  @Test
  fun testHttpsRequest() {
    server.useHttps(handshakeCertificates.sslSocketFactory())

    server.enqueue(MockResponse())
    server.start()

    val request = Request.Builder().url(server.url("/")).build()

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
    }