.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);
  }

    for (long value : TEST_LONGS) {
      boolean expectSuccess = value >= min && value <= max;
      try {
        assertThat(UnsignedInteger.valueOf(value).longValue()).isEqualTo(value);
        assertThat(expectSuccess).isTrue();
      } catch (IllegalArgumentException e) {
        assertThat(expectSuccess).isFalse();
      }
    }
  }

  public void testValueOfBigInteger() {
    long min = 0;
    long max = (1L << 32) - 1;

          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() {

    assertWithMessage("%s is subtype of %s", paramType, returnType)
        .that(TypeToken.of(paramType).isSubtypeOf(returnType))
        .isTrue();
    assertWithMessage("%s is supertype of %s", returnType, paramType)
        .that(TypeToken.of(returnType).isSupertypeOf(paramType))
        .isTrue();
    if (!spec.suppressGetSubtype()) {
      assertThat(getSubtype(returnType, TypeToken.of(paramType).getRawType())).isEqualTo(paramType);
    }

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

  public void testForEach() {

 * 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(Ints.contains(ARRAY234, (int) 1)).isFalse();
    assertThat(Ints.contains(new int[] {(int) -1}, (int) -1)).isTrue();
    assertThat(Ints.contains(ARRAY234, (int) 2)).isTrue();
    assertThat(Ints.contains(ARRAY234, (int) 3)).isTrue();
    assertThat(Ints.contains(ARRAY234, (int) 4)).isTrue();
  }

  public void testIndexOf() {
    assertThat(Ints.indexOf(EMPTY, (int) 1)).isEqualTo(-1);

    assertThat(Doubles.contains(ARRAY234, 2.0)).isTrue();
    assertThat(Doubles.contains(ARRAY234, 3.0)).isTrue();
    assertThat(Doubles.contains(ARRAY234, 4.0)).isTrue();

    for (double value : NUMBERS) {
      assertWithMessage("%s", value)
          .that(Doubles.contains(new double[] {5.0, value}, value))
          .isTrue();
    }

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

  public void testForEach() {

    assertThatFutureBecomesCancelled(closingFuture.finishToFuture());
  }

  @Override
  void cancelFinalStepAndWait(ClosingFuture<TestCloseable> closingFuture) {
    assertThat(closingFuture.finishToFuture().cancel(false)).isTrue();
    waitUntilClosed(closingFuture);
    futureCancelled.countDown();
  }