val deltaMillis = 1000.0
    val durationMillis = TimeUnit.MINUTES.toMillis((60 * 24).toLong())
    assertThat(certificate.notBefore.time.toDouble())
      .isCloseTo(now.toDouble(), deltaMillis)
    assertThat(certificate.notAfter.time.toDouble())
      .isCloseTo(now.toDouble() + durationMillis, deltaMillis)
  }

  @Test
  fun customInterval() {
    // 5 seconds starting on 1970-01-01.
    val heldCertificate =

      assertThat(result).isInstanceOf(eventClass)
    }

    if (elapsedMs != -1L) {
      assertThat(
        TimeUnit.NANOSECONDS.toMillis(actualElapsedNs)
          .toDouble(),
      )
        .isCloseTo(elapsedMs.toDouble(), 100.0)
    }

    return result
  }

  fun recordedEventTypes() = eventSequence.map { it.name }

  fun clearAllEvents() {
    while (eventSequence.isNotEmpty()) {

     * @return 変換された{@link Double}
     */
    public static Double toDouble(final Object o) {
        return toDouble(o, null);
    }

    /**
     * {@link Double}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @param pattern
     *            パターン文字列
     * @return 変換された{@link Double}
     */
    public static Double toDouble(final Object o, final String pattern) {
        if (o == null) {

 */
public class DoubleConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToDouble() throws Exception {
        assertEquals(new Double("1000.5"), DoubleConversionUtil.toDouble("1,000.5"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveDouble() throws Exception {
        assertEquals(1000.5, DoubleConversionUtil.toPrimitiveDouble("1,000.5"), 0);
    }

    assertThat(cookie.value).isEqualTo("android")
    assertThat(cookie.commentURL).isNull()
    assertThat(cookie.discard).isFalse()
    // Converting to a fixed date can cause rounding!
    assertThat(cookie.maxAge.toDouble()).isCloseTo(60.0, 5.0)
    assertThat(cookie.path).isEqualTo("/path")
    assertThat(cookie.secure).isTrue()
  }

  @Test
  fun testQuotedAttributeValues() {

      assertThat(result).isInstanceOf(eventClass)
    }

    if (elapsedMs != -1L) {
      assertThat(
        TimeUnit.NANOSECONDS.toMillis(actualElapsedNs)
          .toDouble(),
      )
        .isCloseTo(elapsedMs.toDouble(), 100.0)
    }

    return result
  }

  fun recordedEventTypes() = eventSequence.map { it.name }

  fun clearAllEvents() {
    while (eventSequence.isNotEmpty()) {

        } else if (type == BigDecimal.class) {
            return BigDecimalConversionUtil.toBigDecimal(o);
        } else if (type == Double.class) {
            return DoubleConversionUtil.toDouble(o);
        } else if (type == Long.class) {
            return LongConversionUtil.toLong(o);
        } else if (type == Float.class) {
            return FloatConversionUtil.toFloat(o);

            type.isFloat -> KtConstantValue.KtFloatConstantValue((value as Number).toFloat(), expression)
            type.isDouble -> KtConstantValue.KtDoubleConstantValue((value as Number).toDouble(), expression)
            else -> null
        }

        return constantValue?.let { KtConstantAnnotationValue(it, analysisSession.token) }
    }

    private fun Collection<FirExpression>.convertVarargsExpression(

        while (e != null) {
          println(e)
          e = e.cause
        }
      }
    }
    println()
  }
  time = System.currentTimeMillis() - time
  println("Time: ${time.toDouble() / 1000} seconds\n")
}

fun main() {
  Security.insertProviderAt(OpenSSLProvider(), 1)
  var bootstrapClient = OkHttpClient()
  var names = listOf("google.com", "graph.facebook.com", "sdflkhfsdlkjdf.ee")
  try {

                args[index] = FloatConversionUtil.toFloat(args[index]);
                return true;
            } else if (paramTypes[index] == double.class) {
                args[index] = DoubleConversionUtil.toDouble(args[index]);
                return true;
            }
        } else {
            if (paramTypes[index] == Byte.class) {
                args[index] = ByteConversionUtil.toByte(args[index]);