for (Field field : HttpHeaders.class.getDeclaredFields()) {
      /*
       * Coverage mode generates synthetic fields.  If we ever add private
       * fields, they will cause similar problems, and we may want to switch
       * this check to isAccessible().
       */
      if (!field.isSynthetic() && field.getType() == String.class) {
        builder.add(field);
      }
    }
    return builder.build();

      e is FileNotFoundException
  }

  private fun isRecoverable(
    e: IOException,
    requestSendStarted: Boolean,
  ): Boolean {
    // If there was a protocol problem, don't recover.
    if (e is ProtocolException) {
      return false
    }

    // If there was an interruption don't recover, but if there was a timeout connecting to a route

        });
        try (InputStream inputStream = form.kuromojiFile.getInputStream()) {
            file.update(inputStream);
        } catch (final IOException e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsFailedToUploadProtwordsFile(GLOBAL));
        }
        return asJson(new ApiResult.ApiResponse().status(ApiResult.Status.OK).result());
    }

        });
        try (InputStream inputStream = form.protwordsFile.getInputStream()) {
            file.update(inputStream);
        } catch (final IOException e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsFailedToUploadProtwordsFile(GLOBAL));
        }
        return asJson(new ApiResult.ApiResponse().status(ApiResult.Status.OK).result());
    }

    `@Deprecated` APIs will remain (again, unless they are `@Beta`). We have no
    plans to start removing things again, but officially, we're leaving our
    options open in case of surprises (like, say, a serious security problem).

3.  Guava has one dependency that is needed for linkage at runtime:
    `com.google.guava:failureaccess:1.0.3`. It also has
    [some annotation-only dependencies][guava-deps], which we discuss in more

public class AbstractListTester<E extends @Nullable Object> extends AbstractCollectionTester<E> {
  /*
   * Previously we had a field named list that was initialized to the value of
   * collection in setUp(), but that caused problems when a tester changed the
   * value of list or collection but not both.
   */
  protected final List<E> getList() {
    return (List<E>) collection;
  }

  /**
   * {@inheritDoc}
   *

        }
        Type[] resolvedBounds = new TypeResolver(forDependants).resolveTypes(bounds);
        /*
         * We'd like to simply create our own TypeVariable with the newly resolved bounds. There's
         * just one problem: We want to interoperate properly with the platform's built-in
         * implementation of TypeVariable, but the behavior of the built-in implementation differs
         * across platforms:
         *

    protected FessConfig fessConfig;

    /** Data serializer for converting objects to binary format */
    protected DataSerializer dataSerializer;

    /** Flag indicating whether to process Google on/off comments */
    protected boolean useGoogleOffOn = true;

    /** Map storing field pruning rules */
    protected Map<String, Boolean> fieldPrunedRuleMap = new HashMap<>();

  /**
   * An {@code AnnotatedType} instance, or {@code null} under Android VMs (possible only when using
   * the Android flavor of Guava). The field is declared with a type of {@code Object} to avoid
   * compatibility problems on Android VMs. The corresponding accessor method, however, can have the
   * more specific return type as long as users are careful to guard calls to it with version checks

    /**
     * Add an url pattern as a non-target.
     *
     * @param urlPattern Regular expression that is not crawled
     */
    void addExclude(String urlPattern);

    /**
     * Process an url when it's added as a seed url.
     *
     * @param url URL
     */
    void processUrl(String url);

    /**
     * Clear this filter.
     */
    void clear();