assertSplitterIterableIsLazy(Splitter.on(","));
  }

  @J2ktIncompatible
  @GwtIncompatible // java.util.regex.Pattern
  @AndroidIncompatible // not clear that j.u.r.Matcher promises to handle mutations during use
  public void testSplitterIterableIsLazy_pattern() {
    if (!CommonPattern.isPcreLike()) {
      return;
    }
    assertSplitterIterableIsLazy(Splitter.onPattern(","));
  }

	err := o.GetRawData(ctx, volume, file, rawDataFn)
	if err != nil {
		if errors.Is(err, errFileNotFound) {
			addErr("GetRawData: No files matched the given pattern")
			return
		}
		embedFileInZip(inspectZipW, "GetRawData-err.txt", []byte(err.Error()), 0o600)
		adminLogIf(ctx, err)
	}

	// save the format.json as part of inspect by default

  public void testAsListEmpty() {
    assertThat(Floats.asList(EMPTY)).isSameInstanceAs(Collections.emptyList());
  }

  /**
   * A reference implementation for {@code tryParse} that just catches the exception from {@link
   * Float#valueOf}.
   */
  private static @Nullable Float referenceTryParse(String input) {
    if (input.trim().length() < input.length()) {
      return null;
    }
    try {

  public void testAsListEmpty() {
    assertThat(Floats.asList(EMPTY)).isSameInstanceAs(Collections.emptyList());
  }

  /**
   * A reference implementation for {@code tryParse} that just catches the exception from {@link
   * Float#valueOf}.
   */
  private static @Nullable Float referenceTryParse(String input) {
    if (input.trim().length() < input.length()) {
      return null;
    }
    try {

   * of reads may not be immediately reflected on the algorithm's data structures. These structures
   * are guarded by a lock and operations are applied in batches to avoid lock contention. The
   * penalty of applying the batches is spread across threads so that the amortized cost is slightly
   * higher than performing just the operation without enforcing the capacity constraint.
   *

communication to establish a relative ordering.
</p>

<h3 id="chan">Channel communication</h3>

<p>
Channel communication is the main method of synchronization
between goroutines.  Each send on a particular channel
is matched to a corresponding receive from that channel,
usually in a different goroutine.
</p>

<p class="rule">
A send on a channel is synchronized before the completion of the
corresponding receive from that channel.

   * the original {@code ClosingFuture} instance.
   *
   * @param exceptionType the exception type that triggers use of {@code fallback}. The exception
   *     type is matched against this step's exception. "This step's exception" means the cause of
   *     the {@link ExecutionException} thrown by {@link Future#get()} on the {@link Future}

    * Specifically the new controller watches the API server for scheduled pods. It processes each pod and ensures that any volumes that implement the volume Attacher interface are attached to the node their pod is scheduled to.

     */
    protected int headerStart;
    /**
     * Total length of the SMB message.
     */
    protected int length;
    /**
     * Batch level for batched requests.
     */
    protected int batchLevel;
    /**
     * Error code returned by the server.
     */
    protected int errorCode;
    /**
     * Additional flags for the SMB message.
     */

  TF_DeleteSessionOptions(opts);

  TF_Output feeds[] = {TF_Output{a, 0}, TF_Output{b, 0}};
  TF_Output fetches[] = {TF_Output{plus2, 0}, TF_Output{plusB, 0}};

  const char* handle = nullptr;
  TF_SessionPRunSetup(sess, feeds, TF_ARRAYSIZE(feeds), fetches,
                      TF_ARRAYSIZE(fetches), nullptr, 0, &handle, s);
  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

  // Feed A and fetch A + 2.