NetworkBuilder.undirected().allowsParallelEdges(true).build();
    assertThat(undirectedMultigraph.addEdge(N1, N2, E12)).isTrue();
    assertThat(undirectedMultigraph.addEdge(N1, N2, E12_A)).isTrue();
    assertThat(undirectedMultigraph.addEdge(N2, N1, E21)).isTrue();
    assertThat(undirectedMultigraph.edgesConnecting(N1, N2))
        .isEqualTo(ImmutableSet.of(E12, E12_A, E21));
  }

  @Test

    assertThat(dispatcher.queuedCalls()).isEmpty()
    assertThat(a1.isExecuted()).isTrue()
    assertThat(a1.isCanceled()).isFalse()
    assertThat(a2.isExecuted()).isTrue()
    assertThat(a2.isCanceled()).isTrue()
    assertThat(a3.isExecuted()).isFalse()
    assertThat(a3.isCanceled()).isTrue()
    assertThat(a4.isExecuted()).isFalse()
    assertThat(a4.isCanceled()).isFalse()
  }

  @Test

 * limitations under the License.
 */
package okhttp3.internal.publicsuffix

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import assertk.assertions.isTrue
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import okhttp3.internal.publicsuffix.ResourcePublicSuffixList.Companion.PUBLIC_SUFFIX_RESOURCE
import okhttp3.internal.toCanonicalHost

    assertThat(Bytes.contains(ARRAY234, (byte) 1)).isFalse();
    assertThat(Bytes.contains(new byte[] {(byte) -1}, (byte) -1)).isTrue();
    assertThat(Bytes.contains(ARRAY234, (byte) 2)).isTrue();
    assertThat(Bytes.contains(ARRAY234, (byte) 3)).isTrue();
    assertThat(Bytes.contains(ARRAY234, (byte) 4)).isTrue();
  }

  public void testIndexOf() {
    assertThat(Bytes.indexOf(EMPTY, (byte) 1)).isEqualTo(-1);

    assertThat(Chars.contains(ARRAY234, (char) 1)).isFalse();
    assertThat(Chars.contains(new char[] {(char) -1}, (char) -1)).isTrue();
    assertThat(Chars.contains(ARRAY234, (char) 2)).isTrue();
    assertThat(Chars.contains(ARRAY234, (char) 3)).isTrue();
    assertThat(Chars.contains(ARRAY234, (char) 4)).isTrue();
  }

  public void testIndexOf() {
    assertThat(Chars.indexOf(EMPTY, (char) 1)).isEqualTo(-1);

    }
  }

  public void testAllocArraysDefault() {
    CompactLinkedHashMap<Integer, String> map = CompactLinkedHashMap.create();
    assertThat(map.needsAllocArrays()).isTrue();
    assertThat(map.entries).isNull();
    assertThat(map.keys).isNull();
    assertThat(map.values).isNull();
    assertThat(map.links).isNull();

    map.put(1, Integer.toString(1));

 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isNotNull
import assertk.assertions.isTrue
import okhttp3.TestUtil.assumeNetwork
import okhttp3.internal.platform.ConscryptPlatform
import okhttp3.internal.platform.Platform
import okhttp3.testing.PlatformRule
import org.conscrypt.Conscrypt

            .createTestSuite());
    return suite;
  }

  public void testAllocArraysDefault() {
    CompactHashSet<Integer> set = CompactHashSet.create();
    assertThat(set.needsAllocArrays()).isTrue();
    assertThat(set.elements).isNull();

    set.add(1);
    assertThat(set.needsAllocArrays()).isFalse();
    assertThat(set.elements).hasLength(CompactHashing.DEFAULT_SIZE);
  }

          assertWithMessage("%s, %s (expected: %s, actual%s)", x, y, expected, actual)
              .that(actual < 0)
              .isTrue();
        } else {
          assertWithMessage("%s, %s (expected: %s, actual%s)", x, y, expected, actual)
              .that(actual > 0)
              .isTrue();
        }
      }
    }
  }

  public void testMax_noArgs() {

    assertThat(iia.contains(1)).isTrue();
    assertThat(iia.contains(8)).isTrue();
    assertThat(iia.contains(4)).isFalse();
    assertThat(ImmutableLongArray.of(13).contains(13)).isTrue();
    assertThat(ImmutableLongArray.of().contains(21)).isFalse();
    assertThat(iia.subArray(1, 5).contains(1)).isTrue();
  }

  public void testForEach() {