public class DurableHandleV2Request implements CreateContextRequest {

    /**
     * Context name for durable handle V2 request
     */
    public static final String CONTEXT_NAME = "DH2Q";

    private static final byte[] CONTEXT_NAME_BYTES = CONTEXT_NAME.getBytes();
    private static final int STRUCTURE_SIZE = 32; // Corrected to 32 bytes as per MS-SMB2

    // MS-SMB2: Timeout is specified in 100-nanosecond intervals, but we store in milliseconds

    /** Minimum supported SMB Direct protocol version (1.0) */
    public static final int MIN_VERSION = 0x0100; // SMB Direct 1.0
    /** Maximum supported SMB Direct protocol version (1.0) */
    public static final int MAX_VERSION = 0x0100; // SMB Direct 1.0
    /** SMB Direct negotiate request message type */
    public static final int NEGOTIATE_REQUEST = 0x01;

    // Message fields
    private int minVersion = MIN_VERSION;

    }
    HashCode actual = hasher.hash();

    assertEquals(expected, actual);
  }

  private static final String TQBFJOTLD = "The quick brown fox jumps over the lazy dog";
  private static final String TQBFJOTLDP = "The quick brown fox jumps over the lazy dog.";

  private static final ImmutableTable<HashFunction, String, String> KNOWN_HASHES =
      ImmutableTable.<HashFunction, String, String>builder()

          continue;
        }
      }

      stack.removeLast();
      visitedNodes.put(node, NodeVisitState.COMPLETE);
    }
    return false;
  }

  private static final class NodeAndRemainingSuccessors<N> {
    final N node;

    /**
     * The successors left to be visited, or {@code null} if we just added this {@code
     * NodeAndRemainingSuccessors} instance to the stack. In the latter case, we'll compute the

          continue;
        }
      }

      stack.removeLast();
      visitedNodes.put(node, NodeVisitState.COMPLETE);
    }
    return false;
  }

  private static final class NodeAndRemainingSuccessors<N> {
    final N node;

    /**
     * The successors left to be visited, or {@code null} if we just added this {@code
     * NodeAndRemainingSuccessors} instance to the stack. In the latter case, we'll compute the

@J2ktIncompatible
@GwtIncompatible
public final class Resources {
  private Resources() {}

  /**
   * Returns a {@link ByteSource} that reads from the given URL.
   *
   * @since 14.0
   */
  public static ByteSource asByteSource(URL url) {
    return new UrlByteSource(url);
  }

  /** A byte source that reads from a URL using {@link URL#openStream()}. */
  private static final class UrlByteSource extends ByteSource {

        encryptCipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "RC4"));
        byte[] encrypted = encryptCipher.doFinal(plaintext);

        Cipher decryptCipher = Crypto.getArcfour(key);
        decryptCipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "RC4"));
        byte[] decrypted = decryptCipher.doFinal(encrypted);

        // Then
        assertNotNull(encrypted);
        assertNotNull(decrypted);

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class PostExample {
  public static final MediaType JSON = MediaType.get("application/json; charset=utf-8");

  final OkHttpClient client = new OkHttpClient();

  String post(String url, String json) throws IOException {
    RequestBody body = RequestBody.create(json, JSON);

   * your own instanceof tests.
   */

  public final FluentFuture<V> catching(
      Class<Throwable> exceptionType,
      Function<? super Throwable, ? extends V> fallback,
      Executor executor) {
    return (FluentFuture<V>) Futures.catching(this, exceptionType, fallback, executor);
  }

  public final FluentFuture<V> catchingAsync(
      Class<Throwable> exceptionType,

import java.util.SortedSet;

/**
 * GWT emulation of {@link RegularImmutableSortedSet}.
 *
 * @author Hayward Chan
 */
final class RegularImmutableSortedSet<E> extends ImmutableSortedSet<E> {
  /** true if this set is a subset of another immutable sorted set. */
  final boolean isSubset;

  RegularImmutableSortedSet(SortedSet<E> delegate, boolean isSubset) {
    super(delegate);
    this.isSubset = isSubset;
  }