*/
  @Test
  public void putEdge_nodesNotInGraph() {
    assume().that(graphIsMutable()).isTrue();

    graphAsMutableGraph.addNode(N1);
    assertThat(graphAsMutableGraph.putEdge(N1, N5)).isTrue();
    assertThat(graphAsMutableGraph.putEdge(N4, N1)).isTrue();
    assertThat(graphAsMutableGraph.putEdge(N2, N3)).isTrue();
    assertThat(graph.nodes()).containsExactly(N1, N5, N4, N2, N3).inOrder();

    assertThat(future.set(1)).isTrue();
    assertSuccessful(future, 1);
  }

  public void testFailed() throws Exception {
    Exception cause = new Exception();
    assertThat(future.setException(cause)).isTrue();
    assertFailed(future, cause);
  }

  public void testCanceled() throws Exception {
    assertThat(future.cancel(false /* mayInterruptIfRunning */)).isTrue();
    assertCancelled(future, false);
  }

          .build(),
      )
    assertThat(cacheControl.noCache).isTrue()
    assertThat(cacheControl.noStore).isTrue()
    assertThat(cacheControl.maxAgeSeconds).isEqualTo(1)
    assertThat(cacheControl.sMaxAgeSeconds).isEqualTo(2)
    assertThat(cacheControl.isPrivate).isTrue()
    assertThat(cacheControl.isPublic).isTrue()
    assertThat(cacheControl.mustRevalidate).isTrue()
    assertThat(cacheControl.maxStaleSeconds).isEqualTo(3)

 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNotNull
import assertk.assertions.isTrue
import java.io.IOException
import java.io.InterruptedIOException
import java.net.HttpURLConnection
import java.time.Duration
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit

    assume().that(graphIsMutable()).isTrue();
    assume().that(network.allowsSelfLoops()).isTrue();
    assume().that(network.allowsParallelEdges()).isTrue();

    assertThat(networkAsMutableNetwork.addEdge(N1, N1, E11)).isTrue();
    assertThat(networkAsMutableNetwork.addEdge(N1, N1, E11_A)).isTrue();
    assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11, E11_A);
  }

    assume().that(graph.allowsSelfLoops()).isTrue();

    addNode(N1);
    putEdge(N1, N1);
    assertThat(graphAsMutableGraph.removeNode(N1)).isTrue();
    assertThat(graph.nodes()).isEmpty();
  }

  @Test
  public void removeEdge_existingSelfLoopEdge() {
    assume().that(graphIsMutable()).isTrue();
    assume().that(graph.allowsSelfLoops()).isTrue();

    putEdge(N1, N1);

    assume().that(graphIsMutable()).isTrue();
    assume().that(network.allowsParallelEdges()).isTrue();

    assertThat(networkAsMutableNetwork.addEdge(N1, N2, E12)).isTrue();
    assertThat(networkAsMutableNetwork.addEdge(N2, N1, E21)).isTrue();
    assertThat(networkAsMutableNetwork.addEdge(N1, N2, E12_A)).isTrue();
    assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12, E12_A, E21);

    assume().that(graph.allowsSelfLoops()).isTrue();

    addNode(N1);
    putEdge(N1, N1);
    assertThat(graphAsMutableGraph.removeNode(N1)).isTrue();
    assertThat(graph.nodes()).isEmpty();
  }

  @Test
  public void removeEdge_existingSelfLoopEdge() {
    assume().that(graphIsMutable()).isTrue();
    assume().that(graph.allowsSelfLoops()).isTrue();

    putEdge(N1, N1);

      dispatcher = dispatcherC
    }

  @Test
  fun happyPath() {
    testInstances += this

    assertThat(serverA.started).isTrue()
    assertThat(serverB.started).isTrue()
    assertThat(serverC.started).isFalse()

    assertThat(serverD.started).isTrue()
    assertThat(serverE.started).isTrue()
    assertThat(serverF.started).isFalse()
  }

  private companion object {

//    assertThat(it.handshake()!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
      }
    }
  }

  @Test
  fun testIfSupported() {
    assertThat(PlatformRule.isCorrettoSupported).isTrue()
    assertThat(PlatformRule.isCorrettoInstalled).isTrue()
  }