}

        @Test
        @DisplayName("Should handle masked value round-trip correctly")
        void testMaskedValueRoundTrip() throws NdrException {
            // Given: Original value that gets masked
            int originalValue = 300; // Will be masked to 44
            int maskedValue = originalValue & 0xFF; // 44
            NdrShort ndrShort1 = new NdrShort(originalValue);

    val b1 = source.readByte() and 0xff

    val isMasked = b1 and B1_FLAG_MASK != 0
    if (isMasked == isClient) {
      // Masked payloads must be read on the server. Unmasked payloads must be read on the client.
      throw ProtocolException(
        if (isClient) {
          "Server-sent frames must not be masked."
        } else {
          "Client-sent frames must be masked."
        },
      )
    }

        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test", "*.*", searchAttributes, 10, 1024);

        // Verify attributes are masked with 0x37
        int expectedAttributes = searchAttributes & 0x37;

        // Write parameters to verify the masked value is used
        byte[] buffer = new byte[100];
        int written = trans2FindFirst2.writeParametersWireFormat(buffer, 0);

        .isEqualTo("Client-sent frames must be masked.")
    }
  }

  @Test fun serverSentFramesMustNotBeMasked() {
    data.write("8180".decodeHex())
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Server-sent frames must not be masked.")
    }
  }

  @Test fun controlFramePayloadMax() {

        }

        // Log command template with masked password for security
        if (logger.isDebugEnabled()) {
            final String commandStr = stream(commands).get(stream -> stream.map(s -> {
                if ("$PASSWORD".equals(s)) {
                    return "***MASKED***";
                }
                if ("$USERNAME".equals(s)) {
                    return username;

            // Mask sensitive keys
            if (key.contains("password") || key.contains("secret") || key.contains("token") || key.contains("credential")) {
                masked.put(entry.getKey(), "****");
            } else if (value instanceof String) {
                masked.put(entry.getKey(), maskSensitiveData((String) value));
            } else {
                masked.put(entry.getKey(), value);
            }

    client.webSocket!!.close(1000, "Hello")
    server.processNextFrame()
    // Not closed until close reply is received.
    assertThat(client.closed).isFalse()

    // Manually write an invalid masked close frame.
    server.sink.write("888760b420bb635c68de0cd84f".decodeHex()).emit()
    client.processNextFrame() // Detects error, disconnects immediately since close already sent.
    client.webSocket!!.finishReader()

   * observed contention rates are typically low in these cases.
   *
   * It is possible for a Cell to become unused when threads that
   * once hashed to it terminate, as well as in the case where
   * doubling the table causes no thread to hash to it under
   * expanded mask.  We do not try to detect or remove such cells,
   * under the assumption that for long-running instances, observed

        assertEquals(expectedType, info.getType());
    }

    @Test
    @DisplayName("Test getType with hidden flag")
    void testGetTypeWithHiddenFlag() {
        // Hidden flag (0x80000000) should be masked out
        int hiddenPrinterType = 0x80000001; // Hidden printer
        SmbShareInfo info = new SmbShareInfo(TEST_NET_NAME, hiddenPrinterType, TEST_REMARK);
        assertEquals(SmbConstants.TYPE_PRINTER, info.getType());

   * observed contention rates are typically low in these cases.
   *
   * It is possible for a Cell to become unused when threads that
   * once hashed to it terminate, as well as in the case where
   * doubling the table causes no thread to hash to it under
   * expanded mask.  We do not try to detect or remove such cells,
   * under the assumption that for long-running instances, observed