final FessFileTransformer transformer = createInstance();

        url = null;
        exp = "";
        assertEquals(exp, transformer.getHostOnFile(url));

        url = "example:";
        exp = "unknown";
        assertEquals(exp, transformer.getHostOnFile(url));

        url = "file:";
        exp = "localhost";
        assertEquals(exp, transformer.getHostOnFile(url));

        url = "file://";

      val responseBody = response.body!!
      val contentLength = responseBody.contentLength()
      val bodySize = if (contentLength != -1L) "$contentLength-byte" else "unknown-length"
      logger.log(
        buildString {
          append("<-- ${response.code}")
          if (response.message.isNotEmpty()) append(" ${response.message}")

                log.warn("Tree handle was not properly released, performing emergency cleanup: "
                        + (this.resourceLoc != null ? this.resourceLoc.getURL() : "unknown"));
                emergencyReleaseHandle();
            }
        } catch (Exception e) {
            log.error("Error during tree handle finalization", e);
        } finally {
            super.finalize();

            assertTrue(ex.getMessage().contains("disposed"));
        }

        @Test
        @DisplayName("Supported/preferred mech edge cases (null, empty, unknown)")
        void testMechanismEdges() {
            DummySSPContext empty = new DummySSPContext(new byte[] { 1 }, false, "", new ASN1ObjectIdentifier[0], 0, false);

            }
            throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                    "Unknown q: " + query.getClass() + " => " + query);
        };
    }

    /**
     * Interface for query processing filters.
     * Filters can modify, validate, or enhance queries before they are executed.
     */

 *     <li><code>rc</code> or <code>cr</code></li>
 *     <li><code>snapshot</code></li>
 *     <li><code>ga</code> or <code>final</code></li>
 *     <li><code>sp</code></li>
 *     </ol>
 *     Unknown qualifiers are considered after known qualifiers,
 *     with lexical order (case-insensitive in the English locale).
 *     <code>ga</code> and <code>final</code> sort the same as not having a qualifier.
 *   </li>

            for (final String line : lines) {
                if (StringUtil.isNotBlank(line)) {
                    final int pos = line.indexOf('=');
                    if (pos == 0) {
                        paramMap.put("unknown." + (unknownKey + 1), line.substring(pos + 1).trim());
                        unknownKey++;
                    } else if (pos > 0) {
                        final String key = line.substring(0, pos).trim();

        }

        @Test
        @DisplayName("Should throw exception for unknown dialect")
        void testConstructorUnknownDialect() {
            IllegalArgumentException exception =
                    assertThrows(IllegalArgumentException.class, () -> new Smb2SigningDigest(sessionKey, 0x9999, null));
            assertEquals("Unknown dialect", exception.getMessage());
        }

        @ParameterizedTest

                        logger.debug("No thumbnail: {} -> {}", thumbnailId, responseData.getUrl());
                    }
                    break;
                default:
                    logger.error("Unknown thumbnail result: {} -> {}", thumbnailId, responseData.getUrl());
                    break;
                }
            } catch (final Throwable t) {

                return message.contains("retry") || message.contains("temporary") || message.contains("timeout")
                        || message.contains("connection");
            }
            return false; // Unknown IO errors are likely not recoverable
        }

        // Runtime exceptions and other errors are likely not recoverable
        return false;
    }

    /**