if (closeable == null) {
            return;
        }
        try {
            closeable.close();
        } catch (final IOException e) {
            logger.log(format("ECL0017", e.getMessage()), e);
        }
    }

    /**
     * Closes a {@link Closeable} quietly, suppressing any {@link IOException}.
     *
     * @param closeable the closeable object
     */

        IOException thrown = assertThrows(IOException.class, () -> {
            packet.readTrailerWireFormat(mockInputStream, buffer, 0);
        });
        assertTrue(thrown.getMessage().contains("unexpected EOF reading netbios retarget session response"));
    }

        return exception;
    }

    public ModelProblemCollectorRequest setException(Exception exception) {
        this.exception = exception;
        return this;
    }

    public String getMessage() {
        return message;
    }

    public ModelProblemCollectorRequest setMessage(String message) {
        this.message = message;
        return this;
    }

    public InputLocation getLocation() {

        try {
            queryCommand.execute(context, termQuery, 1.0f);
            fail("Should throw InvalidQueryException for non-phrase query");
        } catch (InvalidQueryException e) {
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }

    @Test
    public void test_convertPhraseQuery_emptyTerms() {
        // Test with empty phrase query - should throw InvalidQueryException

            long actualInterval = (Long) field.get(dataIndexHelper);
            assertEquals(interval, actualInterval);
        } catch (Exception e) {
            fail("Failed to verify crawlingExecutionInterval: " + e.getMessage());
        }
    }

    @Test
    public void test_setCrawlerPriority() {
        int priority = Thread.NORM_PRIORITY; // Use normal priority for tests
        dataIndexHelper.setCrawlerPriority(priority);

            fail("Should throw exception for non-existent property");
        } catch (ConfigPropertyNotFoundException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("non.existent.property"));
        }
    }

    // Test system property without prefix
    @Test
    public void test_get_systemPropertyWithoutPrefix() {

        // Execute and verify
        CIFSException thrown = assertThrows(CIFSException.class, () -> {
            watchHandle.watch();
        });

        assertEquals("Watch operation failed", thrown.getMessage());
        verify(watchHandle, times(1)).watch();
    }

    /**
     * Test call() method delegates to watch()
     */
    @Test
    void testCall() throws CIFSException {

                    "1 problem was encountered while building the effective toolchains" + LS
                            + "[FATAL] Non-parseable toolchains (memory): MESSAGE @ line 4, column 2" + LS,
                    e.getMessage());
        }
    }

    @Test
    void testIOException() throws Exception {
        Source src = mock(Source.class);
        IOException ioException = new IOException("MESSAGE");

        try {
            deferred.promise().getResponse(5, TimeUnit.SECONDS);
            fail();
        } catch (SuggesterException e) {
            assertEquals("An error occurred during the deferred computation.", e.getMessage());
        }
    }

    // ============================================================
    // Edge case tests for timeout handling
    // ============================================================

            if (logger.isDebugEnabled()) {
                logger.debug(e.getMessage(), e);
            }
            throwValidationErrorApi(e.getMessageCode());
        } catch (final ResultOffsetExceededException e) {
            if (logger.isDebugEnabled()) {
                logger.debug(e.getMessage(), e);
            }