BiMap<V, K> inv = getMap().inverse();
      assertFalse(
          "Inverse should not contain entry " + reversed, inv.entrySet().contains(reversed));
      assertFalse(
          "Inverse should not contain key " + reversed.getKey(),
          inv.containsKey(reversed.getKey()));
      assertFalse(
          "Inverse should not contain value " + reversed.getValue(),
          inv.containsValue(reversed.getValue()));
      /*

        // Store in memory
        sessionKeys.put(sessionId, secretKey);
        rawKeys.put(sessionId, keyClone);

        // Track creation time for rotation (only for non-archived keys)
        if (!sessionId.contains(".v")) {
            keyCreationTimes.put(sessionId, System.currentTimeMillis());
            keyVersions.putIfAbsent(sessionId, 0);
        }

        // Optionally store in KeyStore

            }
        });
    }

    private boolean isSingleWordQuery(final String query) {
        return !Strings.isNullOrEmpty(query) && !query.contains(" ") && !query.contains("　");
    }

    /**
     * Builds the query for suggestions.
     * @param q The query string.
     * @param fields The fields to search in.
     * @return The QueryBuilder instance.
     */

import jcifs.internal.smb2.ServerMessageBlock2Response;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;
import jcifs.smb.NtStatus;

/**
 * SMB2 Read response message.
 *
 * This response contains the data that was read from the file
 * along with information about the read operation.
 *
 * @author mbechler
 */
public class Smb2ReadResponse extends ServerMessageBlock2Response {

    /**

        TestSpnegoToken t = new TestSpnegoToken();
        IOException ex = assertThrows(IOException.class, () -> t.parse(null), "parse should throw IOException on null");
        assertTrue(ex.getMessage().toLowerCase().contains("null"));
    }

    @Test
    @DisplayName("toByteArray returns empty when no mechanismToken")
    void toByteArrayWhenNull() {
        TestSpnegoToken t = new TestSpnegoToken();

        String pkgs = System.getProperty("java.protocol.handler.pkgs");
        if (pkgs == null) {
            System.setProperty("java.protocol.handler.pkgs", "jcifs");
        } else if (!pkgs.contains("jcifs")) {
            System.setProperty("java.protocol.handler.pkgs", pkgs + "|jcifs");
        }
    }

    @BeforeEach
    void setUp() throws Exception {
        parent = mock(SmbFile.class);

      for (Certificate certificate : chain.connection().handshake().peerCertificates()) {
        String pin = CertificatePinner.pin(certificate);
        if (denylist.contains(pin)) {
          throw new IOException("Denylisted peer certificate: " + pin);
        }
      }
      return chain.proceed(chain.request());
    }
  };

        byte[] buf = new byte[12];
        buf[0] = 0x00;
        buf[1] = 0x02; // count = 512 in little-endian
        resp.readParameterWordsWireFormat(buf, 0);
        String str = resp.toString();
        assertTrue(str.contains("count=512"), "toString should include numeric count");
    }

    @Test
    public void testReturnFromReadParameterWordsWireFormatIs8() {
        // ensure the method returns 8 as claimed

                    if (logger.isDebugEnabled()) {
                        logger.debug("Skipping crawl request for url='{}' at depth={} (maxDepth={}, alreadyProcessed={})",
                                crawlRequest.getUrl(), crawlRequest.getDepth(), maxDepth, processedUrls.contains(crawlRequest.getUrl()));
                    }

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

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