} catch (final Exception e) {
                // ignore
            }
        }
        final Integer id = fessConfig.getAvailableSmbSidType(type);
        if (id != null) {
            return createSearchRole(id, sid.getAccountName());
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Ignored SID: {} {}", type, sid);
        }
        return null;
    }

                      try {
                        shutDown();
                      } catch (Exception ignored) {
                        restoreInterruptIfIsInterruptedException(ignored);
                        t.addSuppressed(ignored);
                      }
                      notifyFailed(t);
                      return;
                    }
                  }

 * ignored by {@link #visit}. This avoids infinite recursion caused by recursive type bounds.
 *
 * <p>This class is not thread safe.
 *
 * @author Ben Yu
 */
abstract class TypeVisitor {

  private final Set<Type> visited = new HashSet<>();

  /**
   * Visits the given types. Null types are ignored. This allows subclasses to call {@code

public enum IteratorFeature {
  /** Support for {@link Iterator#remove()}. */
  SUPPORTS_REMOVE,
  /**
   * Support for {@link ListIterator#add(Object)}; ignored for plain {@link Iterator}
   * implementations.
   */
  SUPPORTS_ADD,
  /**
   * Support for {@link ListIterator#set(Object)}; ignored for plain {@link Iterator}
   * implementations.
   */
  SUPPORTS_SET;

  /**

    "deviation ".encodeUtf8(),
    // 1.
    "disallowed ".encodeUtf8(),
    // 2.
    "disallowed_STD3_mapped ".encodeUtf8(),
    // 3.
    "disallowed_STD3_valid ".encodeUtf8(),
    // 4.
    "ignored ".encodeUtf8(),
    // 5.
    "mapped ".encodeUtf8(),
    // 6.
    "valid ".encodeUtf8(),
  )

internal const val TYPE_DEVIATION = 0
internal const val TYPE_DISALLOWED = 1

    }

    // instance method ignored
    public Object badIgnored() {
      return new BadEquals();
    }

    // primitive ignored
    public int returnsInt() {
      throw new UnsupportedOperationException();
    }

    // void ignored
    public void voidMethod() {
      throw new UnsupportedOperationException();
    }

    // non-public method ignored
    static Object badButNotPublic() {

                      try {
                        shutDown();
                      } catch (Exception ignored) {
                        restoreInterruptIfIsInterruptedException(ignored);
                        t.addSuppressed(ignored);
                      }
                      notifyFailed(t);
                      return;
                    }
                  }

    inputFuture.cancel(true); // argument is ignored
    assertThrows(CancellationException.class, () -> resultFuture.get());
  }

  public void testFutureGetThrowsCancellationIfOutputCancelled() throws Exception {
    inputFuture.set(SLOW_OUTPUT_VALID_INPUT_DATA);
    outputFuture.cancel(true); // argument is ignored
    assertThrows(CancellationException.class, () -> resultFuture.get());
  }

    inputFuture.cancel(true); // argument is ignored
    assertThrows(CancellationException.class, () -> resultFuture.get());
  }

  public void testFutureGetThrowsCancellationIfOutputCancelled() throws Exception {
    inputFuture.set(SLOW_OUTPUT_VALID_INPUT_DATA);
    outputFuture.cancel(true); // argument is ignored
    assertThrows(CancellationException.class, () -> resultFuture.get());
  }

        // that. If any of the BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS ended in "'GMT'" we'd have
        // to also check that position.getIndex() == value.length() otherwise parsing might have
        // terminated early, ignoring things like "+01:00". Leaving this as != 0 means that any
        // trailing junk is ignored.
        return result
      }
    }
  }