}

    @Override
    protected Client createClient() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final String[] hosts =
                split(address, ",").get(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).toArray(n -> new String[n]));
        final Builder builder = Settings.builder()
                .putList("http.hosts", hosts)

     * @return a DFS referral or null if not found
     * @throws SmbAuthException if authentication fails
     */
    public DfsReferral getReferral(final SmbTransport trans, final String domain, final String root, final String path,
            final NtlmPasswordAuthentication auth) throws SmbAuthException {
        if (DISABLED) {
            return null;
        }

        try {

    void testConstantNamingConvention() {
        Field[] fields = SecurityInfo.class.getDeclaredFields();

        for (Field field : fields) {
            if (field.getType() == int.class) {
                String name = field.getName();
                // Check that constant names follow UPPER_SNAKE_CASE convention
                assertTrue(name.matches("[A-Z_]+"), "Constant " + name + " should follow UPPER_SNAKE_CASE convention");

        assertFalse(s1.matches(other));
    }

    @Test
    void toStringContainsKeyFields() {
        SmbSession session = new SmbSession(addr, 445, inet, 0, auth);
        String s = session.toString();
        assertTrue(s.contains("accountName="), "toString should contain accountName");
        assertTrue(s.contains("primaryDomain="), "toString should contain primaryDomain");

 */
public class FieldUtilTest {

    /** */
    public Object objectField;

    /** */
    public int intField;

    /** */
    public String stringField;

    /** */
    public static final int INT_DATA = 987654321;

    /** */
    public static final String STRING_DATA = "Hello World!";

    /**
     * @throws Exception
     */
    @Test
    public void testGet() throws Exception {

            fail();
        } catch (IllegalArgumentException e) {
            assertTrue(true);
        }
    }

    @Test
    public void test_setAndGetAsArray() {
        String value1 = "a";
        String value2 = "b";
        String value3 = "c";
        settings.badword().add(value1);
        settings.badword().add(value2);
        settings.badword().add(value3);

    }

    @Test
    public void test_setAndGetAsInt() {
        String key = "key";
        int value = 1;
        settings.set(key, value);
        assertEquals(value, settings.getAsInt(key, -1));
    }

    @Test
    public void test_setAndGetAsLong() {
        String key = "key";
        long value = Long.MAX_VALUE;
        settings.set(key, value);

                    Arrays.spliterator(new String[] {"a", "b", "c", "d", "e"}), Ascii::toUpperCase))
        .expect("A", "B", "C", "D", "E");
  }

  public void testFlatMap() {
    SpliteratorTester.of(
            () ->
                CollectSpliterators.flatMap(
                    Arrays.spliterator(new String[] {"abc", "", "de", "f", "g", ""}),
                    (String str) -> charactersOf(str).spliterator(),

        try {
            robotsTxt = robotsTxtHelper.parse(in);
        } finally {
            CloseableUtil.closeQuietly(in);
        }

        for (String userAgent : new String[] { "FessCrawler", "FessCrawler/1.0", "Mozilla FessCrawler" }) {
            assertTrue(robotsTxt.allows("/aaa", userAgent));
            assertTrue(robotsTxt.allows("/private/", userAgent));

  @Benchmark
  int weakInterner(int reps) {
    Interner<String> interner = Interners.newWeakInterner();
    for (int i = 0; i < reps; i++) {
      String unused = interner.intern(Double.toHexString(Math.random()));
    }
    return reps;
  }

  @CanIgnoreReturnValue
  @Benchmark
  int strongInterner(int reps) {
    Interner<String> interner = Interners.newStrongInterner();
    for (int i = 0; i < reps; i++) {