* but an implemantation that encorporates the transport header(for
     * efficiency) might use a different initial bufferIndex. For example,
     * to eliminate copying data when writing NbtSession data one might
     * manage that 4 byte header specifically and therefore the initial
     * bufferIndex, and thus headerStart, would be 4).(NOTE: If one where
     * looking for a way to improve perfomance this is precisly what you

                        responseData.setResponseBody(outputFile, true);
                        if (logger.isDebugEnabled()) {
                            logger.debug(
                                    "Object size exceeds cache threshold, using temp file: bucket={}, path={}, size={}, threshold={}, tempFile={}",
                                    bucketName, path, blob.getSize(), maxCachedContentSize, outputFile.getAbsolutePath());
                        }

        assertFalse(item.isBadWord(badWords));

        // Test with matching bad word
        String[] badWords2 = { "test", "bad" };
        assertTrue(item.isBadWord(badWords2));

        // Test with partial match
        item.setText("testing something");
        String[] badWords3 = { "test" };
        assertTrue(item.isBadWord(badWords3));
    }

    @Test
    public void testToEmptyMap() {

            verify(transportPool).getChallenge(context, address);
            verify(transportPool).logon(context, address);
        }

        @Test
        @DisplayName("Should manage multiple transport types")
        void testMultipleTransportTypes() throws Exception {
            // Given
            SmbTransport sharedTransport = mock(SmbTransport.class);

        }
        if ("suggest-words".equals(type)) {
            return FormatType.SUGGEST;
        }
        // default
        return FormatType.OTHER;
    }

    @Override
    public boolean matches(final HttpServletRequest request) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        if (!fessConfig.isWebApiJson()) {
            return false;
        }

        assertEquals(2, serverList.size());
        assertEquals("SERVER1", serverList.get(0).oemDomainName);
        assertEquals("SERVER2", serverList.get(1).oemDomainName);
    }

    /**
     * Test field types match expected types
     */
    @Test
    @DisplayName("Test field types are correct")
    public void testFieldTypes() throws NoSuchFieldException {
        // Verify field types

                assertTrue("Child URL should be properly formed", childUrl.contains("dir1/test3.txt"));
                assertTrue("Child URL should contain 'child' not 'chile'", childUrl.matches(".*dir1/test3\\.txt"));
            }
        } finally {
            if (server != null) {
                server.stop();
            }
        }
    }

        trustInfo.name = new rpc.unicode_string(); // Use real object
        trustInfo.name.length = 10;
        trustInfo.name.maximum_length = 20;
        trustInfo.name.buffer = new short[10]; // Should match maximum_length/2
        trustInfo.sid = mock(rpc.sid_t.class);

        trustInfo.encode(mockNdrBuffer);

        verify(mockNdrBuffer).align(4);
        verify(mockNdrBuffer).enc_ndr_short(trustInfo.name.length);

     * Default is Blowfish for backward compatibility.
     */
    protected String algorithm = BLOWFISH;

    /**
     * The transformation to use for the cipher when using Key objects.
     * Default is Blowfish to match the algorithm default.
     * <p>
     * Note: For better security, consider using "AES/GCM/NoPadding" with proper IV handling.
     * </p>
     */
    protected String transformation = BLOWFISH;

    /**

        assertEquals(65024, transactionBufferSize, "Should delegate transaction buffer size");
        assertEquals(16, bufferCacheSize, "Should delegate buffer cache size");
        assertEquals(1024, notifyBufferSize, "Should delegate notify buffer size");

        verify(mockDelegate).getSendBufferSize();
        verify(mockDelegate).getReceiveBufferSize();