Assertions.assertTrue(condition, message);
    }

    // assertTrue - JUnit 5 style (message last)
    protected void assertTrue(boolean condition, String message) {
        Assertions.assertTrue(condition, message);
    }

    // assertFalse - JUnit 4 style (message first)
    protected void assertFalse(String message, boolean condition) {

  }

  // We are implementing Condition, so our callers are responsible for the loop.
  @SuppressWarnings("WaitNotInLoop")
  private static class TestCondition implements Condition {
    private final Lock lock;
    private final Condition condition;

    private TestCondition(Lock lock, Condition condition) {
      this.lock = lock;
      this.condition = condition;
    }

  @IgnoreJRERequirement // Users will use this only if they're already using Duration.
  public static boolean awaitUninterruptibly(Condition condition, Duration timeout) {
    return awaitUninterruptibly(condition, toNanosSaturated(timeout), NANOSECONDS);
  }

  /**
   * Invokes {@code condition.}{@link Condition#await(long, TimeUnit) await(timeout, unit)} in a way
   * that more conveniently supports uninterruptible waits.
   *

  }

  // We are implementing Condition, so our callers are responsible for the loop.
  @SuppressWarnings("WaitNotInLoop")
  private static class TestCondition implements Condition {
    private final Lock lock;
    private final Condition condition;

    private TestCondition(Lock lock, Condition condition) {
      this.lock = lock;
      this.condition = condition;
    }

            public OptionalEntity<Map<String, Object>> getDocument(final String index,
                    final SearchCondition<SearchRequestBuilder> condition) {
                final SearchRequestBuilder builder = new SearchRequestBuilder(this, SearchAction.INSTANCE);
                condition.build(builder);
                resultMap.put("index", index);
                resultMap.put("query", builder.toString());

 * evaluation and signaling of conditions. Signaling is entirely <a
 * href="http://en.wikipedia.org/wiki/Monitor_(synchronization)#Implicit_signaling">implicit</a>. By
 * eliminating explicit signaling, this class can guarantee that only one thread is awakened when a
 * condition becomes true (no "signaling storms" due to use of {@link
 * java.util.concurrent.locks.Condition#signalAll Condition.signalAll}) and that no signals are lost

    @Test
    public void test_addCondition() {
        // Test adding conditions
        generator = new TestThumbnailGenerator();

        // Test adding single condition
        generator.addCondition("field1", "value1");

        // Test adding multiple conditions for same field
        generator.addCondition("field1", "value2");

        // Test adding conditions for different fields
        generator.addCondition("field2", "pattern.*");

	<property name="mydbflute.url" value="https://github.com/lastaflute/lastaflute-example-waterfront/archive/${branch.name}.zip" />

	<target name="mydbflute.check">
		<condition property="mydbflute.exists">
			<available file="${mydbflute.dir}" type="dir" />
		</condition>
	</target>

	<target name="download.dbflute" depends="mydbflute.check" unless="mydbflute.exists">
		<mkdir dir="${mydbflute.dir}" />

	CINC	NV, R2, R3                                       // ERROR "invalid condition"
	CINVW	AL, R2, R3                                       // ERROR "invalid condition"
	CINV	NV, R2, R3                                       // ERROR "invalid condition"
	CNEG	AL, R2, R3                                       // ERROR "invalid condition"

     *
     * @param index     the index name
     * @param condition the search condition
     * @return an optional containing the document if found
     */
    public OptionalEntity<Map<String, Object>> getDocument(final String index, final SearchCondition<SearchRequestBuilder> condition) {
        return getDocument(index, condition, (response, hit) -> {