return Whitespace.INSTANCE;
  }

  /**
   * Determines whether a character is a breaking whitespace (that is, a whitespace which can be
   * interpreted as a break between words for formatting purposes). See {@link #whitespace()} for a
   * discussion of that term.
   *
   * @since 19.0 (since 2.0 as constant {@code BREAKING_WHITESPACE})
   */
  public static CharMatcher breakingWhitespace() {

        assertEquals("User is not found: ユーザー名", exception.getMessage());
        assertNull(exception.getCause());
    }

    @Test
    public void test_instanceOfFessSystemException() {
        // Test that FessUserNotFoundException is an instance of FessSystemException
        FessUserNotFoundException exception = new FessUserNotFoundException("testuser");

        assertTrue(exception instanceof FessSystemException);

        assertNotNull(exception);
        assertNull(exception.getMessage());
        assertNull(exception.getCause());
    }

    @Test
    public void test_instanceOf() {
        // Test that exception is instance of RuntimeException
        DictionaryExpiredException exception = new DictionaryExpiredException();
        assertTrue(exception instanceof RuntimeException);
        assertTrue(exception instanceof Exception);

        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Qualifier that = (Qualifier) o;
            return number == that.number && level == that.level;
        }

        @Override
        public int hashCode() {
            return Objects.hash(level, number);
        }
    }

    }

    /**
     * Verify that root causes are stored and returned correctly.
     */
    @Test
    @DisplayName("Root cause propagation")
    void testRootCausePropagation() {
        Throwable root = mock(Throwable.class);
        SmbException ex = new SmbException(0, root);
        assertSame(root, ex.getRootCause());
    }

    /**

      }
    }
  }

  /** Tests that if specify '%' as safe the result is an idempotent escaper. */
  public void testCustomEscaper_withpercent() {
    UnicodeEscaper e = new PercentEscaper("%", false);
    assertThat(e.escape("foo|bar")).isEqualTo("foo%7Cbar");
    assertThat(e.escape("foo%7Cbar")).isEqualTo("foo%7Cbar"); // idempotent
  }

    id("gradlebuild.module-jar")
    id("gradlebuild.repositories")
    id("gradlebuild.reproducible-archives")
    id("gradlebuild.private-javadoc")
}

description = "A plugin that sets up a Java code that is shared between build-logic and runtime"

java {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

testing {
    suites {

 * {@link #enqueue} and {@link #dispatch} are 2 different methods. It is expected that the decision
 * to run a particular event is made during the state change, but the decision to actually invoke
 * the listeners can be delayed slightly so that locks can be dropped. Also, because {@link
 * #dispatch} is expected to be called concurrently, it is idempotent.
 */
@J2ktIncompatible

   * Creates an index {@code ImmutableListMultimap} that contains the results of applying a
   * specified function to each item in an {@code Iterable} of values. Each value will be stored as
   * a value in the resulting multimap, yielding a multimap with the same size as the input
   * iterable. The key used to store that value in the multimap will be the result of calling the

   * Creates an index {@code ImmutableListMultimap} that contains the results of applying a
   * specified function to each item in an {@code Iterable} of values. Each value will be stored as
   * a value in the resulting multimap, yielding a multimap with the same size as the input
   * iterable. The key used to store that value in the multimap will be the result of calling the