ChannelInfo channel = new ChannelInfo("test-channel", mockTransport, localInterface, remoteInterface);

        IOException error = new IOException("Test error");

        // Should not throw exception
        assertDoesNotThrow(() -> channelManager.handleChannelFailure(channel, error));
    }

    @Test
    void testEstablishReplacementChannel() {

     * @param response the HTTP response
     * @throws IOException if an I/O error occurs
     */
    protected void sendBlockedResponse(final HttpServletResponse response) throws IOException {
        response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().write("{\"error\":\"ip_blocked\",\"message\":\"Access denied.\"}");
    }

    /**

        // Arrange & Act: create exception with error code
        SmbAuthException ex = new SmbAuthException(errCode);

        // Assert: type, message derived from code, status mapping, and no cause
        assertNotNull(ex);
        assertTrue(ex instanceof SmbException);
        assertEquals(SmbException.getMessageByCode(errCode), ex.getMessage(), "message should reflect error code mapping");

// MonitoredReader represents a throttled reader subject to bandwidth monitoring
type MonitoredReader struct {
	r        io.Reader
	throttle *bucketThrottle
	ctx      context.Context // request context
	lastErr  error           // last error reported, if this non-nil all reads will fail.
	m        *Monitor
	opts     *MonitorReaderOptions
}

// BucketOptions represents the bucket and optionally its replication target pair.

	mu sync.Mutex
}

func (pr *syncReadCloser) Read(p []byte) (n int, err error) {
	// This ensures that Close will block until Read has completed.
	// This allows another goroutine to close the reader.
	pr.mu.Lock()
	defer pr.mu.Unlock()
	if pr.rc == nil {
		return 0, io.EOF
	}
	return pr.rc.Read(p)
}

func (pr *syncReadCloser) Close() error {
	pr.mu.Lock()
	defer pr.mu.Unlock()
	if pr.rc != nil {

        // Test initial state
        assertTrue(response.hasMoreElements());

        // Test after setting error code (not status)
        response.setTestErrorCode(1); // Non-zero errorCode indicates error
        assertFalse(response.hasMoreElements());

        // Reset error and test hasMore flag
        response.setTestErrorCode(0);
        response.hasMore = false;

     *
     * @param input the input stream to read from
     * @param locationBuilder optional builder for creating input location objects
     * @return the parsed XML node
     * @throws XMLStreamException if there is an error parsing the XML
     */
    protected abstract XmlNode doRead(InputStream input, InputLocationBuilder locationBuilder)
            throws XMLStreamException;

    /**

		}
		if errorResponse.Resource != testCase.errorResponse.Resource {
			t.Errorf("Test %d: %s: Expected the error resource to be `%s`, but instead found `%s`", i+1, instanceType, testCase.errorResponse.Resource, errorResponse.Resource)
		}
		if errorResponse.Message != testCase.errorResponse.Message {
			t.Errorf("Test %d: %s: Expected the error message to be `%s`, but instead found `%s`", i+1, instanceType, testCase.errorResponse.Message, errorResponse.Message)

		Free:      1000,
		Used:      1000,
		FSType:    "xfs",
		RootDisk:  true,
		Healing:   true,
		Endpoint:  "http://localhost:9001/tmp/drive1",
		MountPath: "/tmp/drive1",
		ID:        "uuid",
		Error:     "",
	}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.Log("Size:", buf.Len(), "bytes")
	b.SetBytes(1)
	b.ReportAllocs()

     * @param serverChallenge the server challenge bytes
     * @param clientChallenge the client challenge bytes
     * @return the calculated response
     * @throws GeneralSecurityException if a cryptographic error occurs
     */
    public static byte[] getNTLM2Response(final byte[] passwordHash, final byte[] serverChallenge, final byte[] clientChallenge)
            throws GeneralSecurityException {