rules[pattern] = NewTargetIDSet(targetID).Union(rules[pattern])
}

// MatchSimple - returns true one of the matching object name in rules.
func (rules Rules) MatchSimple(objectName string) bool {
	for pattern := range rules {
		if wildcard.MatchSimple(pattern, objectName) {
			return true
		}
	}
	return false
}

// Match - returns TargetIDSet matching object name in rules.

     *
     * @return true if running in embedded mode, false otherwise
     */
    public boolean isEmbedded() {
        return runner != null;
    }

    /**
     * Enables the use of ingest pipelines for document processing.
     */
    public void usePipeline() {
        usePipeline = true;
    }

    /**
     * Resolves a hostname to an InetAddress.

        /**
         * Checks if directory change monitoring is currently active
         * @return true if watching is active
         */
        public boolean isActive() {
            return active;
        }

        /**
         * Set active status
         *
         * @param active true to activate
         */
        public void setActive(boolean active) {
            this.active = active;

        @DisplayName("isResponseAsync should return true when asyncId is not 0")
        void testIsResponseAsyncTrue() {
            testRequest.setAsyncId(12345L);
            assertTrue(testRequest.isResponseAsync());
        }

        @ParameterizedTest
        @ValueSource(longs = { 1L, 100L, Long.MAX_VALUE })
        @DisplayName("isResponseAsync should return true for various non-zero asyncIds")

    public void testInitWithException() {
        // Test initialization with exception
        TestReadingConverterWithException errorConverter = new TestReadingConverterWithException();
        errorConverter.setThrowExceptionOnInit(true);

        try {
            errorConverter.init();
            fail("Should throw IOException");
        } catch (IOException e) {
            assertEquals("Init failed", e.getMessage());
        }
    }

        docBoostMatcher.setMatchExpression("true");
        assertFalse(docBoostMatcher.match(null));
    }

    @Test
    public void test_match_emptyMap() {
        final DocBoostMatcher docBoostMatcher = new DocBoostMatcher();
        docBoostMatcher.setMatchExpression("true");
        assertFalse(docBoostMatcher.match(new HashMap<>()));
    }

    @Test

@Timeout(30)
class CallKotlinTest {
  @JvmField @RegisterExtension
  val platform = PlatformRule()

  @JvmField @RegisterExtension
  val clientTestRule =
    OkHttpClientTestRule().apply {
      recordFrames = true
      recordSslDebug = true
    }

  private var client = clientTestRule.newClient()
  private val handshakeCertificates = platform.localhostHandshakeCertificates()

  @StartStop
  private val server = MockWebServer()

 * MutableGraph<String> graph = GraphBuilder.undirected().allowsSelfLoops(true).build();
 * graph.putEdge("bread", "bread");
 * graph.putEdge("chocolate", "peanut butter");
 * graph.putEdge("peanut butter", "jelly");
 *
 * // Building an immutable graph
 * ImmutableGraph<String> immutableGraph =
 *     GraphBuilder.undirected()
 *         .allowsSelfLoops(true)
 *         .<String>immutable()
 *         .putEdge("bread", "bread")

  public void testOffer_supportedNotPresent() {
    assertTrue("offer(notPresent) should return true", getQueue().offer(e3()));
    expectAdded(e3());
  }

  @CollectionFeature.Require({SUPPORTS_ADD, ALLOWS_NULL_VALUES})
  public void testOffer_nullSupported() {
    assertTrue("offer(null) should return true", getQueue().offer(null));
    expectAdded((E) null);
  }

        uses: actions/setup-python@v6
        with:
          python-version-file: ".python-version"
      - name: Setup uv
        uses: astral-sh/setup-uv@v7
        with:
          enable-cache: true
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
      - name: Install GitHub Actions dependencies
        run: uv sync --locked --no-dev --group github-actions