import com.google.common.annotations.J2ktIncompatible;
import java.util.AbstractMap.SimpleImmutableEntry;
import org.jspecify.annotations.Nullable;

/**
 * A notification of the removal of a single entry. The key and/or value may be null if they were
 * already garbage collected.
 *
 * <p>Like other {@code Entry} instances associated with {@code CacheBuilder}, this class holds

      val headers = HeadersReader(source).readHeaders()
      val partSource = PartSource()
      currentPart = partSource
      return Part(headers, partSource.buffer())
    }

    /** A single part in the stream. It is an error to read this after calling [nextPart]. */
    private inner class PartSource : Source {
      private val timeout = Timeout()

      override fun close() {

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * This annotation indicates that the annotated type is <strong>not</strong> threadsafe
 * and should only be used by a single thread.
 *
 * @see ThreadSafe
 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.TYPE)

      Collections.unmodifiableList(cookies)
    } else {
      emptyList()
    }
  }

  /**
   * Convert a request header to OkHttp's cookies via [HttpCookie]. That extra step handles
   * multiple cookies in a single request header, which [Cookie.parse] doesn't support.
   */
  private fun decodeHeaderAsJavaNetCookies(
    url: HttpUrl,
    header: String,
  ): List<Cookie> {
    val result = mutableListOf<Cookie>()

import com.google.caliper.Param;
import com.google.common.primitives.Ints;
import java.util.Random;
import java.util.concurrent.atomic.AtomicLong;
import org.jspecify.annotations.NullUnmarked;

/**
 * Single-threaded benchmark for {@link LoadingCache}.
 *
 * @author Charles Fry
 */
@NullUnmarked
public class LoadingCacheSingleThreadBenchmark {
  @Param({"1000", "2000"})
  int maximumSize;

  @Param("5000")

Later, when reading about how to structure bigger applications ([Bigger Applications - Multiple Files](../../tutorial/bigger-applications.md){.internal-link target=_blank}), possibly with multiple files, you will learn how to declare a single `dependencies` parameter for a group of *path operations*.

## Global Dependencies { #global-dependencies }

But keep in mind that, as everything is handled in memory, in a single list, it will only work while the process is running, and will only work with a single process.

 * limitations under the License.
 */
package okhttp3.slack;

import java.io.IOException;
import java.io.InterruptedIOException;
import okhttp3.HttpUrl;
import okio.Timeout;

/** A connection to Slack as a single user. */
public final class SlackClient {
  private final SlackApi slackApi;
  private OAuthSessionFactory sessionFactory;

  /** Guarded by this. */
  private OAuthSession session;

 */
package jcifs.internal.smb2.lock;

import jcifs.Encodable;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Lock data structure.
 *
 * This class represents a single lock element used in
 * SMB2 Lock requests for byte-range locking.
 *
 * @author mbechler
 */
public class Smb2Lock implements Encodable {

    /**

description: File a bug report
labels: ["bug"]

body:
  - type: markdown
    attributes:
      value: |
        Thanks for taking the time to fill out this bug report.     

        Simple fixes in single PRs do not require issues. 
  
        **Do you use the latest project version?**

  - type: input
    id: version
    attributes:
      label: Affected version
    validations:
      required: true