includedDocPathPatterns = pathPatterList.toArray(new Pattern[pathPatterList.size()]);
            } else {
                includedDocPathPatterns = new Pattern[0];
            }
        }

        if (excludedDocPathPatterns == null) {
            if (StringUtil.isNotBlank(getExcludedDocPaths())) {
                final List<Pattern> pathPatterList = new ArrayList<>();

  static final CharSource BROKEN_OPEN_SOURCE = new TestCharSource("ABC", OPEN_THROWS);
  static final CharSink BROKEN_WRITE_SINK = new TestCharSink(WRITE_THROWS);
  static final CharSink BROKEN_CLOSE_SINK = new TestCharSink(CLOSE_THROWS);
  static final CharSink BROKEN_OPEN_SINK = new TestCharSink(OPEN_THROWS);

  private static final ImmutableSet<CharSource> BROKEN_SOURCES =

        when(delegate.hasNext()).thenReturn(true, true, false);
        when(delegate.next()).thenReturn(entry1, entry2);
        when(filter.accept(resource)).thenThrow(new CIFSException("Error")).thenReturn(true);

        TestIterator iterator = new TestIterator(filter);

        // Verify iteration
        assertTrue(iterator.hasNext());
        assertSame(resource, iterator.next());

        // Test with boolean parameter
        Map<String, Object> booleanParams = new HashMap<>();
        booleanParams.put("boolean", true);
        assertNotNull(queryRescorer.evaluate(booleanParams));

        // Test with unknown parameter
        Map<String, Object> unknownParams = new HashMap<>();
        unknownParams.put("unknown", new Object());
        assertNull(queryRescorer.evaluate(unknownParams));
    }

    @Test

    void testGetBatchLimit() {
        testBlock = new TestAndXServerMessageBlock(mockConfig);

        assertEquals(0, testBlock.getBatchLimit(mockConfig, (byte) 0x25));
    }

    @Test
    @DisplayName("Test encode without andx command")
    void testEncodeWithoutAndx() {
        testBlock = new TestAndXServerMessageBlock(mockConfig, (byte) 0x25);
        byte[] buffer = new byte[1024];

    static final DefaultContentsParser parser = new DefaultContentsParser();
    static final String[] supportedFields = new String[] { "content", "title" };
    static final String[] tagFieldNames = new String[] { "label", "virtual_host" };
    static final String roleFieldName = "role";

    @BeforeClass
    public static void beforeClass() throws Exception {
        runner = new OpenSearchRunner();

        .add(new Striped.LargeLazyStriped<ReadWriteLock>(64, ReentrantReadWriteLock::new))
        .add(new Striped.SmallLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(64, ReentrantLock::new))

        .add(new Striped.LargeLazyStriped<ReadWriteLock>(64, ReentrantReadWriteLock::new))
        .add(new Striped.SmallLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(64, ReentrantLock::new))

        return java.util.stream.Stream.of(Arguments.of(0x00000000, new byte[] { 0x00, 0x00, 0x00, 0x00 }),
                Arguments.of(0x12345678, new byte[] { 0x78, 0x56, 0x34, 0x12 }),
                Arguments.of(0xFFFFFFFF, new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }),
                Arguments.of(0x7FFFFFFF, new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0x7F }));
    }

        java.util.Properties props1 = new java.util.Properties();
        props1.load(new StringReader(config));
        new DefaultInterpolator().performSubstitution((Map) props1, null, true);
        assertEquals(expected, props1);

        MavenProperties props2 = new MavenProperties();
        props2.load(new StringReader(config));
        assertEquals(expected, props2);
    }