if (methodDesc == null) {
            return null;
        }
        final Object value = methodDesc.invoke(annotation);
        if (value == null || "".equals(value)) {
            return null;
        }
        return value;
    }

    this.element = Preconditions.checkNotNull(element);
  }

  @Override
  public int size() {
    return 1;
  }

  @Override
  public boolean contains(@Nullable Object target) {
    return element.equals(target);
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return singletonIterator(element);
  }

  @Override
  public ImmutableList<E> asList() {
    return ImmutableList.of(element);

import com.google.common.collect.testing.features.CollectionSize;
import com.google.common.testing.EqualsTester;
import org.junit.Ignore;

/**
 * Tests for {@code Multiset.equals} and {@code Multiset.hashCode}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")

   * @param from the source file
   * @param to the destination file
   * @throws IOException if an I/O error occurs
   * @throws IllegalArgumentException if {@code from.equals(to)}
   */
  public static void copy(File from, File to) throws IOException {
    checkArgument(!from.equals(to), "Source %s and destination %s must be different", from, to);
    asByteSource(from).copyTo(asByteSink(to));
  }

  /**

    if (this.certificateChainCleaner == certificateChainCleaner) {
      this
    } else {
      CertificatePinner(pins, certificateChainCleaner)
    }

  override fun equals(other: Any?): Boolean =
    other is CertificatePinner &&
      other.pins == pins &&
      other.certificateChainCleaner == certificateChainCleaner

  override fun hashCode(): Int {
    var result = 37

description="Replace checking element presense in array with a utility function" suppressId="manual_array_contains" problemDescriptor="Replace manual array-contains check with utility function" text="for ($TYPE$ $ITEM$ : $ARR$) {
    if ($ITEM$.equals($TARGET$)) {
       return $RES$;
    }
}" recursive="false" caseInsensitive="false" type="JAVA" pattern_context="default" reformatAccordingToStyle="true" shortenFQN="true" useStaticImport="true" replacement="if (org.gradle.util.inter...

import com.google.common.collect.ForwardingSet;
import java.util.Set;

/**
 * A subclass of `ForwardingSet` that throws `IllegalStateException` on invocation of any method
 * (except `hashCode` and `equals`) if the provided `Supplier` returns false.
 */
final class InvalidatableSet<E> extends ForwardingSet<E> {
  private final Supplier<Boolean> validator;
  private final Set<E> delegate;

    void build(ClassDoc classDoc) {
        ClassMetaData classMetaData = classDoc.getClassMetaData();
        String superClassName = classMetaData.getSuperClassName();
        if (superClassName != null && !superClassName.equals("org.gradle.api.DefaultTask")) {
            // Assume this is a class and so has implemented all properties and methods somewhere in the superclass hierarchy
            ClassDoc superClass = model.getClassDoc(superClassName);

        assertNull(ex.getCause(), "Default ctor should not set a cause");
        assertTrue(ex instanceof SmbException, "Should be an SmbException subtype");
        // SmbException default ctor leaves status 0, which equals NT_STATUS_SUCCESS
        assertEquals(NtStatus.NT_STATUS_SUCCESS, ex.getNtStatus(), "Default status should be success (0)");
    }

                public Type type() {
                    return null;
                }

                @Override
                public Map<String, PluginContainer> plugins() {
                    if ("JAR".equals(id)) {
                        return Map.of(
                                DEFAULT,
                                PluginContainer.newBuilder()
                                        .plugins(List.of(