* object to facilitate testing.
   */
  private final SleepingStopwatch stopwatch;

  // Can't be initialized in the constructor because mocks don't call the constructor.
  private volatile @Nullable Object mutexDoNotUseDirectly;

  private Object mutex() {
    Object mutex = mutexDoNotUseDirectly;
    if (mutex == null) {
      synchronized (this) {

        assertTrue("CONNECT method should exist", hasConnect);
    }

    @Test
    public void test_FactoryMethodsReturnNewInstances() {
        // ## Test that each factory method call returns a new instance ##

        // ## Act ##
        final CurlRequest request1 = Curl.get("http://example.com");
        final CurlRequest request2 = Curl.get("http://example.com");

        // ## Assert ##

        checkArgument(edges().contains(edge));
        return edge;
      }

      // Don't override the existing edge[s]Connecting() or *degree() AbstractNetwork
      // implementations; they call in/outEdges() and should be fine.
    };
  }

  /**
   * Throws {@code IllegalArgumentException} if the ordering of {@code endpoints} is not compatible
   * with the directionality of this graph.
   */

    @Override
    public void suppress(Closeable closeable, Throwable thrown, Throwable suppressed) {
      suppressions.add(new Suppression(closeable, thrown, suppressed));
    }
  }

  /** Record of a call to suppress. */
  private static class Suppression {
    private final Closeable closeable;
    private final Throwable thrown;
    private final Throwable suppressed;

                } catch (final IOException ioe) {
                    ioe.printStackTrace(log);
                }
            }
        }
    }

    /* Build a connection. Only one thread will ever call this method at
     * any one time. If this method throws an exception or the connect timeout
     * expires an encapsulating TransportException will be thrown from connect
     * and the transport will be in error.
     */

          return true;
        }
      }
      return false;
    }

    Alphabet upperCase() {
      if (!hasLowerCase()) {
        return this;
      }
      checkState(!hasUpperCase(), "Cannot call upperCase() on a mixed-case alphabet");
      char[] upperCased = new char[chars.length];
      for (int i = 0; i < chars.length; i++) {
        upperCased[i] = Ascii.toUpperCase(chars[i]);
      }

            when(mockSession.getConfig()).thenReturn(mockConfig);

            for (int i = 0; i < 10; i++) {
                assertSame(mockConfig, mockSession.getConfig(), "getConfig should return same result on call " + i);
            }

            verify(mockSession, times(10)).getConfig();
        }

        @Test
        @DisplayName("Should handle concurrent access patterns")

            entry.dfs_name = "consistent_share_" + i;
            testArray.s[i] = entry;
        }

        setDfsEnumArray(dfsRootEnum, testArray);

        // Call getEntries multiple times
        FileEntry[] entries1 = dfsRootEnum.getEntries();
        FileEntry[] entries2 = dfsRootEnum.getEntries();
        FileEntry[] entries3 = dfsRootEnum.getEntries();

   * {@code factory.get()} does.
   *
   * <p>Call this method only when the simpler factory methods in classes like {@link
   * HashBasedTable} and {@link TreeBasedTable} won't suffice.
   *
   * <p>The views returned by the {@code Table} methods {@link Table#column}, {@link
   * Table#columnKeySet}, and {@link Table#columnMap} have iterators that don't support {@code

    } catch (AssertionFailedError expected) {
      return;
    }
    fail("Should have failed");
  }

  /** An interface for the 2 ways that a chaining call might be defined. */
  private interface ChainingCalls {
    // A method that is defined to 'return this'
    @CanIgnoreReturnValue
    ChainingCalls chainingCall();