assertNextPermutation(newArrayList(3, 4, 1, 2), permutations);
    assertNextPermutation(newArrayList(4, 3, 1, 2), permutations);

    assertNextPermutation(newArrayList(4, 3, 2, 1), permutations);
    assertNextPermutation(newArrayList(3, 4, 2, 1), permutations);
    assertNextPermutation(newArrayList(3, 2, 4, 1), permutations);
    assertNextPermutation(newArrayList(3, 2, 1, 4), permutations);

    assertThat(request.tag(String::class)).isSameAs(uuidTag)
    assertThat(request.tag<String>()).isSameAs(uuidTag)
  }

  @Test
  fun replaceOnlyTag() {
    val uuidTag1 = "1234"
    val uuidTag2 = "4321"
    val request =
      Request
        .Builder()
        .url("https://square.com")
        .tag(String::class, uuidTag1)
        .tag(String::class, uuidTag2)
        .build()

    shares connections when hosts share both IP addresses and certificates, such as `squareup.com`
    and `www.squareup.com`. If a server refuses such sharing it will return HTTP 421 and OkHttp will
    automatically retry on an unshared connection.
 *  Fix: Don't crash if a TLS tunnel's response body is truncated.
 *  Fix: Don't track unusable routes beyond their usefulness. We had a bug where we could track

    server.enqueue(
      MockResponse
        .Builder()
        .body("seed connection")
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .code(421)
        .body("misdirected!")
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .body("after misdirect")
        .build(),
    )

  static int flip(int value) {
    return value ^ Integer.MIN_VALUE;
  }

  /**
   * Compares the two specified {@code int} values, treating them as unsigned values between {@code
   * 0} and {@code 2^32 - 1} inclusive.
   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated; use the
   * equivalent {@link Integer#compareUnsigned(int, int)} method instead.
   *

        .addEqualityGroup(
            newHashSet(3, 2),
            union(singleton(3), singleton(2)),
            intersection(newHashSet(3, 2), newHashSet(3, 2, 1)),
            difference(newHashSet(3, 2, 1), newHashSet(1)),
            symmetricDifference(newHashSet(3, 1), newHashSet(2, 1)))
        .addEqualityGroup(
            newHashSet(1, 2, 3),

    checkInitialCapacity(2, 7, 4);
    checkInitialCapacity(2, 8, 4);

    checkInitialCapacity(4, 0, 1);
    checkInitialCapacity(4, 1, 1);
    checkInitialCapacity(4, 2, 1);
    checkInitialCapacity(4, 3, 1);
    checkInitialCapacity(4, 4, 1);
    checkInitialCapacity(4, 5, 2);
    checkInitialCapacity(4, 6, 2);
    checkInitialCapacity(4, 7, 2);
    checkInitialCapacity(4, 8, 2);
  }

    checkInitialCapacity(2, 7, 4);
    checkInitialCapacity(2, 8, 4);

    checkInitialCapacity(4, 0, 1);
    checkInitialCapacity(4, 1, 1);
    checkInitialCapacity(4, 2, 1);
    checkInitialCapacity(4, 3, 1);
    checkInitialCapacity(4, 4, 1);
    checkInitialCapacity(4, 5, 2);
    checkInitialCapacity(4, 6, 2);
    checkInitialCapacity(4, 7, 2);
    checkInitialCapacity(4, 8, 2);
  }

        // Clear execution order before test
        PriorityTrackingBooster.clearExecutionOrder();

        scoreUpdater.execute();

        // Boosters should be executed in priority order (3, 2, 1)
        List<Integer> executionOrder = PriorityTrackingBooster.getExecutionOrder();
        assertEquals(3, executionOrder.size());
        assertEquals(Integer.valueOf(3), executionOrder.get(0));

    assume().that(graph.incidentEdgeOrder().type()).isEqualTo(ElementOrder.Type.STABLE);

    populateStarShapedGraph();

    assertThat(graph.successors(1)).containsExactly(4, 3, 2).inOrder();
  }

  @Test
  public void stableIncidentEdgeOrder_incidentEdges_returnsInEdgeInsertionOrder() {
    assume().that(graph.incidentEdgeOrder().type()).isEqualTo(ElementOrder.Type.STABLE);