* limitations under the License.
 */
package okhttp3

import assertk.all
import assertk.assertThat
import assertk.assertions.contains
import assertk.assertions.containsExactly
import assertk.assertions.doesNotContain
import assertk.assertions.hasMessage
import assertk.assertions.hasSize
import assertk.assertions.index
import assertk.assertions.isCloseTo
import assertk.assertions.isEqualTo

    }

    directedGraph.addEdge(N2, N1, E21);
    // View should be updated.
    assertThat(transpose.edgesConnecting(N1, N2)).containsExactly(E21);
    assertThat(transpose.edgeConnectingOrNull(N1, N2)).isEqualTo(E21);

    AbstractNetworkTest.validateNetwork(transpose);
  }

  @Test
  public void inducedSubgraph_graph() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.isCloseTo
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNotNull
import assertk.assertions.isNull

    double[] array = {0.0, 1.0};
    List<Double> list = Doubles.asList(array);
    list.set(0, 2.0);
    assertThat(array).isEqualTo(new double[] {2.0, 1.0});
    array[1] = 3.0;
    assertThat(list).containsExactly(2.0, 3.0).inOrder();
  }

  public void testAsList_toArray_roundTrip() {
    double[] array = {0.0, 1.0, 2.0};
    List<Double> list = Doubles.asList(array);
    double[] newArray = Doubles.toArray(list);

    long[] array = {0L, 1L};
    List<Long> list = Longs.asList(array);
    list.set(0, 2L);
    assertThat(array).isEqualTo(new long[] {2L, 1L});
    array[1] = 3L;
    assertThat(list).containsExactly(2L, 3L).inOrder();
  }

  public void testAsList_toArray_roundTrip() {
    long[] array = {0L, 1L, 2L};
    List<Long> list = Longs.asList(array);
    long[] newArray = Longs.toArray(list);

    List<Short> list = Shorts.asList(array);
    list.set(0, (short) 2);
    assertThat(array).isEqualTo(new short[] {(short) 2, (short) 1});
    array[1] = (short) 3;
    assertThat(list).containsExactly((short) 2, (short) 3).inOrder();
  }

  public void testAsList_toArray_roundTrip() {
    short[] array = {(short) 0, (short) 1, (short) 2};
    List<Short> list = Shorts.asList(array);

    float[] array = {0.0f, 1.0f};
    List<Float> list = Floats.asList(array);
    list.set(0, 2.0f);
    assertThat(array).isEqualTo(new float[] {2.0f, 1.0f});
    array[1] = 3.0f;
    assertThat(list).containsExactly(2.0f, 3.0f).inOrder();
  }

  public void testAsList_toArray_roundTrip() {
    float[] array = {0.0f, 1.0f, 2.0f};
    List<Float> list = Floats.asList(array);
    float[] newArray = Floats.toArray(list);

    int[] array = {(int) 0, (int) 1};
    List<Integer> list = Ints.asList(array);
    list.set(0, (int) 2);
    assertThat(array).isEqualTo(new int[] {(int) 2, (int) 1});
    array[1] = (int) 3;
    assertThat(list).containsExactly((int) 2, (int) 3).inOrder();
  }

  public void testAsList_toArray_roundTrip() {
    int[] array = {(int) 0, (int) 1, (int) 2};
    List<Integer> list = Ints.asList(array);

    float[] array = {0.0f, 1.0f};
    List<Float> list = Floats.asList(array);
    list.set(0, 2.0f);
    assertThat(array).isEqualTo(new float[] {2.0f, 1.0f});
    array[1] = 3.0f;
    assertThat(list).containsExactly(2.0f, 3.0f).inOrder();
  }

  public void testAsList_toArray_roundTrip() {
    float[] array = {0.0f, 1.0f, 2.0f};
    List<Float> list = Floats.asList(array);
    float[] newArray = Floats.toArray(list);

      Integer value = iter.next();
      result.add(value);
      if (value == 8) {
        iter.remove();
      }
    }
    assertIntact(q);
    assertThat(result).containsExactly(1, 15, 13, 8, 14);
  }

  /**
   * This tests a special case of the removeAt() call. Moving an element sideways on the heap could