this.cacheTemplateName = cacheTemplateName;
    }

    /**
     * Sets the facet cache duration in seconds.
     *
     * @param facetCacheDuration the cache duration in seconds
     */
    public void setFacetCacheDuration(final long facetCacheDuration) {
        this.facetCacheDuration = facetCacheDuration;
    }

    /**

            try {
              proceed.await(5, TimeUnit.SECONDS)
            } catch (e: InterruptedException) {
              throw RuntimeException(e)
            }
            chain.proceed(chain.request())
          },
        ).build()
    val t1 = makeSynchronousCall(client.newCall(newRequest("http://a/3")))
    ready.await(5, TimeUnit.SECONDS)
    executor.finishJob("http://a/2")

                    exception.set(e);
                } finally {
                    latch.countDown();
                }
            });
        }

        latch.await(30, TimeUnit.SECONDS);
        executor.shutdown();

        if (exception.get() != null) {
            throw exception.get();
        }
    }

        }
      },
    )

    // This should fail the Call, but not cause an unhandled Exception bubbling up
    client.dispatcher.executorService.shutdownNow()

    val exception = callFailure.get(5, TimeUnit.SECONDS)
    assertThat(exception.message)
      .isNotNull()
      .startsWith("canceled due to")
    assertThat(exception).isInstanceOf<IOException>()
    assertThat(exception.cause)
      .isNotNull()

const (
	// browserCSPPolicy setting name for Content-Security-Policy response header value
	browserCSPPolicy = "csp_policy"
	// browserHSTSSeconds setting name for Strict-Transport-Security response header, amount of seconds for 'max-age'
	browserHSTSSeconds = "hsts_seconds"
	// browserHSTSIncludeSubdomains setting name for Strict-Transport-Security response header 'includeSubDomains' flag (true or false)

   * is complete. It does so by using daemon threads and adding a shutdown hook to wait for their
   * completion.
   *
   * <p>This method waits 120 seconds before continuing with JVM termination, even if the executor
   * has not finished its work.
   *
   * <p>This is mainly for fixed thread pools. See {@link Executors#newFixedThreadPool(int)}.
   *

    protected int maxRedirectCount;

    /** Executor service for concurrent processing of file operations. */
    private final ExecutorService executor;

    /** Timeout in seconds for executor service termination during shutdown. */
    private int executorTerminationTimeout = 300;

    /**
     * Constructs a new FileListIndexUpdateCallbackImpl with the specified parameters.
     *

    FluentIterable<TimeUnit> unused = FluentIterable.from(TimeUnit.values()).append(SECONDS);
  }

  public void testFromArrayAndIteratorRemove() {
    FluentIterable<TimeUnit> units = FluentIterable.from(TimeUnit.values());
    assertThrows(UnsupportedOperationException.class, () -> removeIf(units, equalTo(SECONDS)));
  }

  public void testFrom() {
    assertEquals(
        ImmutableList.of(1, 2, 3, 4),

    @Keep public static final WithPublicConstants SECOND = new WithPublicConstants();
  }

  private static class FirstConstantIsNull {
    // To test that null constant is ignored
    @Keep public static final @Nullable FirstConstantIsNull FIRST = null;

    @Keep public static final FirstConstantIsNull SECOND = new FirstConstantIsNull();
  }

  public static class NonFinalFieldIgnored {

     *
     * @return the altPath
     */
    public final String getAltPath() {
        return this.altPath;
    }

    /**
     * Gets the time-to-live value for this referral in seconds.
     *
     * @return the ttl
     */
    public final int getTtl() {
        return this.ttl;
    }

    /**
     * Gets the referral path.
     *
     * @return the rpath
     */