String msg = "\u00A1\u00A2"; // same Unicode string
        byte[] asciiBytes = msg.getBytes(SmbConstants.DEFAULT_OEM_ENCODING);
        assertTrue(asciiBytes.length > 0, "ASCII encoding should produce bytes");
    }

    @Test
    public void testBufferCreation() throws UnsupportedEncodingException {
        byte[] dataBytes = { 1, 2, 3, 4 };
        String params = "test";

 *   <li>Conversion of individual Hankaku Kana characters to Zenkaku Kana characters.</li>
 *   <li>Handling of voiced (ﾞ) and semi-voiced (ﾟ) sound marks to produce the correct Zenkaku Kana characters.</li>
 * </ul>
 *
 * <p>Example usage:</p>
 * <pre>
 * {@code
 * HankakuKanaToZenkakuKana normalizer = new HankakuKanaToZenkakuKana();

   * char} are hashed directly (in that order). The input must not be updated while this method is
   * in progress.
   *
   * <p><b>Warning:</b> This method will produce different output than most other languages do when
   * running the same hash function on the equivalent input. For cross-language compatibility, use

        byte[] encrypted2 = storage.encryptCredentials(plaintext.clone());

        // Should produce different ciphertexts due to random IV
        assertFalse(Arrays.equals(encrypted1, encrypted2), "Different encryptions should produce different ciphertexts");

        // But both should decrypt to same plaintext
        char[] decrypted1 = storage.decryptCredentials(encrypted1);

### 4. Excluded Types

- Already compressed objects are not fit for compression since they do not have compressible patterns.
Such objects do not produce efficient [`LZ compression`](https://en.wikipedia.org/wiki/LZ77_and_LZ78)
which is a fitness factor for a lossless data compression.

Pre-compressed input typically compresses in excess of 2GiB/s per core,

    this.collector = checkNotNull(collector);
    this.equivalence = checkNotNull(equivalence);
  }

  /**
   * Different orderings for combining the elements of an input array, which must all produce the
   * same result.
   */
  enum CollectStrategy {
    /** Get one accumulator and accumulate the elements into it sequentially. */
    SEQUENTIAL {
      @Override

        assertEquals(32, derived3.length, "Derived key should have correct length");

        assertFalse(Arrays.equals(derived1, derived2), "Different labels should produce different keys");
        assertFalse(Arrays.equals(derived1, derived3), "Different contexts should produce different keys");
    }

    @Test
    public void testStoreNullKey() {

   * edges". For that functionality, see {@link Graphs#reachableNodes(Graph, Object)}.
   *
   * <p>Some algorithms that operate on a {@code SuccessorsFunction} may produce undesired results
   * if the returned {@link Iterable} contains duplicate elements. Implementations of such
   * algorithms should document their behavior in the presence of duplicates.
   *

  @GwtIncompatible
    Object writeReplace() {
    return super.writeReplace();
  }

  @GwtIncompatible
  @J2ktIncompatible
  /*
   * The mainline copy of ImmutableMapValues doesn't produce this serialized form anymore, though
   * the backport does. For now, we're keeping the class declaration in *both* flavors so that both
   * flavors can read old data or data from the other flavor. However, we strongly discourage

# Calls

The HTTP client’s job is to accept your request and produce its response. This is simple in theory but it gets tricky in practice.

## [Requests](https://square.github.io/okhttp/4.x/okhttp/okhttp3/-request/)

Each HTTP request contains a URL, a method (like `GET` or `POST`), and a list of headers. Requests may also contain a body: a data stream of a specific content type.

## [Responses](https://square.github.io/okhttp/4.x/okhttp/okhttp3/-response/)