}

    @Test
    @DisplayName("Test Response interface methods - isError")
    void testIsError() {
        // Given
        when(response.isError()).thenReturn(false);

        // When
        boolean isError = response.isError();

        // Then
        assertFalse(isError);
        verify(response).isError();
    }

    @Test
    @DisplayName("Test Response interface methods - error")

        statusField.setAccessible(true);
        statusField.set(response, NtStatus.NT_STATUS_BUFFER_OVERFLOW);

        // When
        boolean isError = response.isErrorResponseStatus();

        // Then
        assertFalse(isError); // Buffer overflow is not considered an error
    }

    @Test
    @DisplayName("Should check if error response for other error status")

        // Test initial state (should be false by default for a fresh mock)
        assertFalse(mockResponse.isError());

        // Simulate error status
        when(mockResponse.isError()).thenReturn(true);
        assertTrue(mockResponse.isError());

        // Verify the method was called
        verify(mockResponse, times(2)).isError();
    }

    @Test
    void testError() {
        // Call the method

     */
    boolean isVerifyFailed();

    /**
     * Checks if the response indicates an error.
     *
     * @return whether the response is an error
     */
    boolean isError();

    /**
     * Set error status
     */
    void error();

    /**
     * Gets the expiration time for this response.
     *
     * @return the message timeout
     */

        this.why = why;
    }

    public String getError() {
        return error;
    }

    public void setError(String error) {
        this.error = error;
    }

    public boolean isError() {
        return error == null;
    }

    public String getDependencyConflictId() {
        return groupId + ":" + artifactId;
    }

            return true;
        }

        @Override
        public boolean isVerifyFailed() {
            return false;
        }

        @Override
        public boolean isError() {
            return errorCode != 0;
        }

        @Override
        public void error() {
            this.errorCode = -1;
        }

        @Override

            return this.errorCode;
        }

        @Override
        public boolean isVerifyFailed() {
            return this.verifyFailed;
        }

        @Override
        public boolean isError() {
            return this.error;
        }

        @Override
        public void error() {
            this.error = true;
        }

        // Setter methods for testing

            assertFalse(echoResponse.isError());

            echoResponse.error();

            assertTrue(echoResponse.isError());
        }

        @Test
        @DisplayName("Should handle exception")
        void testException() {
            Exception testException = new Exception("Test exception");

            assertFalse(echoResponse.isError());
            assertFalse(echoResponse.isReceived());

	}
	xhttp.DrainBody(resp.Body)
	return !resp.IsError(), nil
}

func (c *esClientV7) entryExists(ctx context.Context, index string, key string) (bool, error) {
	res, err := c.Exists(
		index,
		key,
		c.Exists.WithContext(ctx),
	)
	if err != nil {
		return false, err
	}
	xhttp.DrainBody(res.Body)
	return !res.IsError(), nil
}

        void testException() {
            Exception testException = new Exception("Test exception");

            response.exception(testException);

            assertTrue(response.isError());
            assertTrue(response.isReceived());
            assertSame(testException, response.getException());
        }

        @Test
        @DisplayName("Should handle error")