public void setCookieDomain(final String cookieDomain) {
        this.cookieDomain = cookieDomain;
    }

    /**
     * Sets the maximum age of the user identification cookie in seconds.
     *
     * @param cookieMaxAge the maximum age in seconds
     */
    public void setCookieMaxAge(final int cookieMaxAge) {
        this.cookieMaxAge = cookieMaxAge;
    }

    /**

    // causing the thread to be suspended for 3.5 seconds, and then park itself for 2 seconds after
    // being resumed. To avoid a flake in this scenario, calculate how long that thread actually
    // waited and assert based on that time. Empirically, the race where the thread ends up waiting
    // for 5.5 seconds happens about 2% of the time.

import static java.util.concurrent.Executors.newFixedThreadPool;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import java.time.Duration;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;

import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
import static java.util.concurrent.Executors.newScheduledThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertThrows;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;

import static com.google.common.truth.Truth.assertThat;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.collect.Lists;

    private static final long MAX_POLL_INTERVAL = 30000;
    private static final long BASE_RETRY_DELAY = 1000;
    private static final long MAX_RETRY_DELAY = 30000;
    private static final int MAX_BACKOFF_SHIFT = 3; // Maximum 8 seconds (2^3 * 1000ms)

    private final DirectoryLeaseManager leaseManager;
    private final ConcurrentHashMap<String, ChangeNotificationHandle> activeWatchers;
    private final ConcurrentHashMap<String, Integer> failureCounts;

    private final CIFSContext context;
    private final ScheduledExecutorService cleanupExecutor;
    private static final long DEFAULT_LEASE_CLEANUP_INTERVAL = 60000; // 60 seconds
    private static final int DEFAULT_LEASE_BREAK_TIMEOUT = 60; // 60 seconds per MS-SMB2

    /**
     * Create a new lease manager
     *
     * @param context CIFS context
     */
    public LeaseManager(CIFSContext context) {

                    endLatch.countDown();
                }
            });
        }

        startLatch.countDown(); // Start all threads
        assertTrue(endLatch.await(30, TimeUnit.SECONDS), "All threads should complete within timeout");
        executor.shutdown();

        long overallEnd = System.nanoTime();
        double overallTimeMs = (overallEnd - overallStart) / 1_000_000.0;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
@file:Suppress("ktlint:standard:filename")

package okhttp3.internal

import kotlin.time.Duration.Companion.seconds
import okhttp3.CacheControl
import okhttp3.Headers

internal fun CacheControl.commonToString(): String {
  var result = headerValue
  if (result == null) {
    result =
      buildString {

            ImmutableSet.of(
                // DurationSpec.of(500, MILLISECONDS),
                DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)))
        .withExpireAfterAccesses(
            ImmutableSet.of(
                // DurationSpec.of(500, MILLISECONDS),
                DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)))
        .withRefreshes(
            ImmutableSet.of(