try {
            queryProcessor.execute(context, termQuery, 1.0f);
            fail();
        } catch (InvalidQueryException e) {
            // expected
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }

    @Test
    public void test_convertPrefixQuery_withDefaultField() throws Exception {
        QueryContext context = new QueryContext("test", false);

    )
  }

  /** A request body that fires events when it completes. */
  private inner class RequestBodySink(
    delegate: Sink,
    /** The exact number of bytes to be written, or -1L if that is unknown. */
    private val contentLength: Long,
    private val isSocket: Boolean,
  ) : ForwardingSink(delegate) {
    private var completed = false
    private var bytesReceived = 0L

						rate_limit: '<la:message key="labels.chat_error_rate_limit" />',
						auth_error: '<la:message key="labels.chat_error_auth" />',
						service_unavailable: '<la:message key="labels.chat_error_service_unavailable" />',
						unknown: '<la:message key="labels.chat_error" />'
					}
				}
			});
		});
	</script>
</body>

        try {
            booleanQueryCommand.execute(context, termQuery, 1.0f);
            fail("Should throw InvalidQueryException");
        } catch (InvalidQueryException e) {
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }

    // Test convertBooleanQuery with MUST clause
    @Test
    public void test_convertBooleanQuery_withMustClause() {

    }

    @DisplayName("Should parse different share types correctly")
    @ParameterizedTest
    @CsvSource({ "1, 1", // DISK
            "2, 2", // PIPE
            "3, 3", // PRINT
            "0, 0", // Unknown
            "255, -1" // Byte overflow to signed
    })
    void testDifferentShareTypes(int shareTypeValue, int expectedValue) throws SMBProtocolDecodingException {
        // Given

                || url.startsWith("gcs:");
    }

    /**
     * Checks if the given path has a known protocol prefix that should not be converted.
     * Used to determine if path conversion is needed in the wizard.
     *
     * @param path the path to check
     * @return true if the path has a known protocol prefix
     */
    public boolean hasKnownProtocol(final String path) {

     */
    public static String getHashAlgorithmName(int algorithm) {
        switch (algorithm) {
        case HASH_ALGO_SHA512:
            return "SHA-512";
        default:
            return "Unknown(0x" + Integer.toHexString(algorithm) + ")";
        }
    }

    /**
     * Clears all session contexts (for cleanup).
     */
    public void cleanup() {

        assertTrue(queryCommand.isSearchField("filetype"));

        // Test invalid search fields
        assertFalse(queryCommand.isSearchField("invalid"));
        assertFalse(queryCommand.isSearchField("unknown"));
        assertFalse(queryCommand.isSearchField(""));
    }

    /**
     * Test isSearchField() with null field.
     */
    @Test
    public void test_isSearchField_withNull() {

   *
   * This returns null if:
   *
   *  * The stream is exhausted.
   *  * We've read all of the bytes of an object whose length is known.
   *  * We've reached the [DerHeader.TAG_END_OF_CONTENTS] of an object whose length is unknown.
   */
  fun peekHeader(): DerHeader? {
    var result = peekedHeader

    if (result == null) {
      result = readHeader()
      peekedHeader = result
    }

    assertThat(closed.get()).isTrue()
  }

  @Test
  fun unicodeTextWithUnsupportedEncoding() {
    val text = "eile oli oliiviõli"
    val body = text.toResponseBody("text/plain; charset=unknown".toMediaType())
    assertThat(body.string()).isEqualTo(text)
  }

  companion object {
    @JvmOverloads
    fun body(
      hex: String,
      charset: String? = null,
    ): ResponseBody {