}

  @Test
  public void hasCycle_twoCyclicEdges() {
    for (MutableGraph<Integer> graph : graphsToTest) {
      graph.putEdge(1, 2);
      graph.putEdge(2, 1); // no-op in undirected case
    }
    assertThat(hasCycle(directedGraph)).isTrue();
    assertThat(hasCycle(undirectedGraph)).isFalse();
  }

  @Test
  public void hasCycle_threeAcyclicEdges() {

        that actually comes up in the real world. We want to hear the real-world use case so the
        community can discuss and debate whether this feature is actually the *best* way to address
        the real use case, or whether or not a different abstraction might be more appropriate.


        It's okay if you can't provide complete context on a use case. We understand if you are not

	switch exp := expI.(type) {
	case string:
		expAt, err = strconv.ParseInt(exp, 10, 64)
	case float64:
		expAt, err = int64(exp), nil
	case int64:
		expAt, err = exp, nil
	case int:
		expAt, err = int64(exp), nil
	case uint64:
		expAt, err = int64(exp), nil
	case uint:
		expAt, err = int64(exp), nil
	case json.Number:
		expAt, err = exp.Int64()
	case time.Duration:

	e.strippedPathExpr = pathExpr
	return e.strippedPathExpr
}

func (e *JSONPathElement) String() string {
	switch {
	case e.Key != nil:
		return e.Key.String()
	case e.Index != nil:
		return fmt.Sprintf("[%d]", *e.Index)
	case e.ObjectWildcard:
		return ".*"
	case e.ArrayWildcard:
		return "[*]"
	}
	return ""
}

// String removes double quotes in quoted identifiers

	// Closure to handle listener until httpListener.ctxDoneCh channel is closed.
	handleListener := func(idx int, ln net.Listener) {
		for {
			conn, err := ln.Accept()
			select {
			case listener.acceptCh <- acceptResult{conn, err, idx}:
			case <-listener.ctxDoneCh:
				return
			}
		}
	}

	// Start separate goroutine for each listener to handle connection.
	for idx, ln := range listener.listeners {

}

func objectErrToDriveState(reason error) string {
	switch {
	case reason == nil:
		return madmin.DriveStateOk
	case IsErr(reason, errDiskNotFound):
		return madmin.DriveStateOffline
	case IsErr(reason, errFileNotFound, errFileVersionNotFound, errVolumeNotFound, errPartMissing, errOutdatedXLMeta, errLegacyXLMeta):
		return madmin.DriveStateMissing
	case IsErr(reason, errFileCorrupt, errPartCorrupt):
		return madmin.DriveStateCorrupt

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.base;

import static com.google.common.base.NullnessCasts.uncheckedCastNullableTToT;
import static com.google.common.base.Preconditions.checkState;

import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;

        ComparableVersion lower = new ComparableVersion("1.0.0-alpha1");
        ComparableVersion upper = new ComparableVersion("1.0.0-ALPHA1");
        // Lower case is equal to upper case. This is *NOT* what Semver 1.0
        // specifies. Here we are explicitly deviating from Semver 1.0.
        assertTrue(upper.compareTo(lower) == 0, "expected 1.0.0-ALPHA1 == 1.0.0-alpha1");

		copy(t, s)
		for i := range len(s) {
			if s[i] == ' ' {
				t[i] = '+'
			}
		}
		return string(t)
	}

	j := 0
	for i := range len(s) {
		switch c := s[i]; {
		case c == ' ':
			t[j] = '+'
			j++
		case shouldEscape(c):
			t[j] = '%'
			t[j+1] = "0123456789ABCDEF"[c>>4]
			t[j+2] = "0123456789ABCDEF"[c&15]
			j += 3
		default:
			t[j] = s[i]
			j++
		}
	}
	return string(t)
}

	for {
		if !globalCallhomeConfig.Enabled() {
			// Stop the processing as callhome got disabled
			return false
		}

		select {
		case <-ctx.Done():
			// indicates that we do not need to run callhome anymore
			return false
		case <-callhomeTimer.C:
			if !globalCallhomeConfig.Enabled() {
				// Stop the processing as callhome got disabled
				return false
			}

			performCallhome(ctx)