// When
        Cipher encryptCipher = Crypto.getArcfour(key);
        encryptCipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "RC4"));
        byte[] encrypted = encryptCipher.doFinal(plaintext);

        Cipher decryptCipher = Crypto.getArcfour(key);
        decryptCipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "RC4"));
        byte[] decrypted = decryptCipher.doFinal(encrypted);

     * This method is called automatically by the dependency injection framework
     * and loads the initial related query configurations.
     */
    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initializing {}", this.getClass().getSimpleName());
        }
        load();
    }

    /**

    void testWriteParametersWireFormatNetServerEnum2() throws Exception {
        String domain = "TESTDOMAIN";
        int serverTypes = NetServerEnum2.SV_TYPE_ALL;
        netServerEnum2 = new NetServerEnum2(realConfig, domain, serverTypes);

        byte[] dst = new byte[1024];
        int dstIndex = 0;

        int bytesWritten = netServerEnum2.writeParametersWireFormat(dst, dstIndex);

        // Verify bytes written

                // endpointGroup = new RdmaActiveEndpointGroup<DisniRdmaEndpoint>(
                //     1000, false, 128, 4, 128);
                // endpointGroup.init(new DisniRdmaEndpointFactory());

                // For now, we'll just create placeholder objects
                endpointGroup = new Object();
                endpoint = new Object();

        assertEquals(0, msg.getFlags(), "Initial flags should be 0");
    }

    @ParameterizedTest(name = "setFlags({0}) ➜ getFlags() == {0}")
    @ValueSource(ints = { 0x0, 0x1, 0x2, 0xFFFFFFFF, -123456 })
    void testSetAndGetFlags(int value) {
        msg.setFlags(value);
        assertEquals(value, msg.getFlags(), "getFlags should return the value set");
    }

    @Test

    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 4, 8, 16 })
    @DisplayName("Test verify method with different extra padding values")
    void testVerifyWithDifferentExtraPadding(int extraPad) {
        // Arrange
        int offset = 0;
        int length = testData.length;

        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 2, 3, 5, 6, 100, 255, 65535 })
        @DisplayName("Should throw exception for various invalid structure sizes")
        void testReadBytesWireFormatVariousInvalidSizes(int invalidSize) {
            // Given
            byte[] buffer = new byte[10];
            int bufferIndex = 0;
            SMBUtil.writeInt2(invalidSize, buffer, bufferIndex);

        int written = trans2QueryPathInfo.writeParametersWireFormat(buffer, 0);

        // Should handle Unicode characters
        assertTrue(written > 6);

        // Check information level
        int actualInfoLevel = SMBUtil.readInt2(buffer, 0);
        assertEquals(0x0101, actualInfoLevel);
    }

    @ParameterizedTest
    @ValueSource(ints = { -1, 0, 100, 255, Integer.MAX_VALUE })

        assertDoesNotThrow(() -> networkExplorer.init(servletConfig));
    }

    /**
     * Test servlet initialization with custom JCIFS parameters
     */
    @Test
    void testInit_WithJcifsParameters() throws ServletException {
        // Reset mocks for this test
        reset(servletConfig, servletContext);

        // Setup init parameters
        Vector<String> paramNames = new Vector<>();

    @ParameterizedTest
    @DisplayName("Test search attributes masking")
    @ValueSource(ints = { 0x00, 0x16, 0x37, 0xFF })
    void testSearchAttributesMasking(int searchAttributes) {
        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test", "*.*", searchAttributes, 10, 1024);

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