(state, o) -> state.add((o == null) ? NULL_PLACEHOLDER : o),
          ToOptionalState::combine,
          state -> {
            Object result = state.getElement();
            return (result == NULL_PLACEHOLDER) ? null : result;
          },
          Collector.Characteristics.UNORDERED);

  /**
   * A collector that takes a stream containing exactly one element and returns that element. The

  public void testCheckNotNull_simple_success() {
    String result = checkNotNull(NON_NULL_STRING);
    assertThat(result).isSameInstanceAs(NON_NULL_STRING);
  }

  public void testCheckNotNull_simple_failure() {
    assertThrows(NullPointerException.class, () -> checkNotNull(null));
  }

  public void testCheckNotNull_simpleMessage_success() {
    String result = checkNotNull(NON_NULL_STRING, IGNORE_ME);

  public void testCheckNotNull_simple_success() {
    String result = checkNotNull(NON_NULL_STRING);
    assertThat(result).isSameInstanceAs(NON_NULL_STRING);
  }

  public void testCheckNotNull_simple_failure() {
    assertThrows(NullPointerException.class, () -> checkNotNull(null));
  }

  public void testCheckNotNull_simpleMessage_success() {
    String result = checkNotNull(NON_NULL_STRING, IGNORE_ME);

import org.gradle.api.DefaultTask
import org.gradle.api.GradleException
import org.gradle.api.artifacts.component.ModuleComponentIdentifier
import org.gradle.api.artifacts.result.ResolutionResult
import org.gradle.api.artifacts.result.ResolvedComponentResult
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.TaskAction
import org.gradle.internal.util.PropertiesUtils

     */
    @Test
    void testGetTree() {
        when(smbFileHandle.getTree()).thenReturn(smbTreeHandle);
        SmbTreeHandle result = smbFileHandle.getTree();
        assertEquals(smbTreeHandle, result, "getTree should return the mocked SmbTreeHandle.");
        verify(smbFileHandle, times(1)).getTree();
    }

    /**
     * Test isValid() when the handle is valid.
     */

      unit: TimeUnit,
    ): T? {
      return taskRunner.withLock {
        val waitUntil = nanoTime + unit.toNanos(timeout)
        while (true) {
          val result = poll()
          if (result != null) return@withLock result
          if (nanoTime >= waitUntil) return@withLock null
          val editCountBefore = editCount
          yieldUntil { nanoTime >= waitUntil || editCount > editCountBefore }
        }

   *
   * <p>Among the improvements that this method and {@code LoadingCache.get(K)} both provide are:
   *
   * <ul>
   *   <li>{@linkplain LoadingCache#get(Object) awaiting the result of a pending load} rather than
   *       starting a redundant one
   *   <li>eliminating the error-prone caching boilerplate
   *   <li>tracking load {@linkplain #stats statistics}
   * </ul>
   *

            method.setAccessible(true);

            org.opensearch.search.sort.SortBuilder<?> result = (org.opensearch.search.sort.SortBuilder<?>) method.invoke(queryHelper,
                    "timestamp", org.opensearch.search.sort.SortOrder.DESC);

            assertNotNull(result);
            assertTrue(result.toString().contains("timestamp"));
        } catch (Exception e) {

                .iterator();
    Iterator<Integer> result = Iterators.concat(input);
    assertEquals(1, (int) result.next());
    assertEquals(2, (int) result.next());
    assertThrows(NullPointerException.class, () -> result.hasNext());
    assertThrows(NullPointerException.class, () -> result.next());
    // There is no way to get "through" to the 3.  Buh-bye
  }

    final Chopper or(Chopper you) {
      Chopper i = this;
      return new Chopper() {
        @Override
        @Nullable String chop(String str) {
          String result = i.chop(str);
          return result != null ? result : you.chop(str);
        }
      };
    }

    abstract @Nullable String chop(String str);

    static Chopper suffix(String suffix) {
      return new Chopper() {