Removing duplication from Duration.

I don't know what good it is to have code review if we are checking
in code like this. We must raise the bar, people. When the
justification for code being in the standard library is borderline
at best - as it is here - then the code must be of exceptional
quality. This code is not of exceptional quality.

Mostly these are not behavioral changes, but:

 - I removed finite_? as it is a gratuitous deviation from
   every isXXX method in the world.  This isn't ruby.
 - I removed all the regexps, which only made things complicated
 - I removed all the unnecessary casts, which is to say, all of them
 - I made more things final, sealed, and private
 - The unapply structure was all wrong; returning Option[Duration]
   on the string unapply meant you'd have to say
     case Duration(Duration(x, y)) => ...
   So I fixed apply and unapply to be symmetric.
 - And I removed the "parse" method, since it was doing what
   apply is supposed to do.

There's a test case to exercise accessing it from java,
which also reveals what I hope are bugs.

Thanks to viktor klang for DurationConversions.

3 files changed, 578 insertions, 328 deletions

diff --git a/src/library/scala/concurrent/util/Duration.scala b/src/library/scala/concurrent/util/Duration.scala
index bab664727e..bf0f3006f1 100644
--- a/src/library/scala/concurrent/util/Duration.scala
+++ b/src/library/scala/concurrent/util/Duration.scala
@@ -26,76 +26,68 @@ object Deadline {
   def now: Deadline = Deadline(Duration(System.nanoTime, NANOSECONDS))
 }
 
+// TODO: "Inf", "PlusInf", "MinusInf", where did these names come from?
+// TODO: Duration.create(n, DAYS) == Duration(Long.MaxValue, NANOSECONDS) forall (n: Double) >= 106752d
 object Duration {
   implicit def timeLeft(implicit d: Deadline): Duration = d.timeLeft
 
-  def apply(length: Long, unit: TimeUnit): FiniteDuration = new FiniteDuration(length, unit)
   def apply(length: Double, unit: TimeUnit): FiniteDuration = fromNanos(unit.toNanos(1) * length)
-  def apply(length: Long, unit: String): FiniteDuration = new FiniteDuration(length,  Duration.timeUnit(unit))
+  def apply(length: Long, unit: TimeUnit): FiniteDuration   = new FiniteDuration(length, unit)
+  def apply(length: Long, unit: String): FiniteDuration     = new FiniteDuration(length,  Duration.timeUnit(unit))
 
   /**
-   * Construct a Duration by parsing a String. In case of a format error, a
-   * RuntimeException is thrown. See `unapply(String)` for more information.
-   */
-  def apply(s: String): Duration = unapply(s) getOrElse sys.error("format error " + s)
-
-  private val RE = ("""^\s*([\+|-]?\d+(?:\.\d+)?)\s*""" + // length part
-    "(?:" + // units are distinguished in separate match groups
-    "(d|day|days)|" +
-    "(h|hour|hours)|" +
-    "(min|minute|minutes)|" +
-    "(s|sec|second|seconds)|" +
-    "(ms|milli|millis|millisecond|milliseconds)|" +
-    "(µs|micro|micros|microsecond|microseconds)|" +
-    "(ns|nano|nanos|nanosecond|nanoseconds)" +
-    """)\s*$""").r // close the non-capturing group
-  private val REinf = """^\s*(?:\+|Plus)?Inf\s*$""".r
-  private val REminf = """^\s*(?:-|Minus)Inf\s*""".r
-
-  /**
-   * Deconstruct a Duration into `Long` length and [[java.util.concurrent.TimeUnit]] if it is a 
-   * [[scala.util.concurrent.FiniteDuration]].
-   *
-   * @param d Duration to be deconstructed.
+   * Parse String into Duration.  Format is `"<length><unit>"`, where
+   * whitespace is allowed before, between and after the parts. Infinities are
+   * designated by `"Inf"`, `"PlusInf"`, `"+Inf"` and `"-Inf"` or `"MinusInf"`.
+   * Throws exception if format is not parseable.
    */
-  def unapply(d: Duration): Option[(Long, TimeUnit)] = {
-    if (d.finite_?) {
-      Some((d.length, d.unit))
-    } else {
-      None
+  def apply(s: String): Duration = {
+    val s1: String = s filterNot (_.isWhitespace)
+    s1 match {
+      case "Inf" | "PlusInf" | "+Inf" => Inf
+      case "MinusInf" | "-Inf"        => MinusInf
+      case _                          =>
+        val unitName = s1.reverse takeWhile (_.isLetter) reverse;
+        def length   = JDouble.parseDouble(s1 dropRight unitName.length)
+        timeUnit get unitName match {
+          case Some(unit) => Duration(length, unit)
+          case _          => sys.error("format error " + s)
+        }
     }
   }
 
-  /**
-   * Parse String, return None if no match. Format is `"<length><unit>"`, where
-   * whitespace is allowed before, between and after the parts. Infinities are
-   * designated by `"Inf"`, `"PlusInf"`, `"+Inf"` and `"-Inf"` or `"MinusInf"`.
-   */
-  def unapply(s: String): Option[Duration] = s match {
-    case RE(length, d, h, m, s, ms, mus, ns) ⇒
-      if (d ne null)
-        Some(Duration(JDouble.parseDouble(length), DAYS))
-      else if (h ne null)
-        Some(Duration(JDouble.parseDouble(length), HOURS))
-      else if (m ne null)
-        Some(Duration(JDouble.parseDouble(length), MINUTES))
-      else if (s ne null)
-        Some(Duration(JDouble.parseDouble(length), SECONDS))
-      else if (ms ne null)
-        Some(Duration(JDouble.parseDouble(length), MILLISECONDS))
-      else if (mus ne null)
-        Some(Duration(JDouble.parseDouble(length), MICROSECONDS))
-      else if (ns ne null)
-        Some(Duration(JDouble.parseDouble(length), NANOSECONDS))
-      else
-        sys.error("made some error in regex (should not be possible)")
-    case REinf()  ⇒ Some(Inf)
-    case REminf() ⇒ Some(MinusInf)
-    case _        ⇒ None
+  // "ms milli millisecond" -> List("ms", "milli", "millis", "millisecond", "milliseconds")
+  private def words(s: String) = (s.trim split "\\s+").toList
+  private def expandLabels(labels: String): List[String] = {
+    val hd :: rest = words(labels)
+    hd :: rest.flatMap(s => List(s, s + "s"))
   }
+  private val timeUnitLabels = List(
+    DAYS         -> "d day",
+    HOURS        -> "h hour",
+    MINUTES      -> "min minute",
+    SECONDS      -> "s sec second",
+    MILLISECONDS -> "ms milli millisecond",
+    MICROSECONDS -> "µs micro microsecond",
+    NANOSECONDS  -> "ns nano nanosecond"
+  )
+
+  // TimeUnit => standard label
+  protected[util] val timeUnitName: Map[TimeUnit, String] =
+    timeUnitLabels.toMap mapValues (s => words(s).last) toMap
+
+  // Label => TimeUnit
+  protected[util] val timeUnit: Map[String, TimeUnit] =
+    timeUnitLabels flatMap { case (unit, names) => expandLabels(names) map (_ -> unit) } toMap
+
+  def unapply(s: String): Option[(Long, TimeUnit)] =
+    ( try Some(apply(s)) catch { case _: RuntimeException => None } ) flatMap unapply
+
+  def unapply(d: Duration): Option[(Long, TimeUnit)] =
+    if (d.isFinite) Some((d.length, d.unit)) else None
 
   def fromNanos(nanos: Double): FiniteDuration =
-    fromNanos((nanos + 0.5).asInstanceOf[Long])
+    fromNanos((nanos + 0.5).toLong)
 
   def fromNanos(nanos: Long): FiniteDuration = {
     if (nanos % 86400000000000L == 0) {
@@ -118,72 +110,62 @@ object Duration {
   /**
    * Parse TimeUnit from string representation.
    */
-  protected[util] def timeUnit(unit: String): TimeUnit = unit.toLowerCase match {
-    case "d" | "day" | "days"                                       => DAYS
-    case "h" | "hour" | "hours"                                     => HOURS
-    case "min" | "minute" | "minutes"                               => MINUTES
-    case "s" | "sec" | "second" | "seconds"                         => SECONDS
-    case "ms" | "milli" | "millis" | "millisecond" | "milliseconds" => MILLISECONDS
-    case "µs" | "micro" | "micros" | "microsecond" | "microseconds" => MICROSECONDS
-    case "ns" | "nano" | "nanos" | "nanosecond" | "nanoseconds"     => NANOSECONDS
-  }
 
   val Zero: FiniteDuration = new FiniteDuration(0, NANOSECONDS)
-  val Undefined: Duration = new Duration with Infinite {
+
+  object Undefined extends Infinite {
+    private def fail(what: String) = throw new IllegalArgumentException(s"cannot $what Undefined duration")
+
     override def toString = "Duration.Undefined"
-    override def equals(other: Any) = other.asInstanceOf[AnyRef] eq this
-    override def +(other: Duration): Duration = throw new IllegalArgumentException("cannot add Undefined duration")
-    override def -(other: Duration): Duration = throw new IllegalArgumentException("cannot subtract Undefined duration")
-    override def *(factor: Double): Duration = throw new IllegalArgumentException("cannot multiply Undefined duration")
-    override def /(factor: Double): Duration = throw new IllegalArgumentException("cannot divide Undefined duration")
-    override def /(other: Duration): Double = throw new IllegalArgumentException("cannot divide Undefined duration")
-    def compare(other: Duration) = throw new IllegalArgumentException("cannot compare Undefined duration")
-    def unary_- : Duration = throw new IllegalArgumentException("cannot negate Undefined duration")
+    override def equals(other: Any) = this eq other.asInstanceOf[AnyRef]
+    override def +(other: Duration): Duration = fail("add")
+    override def -(other: Duration): Duration = fail("subtract")
+    override def *(factor: Double): Duration  = fail("multiply")
+    override def /(factor: Double): Duration  = fail("divide")
+    override def /(other: Duration): Double   = fail("divide")
+    def compare(other: Duration) = fail("compare")
+    def unary_- : Duration = fail("negate")
   }
 
-  trait Infinite {
-    this: Duration =>
-
-    def +(other: Duration): Duration =
-      other match {
-        case _: this.type => this
-        case _: Infinite  => throw new IllegalArgumentException("illegal addition of infinities")
-        case _            => this
-      }
+  sealed abstract class Infinite extends Duration {
+    def +(other: Duration): Duration = other match {
+      case x: Infinite if x ne this => throw new IllegalArgumentException("illegal addition of infinities")
+      case _                        => this
+    }
+    // Is this really intended to throw if the argument is "this" but otherwise return this?
     def -(other: Duration): Duration =
-      other match {
-        case _: this.type => throw new IllegalArgumentException("illegal subtraction of infinities")
-        case _            => this
-      }
+      if (other ne this) this
+      else throw new IllegalArgumentException("illegal subtraction of infinities")
+
     def *(factor: Double): Duration = this
     def /(factor: Double): Duration = this
-    def /(other: Duration): Double =
-      other match {
-        case _: Infinite => throw new IllegalArgumentException("illegal division of infinities")
-        // maybe questionable but pragmatic: Inf / 0 => Inf
-        case x           => Double.PositiveInfinity * (if ((this > Zero) ^ (other >= Zero)) -1 else 1)
-      }
-
-    def finite_? = false
-
-    def length: Long = throw new IllegalArgumentException("length not allowed on infinite Durations")
-    def unit: TimeUnit = throw new IllegalArgumentException("unit not allowed on infinite Durations")
-    def toNanos: Long = throw new IllegalArgumentException("toNanos not allowed on infinite Durations")
-    def toMicros: Long = throw new IllegalArgumentException("toMicros not allowed on infinite Durations")
-    def toMillis: Long = throw new IllegalArgumentException("toMillis not allowed on infinite Durations")
-    def toSeconds: Long = throw new IllegalArgumentException("toSeconds not allowed on infinite Durations")
-    def toMinutes: Long = throw new IllegalArgumentException("toMinutes not allowed on infinite Durations")
-    def toHours: Long = throw new IllegalArgumentException("toHours not allowed on infinite Durations")
-    def toDays: Long = throw new IllegalArgumentException("toDays not allowed on infinite Durations")
-    def toUnit(unit: TimeUnit): Double = throw new IllegalArgumentException("toUnit not allowed on infinite Durations")
+    def /(other: Duration): Double = other match {
+      case _: Infinite => throw new IllegalArgumentException("illegal division of infinities")
+      // maybe questionable but pragmatic: Inf / 0 => Inf
+      case x           => Double.PositiveInfinity * (if ((this > Zero) ^ (other >= Zero)) -1 else 1)
+    }
+
+    final def isFinite() = false
 
+    private def fail(what: String) = throw new IllegalArgumentException(s"$what not allowed on infinite Durations")
+    def length: Long    = fail("length")
+    def toNanos: Long   = fail("toNanos")
+    def toMicros: Long  = fail("toMicros")
+    def toMillis: Long  = fail("toMillis")
+    def toSeconds: Long = fail("toSeconds")
+    def toMinutes: Long = fail("toMinutes")
+    def toHours: Long   = fail("toHours")
+    def toDays: Long    = fail("toDays")
+
+    def unit: TimeUnit                 = fail("unit")
+    def toUnit(unit: TimeUnit): Double = fail("toUnit")
   }
 
   /**
    * Infinite duration: greater than any other and not equal to any other,
    * including itself.
    */
-  val Inf: Duration = new Duration with Infinite {
+  val Inf: Infinite = new Infinite {
     override def toString = "Duration.Inf"
     def compare(other: Duration) = if (other eq this) 0 else 1
     def unary_- : Duration = MinusInf
@@ -193,17 +175,17 @@ object Duration {
    * Infinite negative duration: lesser than any other and not equal to any other,
    * including itself.
    */
-  val MinusInf: Duration = new Duration with Infinite {
+  val MinusInf: Infinite = new Infinite {
     override def toString = "Duration.MinusInf"
     def compare(other: Duration) = if (other eq this) 0 else -1
     def unary_- : Duration = Inf
   }
 
   // Java Factories
-  def create(length: Long, unit: TimeUnit): FiniteDuration = apply(length, unit)
+  def create(length: Long, unit: TimeUnit): FiniteDuration   = apply(length, unit)
   def create(length: Double, unit: TimeUnit): FiniteDuration = apply(length, unit)
-  def create(length: Long, unit: String): FiniteDuration = apply(length, unit)
-  def parse(s: String): Duration = unapply(s).get
+  def create(length: Long, unit: String): FiniteDuration     = apply(length, unit)
+  def create(s: String): Duration                            = apply(s)
 
   implicit object DurationIsOrdered extends Ordering[Duration] {
     def compare(a: Duration, b: Duration) = a compare b
@@ -261,23 +243,22 @@ abstract class Duration extends Serializable with Ordered[Duration] {
   def /(factor: Double): Duration
   def /(other: Duration): Double
   def unary_- : Duration
-  def finite_? : Boolean
+  def isFinite(): Boolean
   def min(other: Duration): Duration = if (this < other) this else other
   def max(other: Duration): Duration = if (this > other) this else other
   def fromNow: Deadline = Deadline.now + this
 
   // Java API
-  def lt(other: Duration) = this < other
-  def lteq(other: Duration) = this <= other
-  def gt(other: Duration) = this > other
-  def gteq(other: Duration) = this >= other
-  def plus(other: Duration) = this + other
+  def div(factor: Double)    = this / factor
+  def div(other: Duration)   = this / other
+  def gt(other: Duration)    = this > other
+  def gteq(other: Duration)  = this >= other
+  def lt(other: Duration)    = this < other
+  def lteq(other: Duration)  = this <= other
   def minus(other: Duration) = this - other
-  def mul(factor: Double) = this * factor
-  def div(factor: Double) = this / factor
-  def div(other: Duration) = this / other
-  def neg() = -this
-  def isFinite() = finite_?
+  def mul(factor: Double)    = this * factor
+  def neg()                  = -this
+  def plus(other: Duration)  = this + other
 }
 
 object FiniteDuration {
@@ -286,252 +267,121 @@ object FiniteDuration {
   }
 
   def apply(length: Long, unit: TimeUnit) = new FiniteDuration(length, unit)
-
-  def apply(length: Long, unit: String) = new FiniteDuration(length, Duration.timeUnit(unit))
-
+  def apply(length: Long, unit: String)   = new FiniteDuration(length, Duration.timeUnit(unit))
 }
 
 class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
   import Duration._
 
-  def toNanos = unit.toNanos(length)
-  def toMicros = unit.toMicros(length)
-  def toMillis = unit.toMillis(length)
+  def toNanos   = unit.toNanos(length)
+  def toMicros  = unit.toMicros(length)
+  def toMillis  = unit.toMillis(length)
   def toSeconds = unit.toSeconds(length)
   def toMinutes = unit.toMinutes(length)
-  def toHours = unit.toHours(length)
-  def toDays = unit.toDays(length)
+  def toHours   = unit.toHours(length)
+  def toDays    = unit.toDays(length)
   def toUnit(u: TimeUnit) = toNanos.toDouble / NANOSECONDS.convert(1, u)
 
-  override def toString = this match {
-    case Duration(1, DAYS)         => "1 day"
-    case Duration(x, DAYS)         => x + " days"
-    case Duration(1, HOURS)        => "1 hour"
-    case Duration(x, HOURS)        => x + " hours"
-    case Duration(1, MINUTES)      => "1 minute"
-    case Duration(x, MINUTES)      => x + " minutes"
-    case Duration(1, SECONDS)      => "1 second"
-    case Duration(x, SECONDS)      => x + " seconds"
-    case Duration(1, MILLISECONDS) => "1 millisecond"
-    case Duration(x, MILLISECONDS) => x + " milliseconds"
-    case Duration(1, MICROSECONDS) => "1 microsecond"
-    case Duration(x, MICROSECONDS) => x + " microseconds"
-    case Duration(1, NANOSECONDS)  => "1 nanosecond"
-    case Duration(x, NANOSECONDS)  => x + " nanoseconds"
-  }
-
-  def compare(other: Duration) =
-    if (other.finite_?) {
-      val me = toNanos
-      val o = other.toNanos
-      if (me > o) 1 else if (me < o) -1 else 0
-    } else -other.compare(this)
+  private def unitString = timeUnitName(unit) + ( if (length == 1) "" else "s" )
+  override def toString = "" + length + " " + unitString
 
-  def +(other: Duration) = {
-    if (!other.finite_?) {
-      other
-    } else {
-      val nanos = toNanos + other.asInstanceOf[FiniteDuration].toNanos
-      fromNanos(nanos)
-    }
+  def compare(other: Duration) = other match {
+    case x: FiniteDuration => toNanos compare x.toNanos
+    case _                 => -(other compare this)
   }
-
-  def -(other: Duration) = {
-    if (!other.finite_?) {
-      other
-    } else {
-      val nanos = toNanos - other.asInstanceOf[FiniteDuration].toNanos
-      fromNanos(nanos)
-    }
+  def +(other: Duration) = other match {
+    case x: FiniteDuration => fromNanos(toNanos + x.toNanos)
+    case _                 => other
+  }
+  def -(other: Duration) = other match {
+    case x: FiniteDuration => fromNanos(toNanos - x.toNanos)
+    case _                 => other
   }
 
   def *(factor: Double) = fromNanos(toNanos.toDouble * factor)
 
   def /(factor: Double) = fromNanos(toNanos.toDouble / factor)
 
-  def /(other: Duration) = if (other.finite_?) toNanos.toDouble / other.toNanos else 0
+  def /(other: Duration) = if (other.isFinite) toNanos.toDouble / other.toNanos else 0
 
   def unary_- = Duration(-length, unit)
 
-  def finite_? = true
-
-  override def equals(other: Any) =
-    other.isInstanceOf[FiniteDuration] &&
-      toNanos == other.asInstanceOf[FiniteDuration].toNanos
+  final def isFinite() = true
 
-  override def hashCode = toNanos.asInstanceOf[Int]
+  override def equals(other: Any) = other match {
+    case x: FiniteDuration => toNanos == x.toNanos
+    case _                 => super.equals(other)
+  }
+  override def hashCode = toNanos.toInt
 }
 
-class DurationInt(n: Int) {
+trait DurationConversions extends Any {
   import duration.Classifier
+  protected def durationIn(unit: TimeUnit): FiniteDuration
 
-  def nanoseconds = Duration(n, NANOSECONDS)
-  def nanos = Duration(n, NANOSECONDS)
-  def nanosecond = Duration(n, NANOSECONDS)
-  def nano = Duration(n, NANOSECONDS)
+  def nanoseconds  = durationIn(NANOSECONDS)
+  def nanos        = nanoseconds
+  def nanosecond   = nanoseconds
+  def nano         = nanoseconds
 
-  def microseconds = Duration(n, MICROSECONDS)
-  def micros = Duration(n, MICROSECONDS)
-  def microsecond = Duration(n, MICROSECONDS)
-  def micro = Duration(n, MICROSECONDS)
+  def microseconds = durationIn(MICROSECONDS)
+  def micros       = microseconds
+  def microsecond  = microseconds
+  def micro        = microseconds
 
-  def milliseconds = Duration(n, MILLISECONDS)
-  def millis = Duration(n, MILLISECONDS)
-  def millisecond = Duration(n, MILLISECONDS)
-  def milli = Duration(n, MILLISECONDS)
+  def milliseconds = durationIn(MILLISECONDS)
+  def millis       = milliseconds
+  def millisecond  = milliseconds
+  def milli        = milliseconds
 
-  def seconds = Duration(n, SECONDS)
-  def second = Duration(n, SECONDS)
+  def seconds      = durationIn(SECONDS)
+  def second       = seconds
 
-  def minutes = Duration(n, MINUTES)
-  def minute = Duration(n, MINUTES)
+  def minutes      = durationIn(MINUTES)
+  def minute       = minutes
 
-  def hours = Duration(n, HOURS)
-  def hour =  Duration(n, HOURS)
+  def hours        = durationIn(HOURS)
+  def hour         = hours
 
-  def days = Duration(n, DAYS)
-  def day = Duration(n, DAYS)
+  def days         = durationIn(DAYS)
+  def day          = days
 
-  def nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
-  def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
-  def nanosecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
-  def nano[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
+  def nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(nanoseconds)
+  def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = nanoseconds(c)
+  def nanosecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = nanoseconds(c)
+  def nano[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = nanoseconds(c)
 
-  def microseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
-  def micros[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
-  def microsecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
-  def micro[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
+  def microseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(microseconds)
+  def micros[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = microseconds(c)
+  def microsecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = microseconds(c)
+  def micro[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = microseconds(c)
 
-  def milliseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
-  def millis[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
-  def millisecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
-  def milli[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
+  def milliseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(milliseconds)
+  def millis[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = milliseconds(c)
+  def millisecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = milliseconds(c)
+  def milli[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = milliseconds(c)
 
-  def seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
-  def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
+  def seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(seconds)
+  def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = seconds(c)
 
-  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
-  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
+  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(minutes)
+  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = minutes(c)
 
-  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
-  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
+  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(hours)
+  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = hours(c)
 
-  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
-  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
+  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(days)
+  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = days(c)
 }
 
-class DurationLong(n: Long) {
-  import duration.Classifier
-
-  def nanoseconds = Duration(n, NANOSECONDS)
-  def nanos = Duration(n, NANOSECONDS)
-  def nanosecond = Duration(n, NANOSECONDS)
-  def nano = Duration(n, NANOSECONDS)
-
-  def microseconds = Duration(n, MICROSECONDS)
-  def micros = Duration(n, MICROSECONDS)
-  def microsecond = Duration(n, MICROSECONDS)
-  def micro = Duration(n, MICROSECONDS)
-
-  def milliseconds = Duration(n, MILLISECONDS)
-  def millis = Duration(n, MILLISECONDS)
-  def millisecond = Duration(n, MILLISECONDS)
-  def milli = Duration(n, MILLISECONDS)
-
-  def seconds = Duration(n, SECONDS)
-  def second = Duration(n, SECONDS)
-
-  def minutes = Duration(n, MINUTES)
-  def minute = Duration(n, MINUTES)
-
-  def hours = Duration(n, HOURS)
-  def hour = Duration(n, HOURS)
-
-  def days = Duration(n, DAYS)
-  def day = Duration(n, DAYS)
-
-  def nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
-  def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
-  def nanosecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
-  def nano[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
-
-  def microseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
-  def micros[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
-  def microsecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
-  def micro[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
-
-  def milliseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
-  def millis[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
-  def millisecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
-  def milli[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
-
-  def seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
-  def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
-
-  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
-  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
-
-  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
-  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
-
-  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
-  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
+final class DurationInt(val n: Int) extends AnyVal with DurationConversions {
+  override protected def durationIn(unit: TimeUnit): FiniteDuration = Duration(n, unit)
 }
 
-class DurationDouble(d: Double) {
-  import duration.Classifier
-
-  def nanoseconds = Duration(d, NANOSECONDS)
-  def nanos = Duration(d, NANOSECONDS)
-  def nanosecond = Duration(d, NANOSECONDS)
-  def nano = Duration(d, NANOSECONDS)
-
-  def microseconds = Duration(d, MICROSECONDS)
-  def micros = Duration(d, MICROSECONDS)
-  def microsecond = Duration(d, MICROSECONDS)
-  def micro = Duration(d, MICROSECONDS)
-
-  def milliseconds = Duration(d, MILLISECONDS)
-  def millis = Duration(d, MILLISECONDS)
-  def millisecond = Duration(d, MILLISECONDS)
-  def milli = Duration(d, MILLISECONDS)
-
-  def seconds = Duration(d, SECONDS)
-  def second = Duration(d, SECONDS)
-
-  def minutes = Duration(d, MINUTES)
-  def minute = Duration(d, MINUTES)
-
-  def hours = Duration(d, HOURS)
-  def hour = Duration(d, HOURS)
-
-  def days = Duration(d, DAYS)
-  def day = Duration(d, DAYS)
-
-  def nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, NANOSECONDS))
-  def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, NANOSECONDS))
-  def nanosecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, NANOSECONDS))
-  def nano[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, NANOSECONDS))
-
-  def microseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MICROSECONDS))
-  def micros[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MICROSECONDS))
-  def microsecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MICROSECONDS))
-  def micro[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MICROSECONDS))
-
-  def milliseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MILLISECONDS))
-  def millis[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MILLISECONDS))
-  def millisecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MILLISECONDS))
-  def milli[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MILLISECONDS))
-
-  def seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, SECONDS))
-  def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, SECONDS))
-
-  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MINUTES))
-  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MINUTES))
-
-  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, HOURS))
-  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, HOURS))
+final class DurationLong(val n: Long) extends AnyVal with DurationConversions {
+  override protected def durationIn(unit: TimeUnit): FiniteDuration = Duration(n, unit)
+}
 
-  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, DAYS))
-  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, DAYS))
+final class DurationDouble(val d: Double) extends AnyVal with DurationConversions {
+  override protected def durationIn(unit: TimeUnit): FiniteDuration = Duration(d, unit)
 }
diff --git a/test/files/jvm/duration-java.check b/test/files/jvm/duration-java.check
new file mode 100644
index 0000000000..7ae257dcc0
--- /dev/null
+++ b/test/files/jvm/duration-java.check
@@ -0,0 +1,362 @@
+          0.0 nanoseconds  =>  0 days
+          1.0 nanoseconds  =>  1 nanosecond
+          7.0 nanoseconds  =>  7 nanoseconds
+         10.0 nanoseconds  =>  10 nanoseconds
+         12.0 nanoseconds  =>  12 nanoseconds
+         24.0 nanoseconds  =>  24 nanoseconds
+         30.0 nanoseconds  =>  30 nanoseconds
+         49.0 nanoseconds  =>  49 nanoseconds
+         60.0 nanoseconds  =>  60 nanoseconds
+         70.0 nanoseconds  =>  70 nanoseconds
+         84.0 nanoseconds  =>  84 nanoseconds
+        100.0 nanoseconds  =>  100 nanoseconds
+        120.0 nanoseconds  =>  120 nanoseconds
+        144.0 nanoseconds  =>  144 nanoseconds
+        168.0 nanoseconds  =>  168 nanoseconds
+        210.0 nanoseconds  =>  210 nanoseconds
+        240.0 nanoseconds  =>  240 nanoseconds
+        288.0 nanoseconds  =>  288 nanoseconds
+        300.0 nanoseconds  =>  300 nanoseconds
+        360.0 nanoseconds  =>  360 nanoseconds
+        420.0 nanoseconds  =>  420 nanoseconds
+        576.0 nanoseconds  =>  576 nanoseconds
+        600.0 nanoseconds  =>  600 nanoseconds
+        700.0 nanoseconds  =>  700 nanoseconds
+        720.0 nanoseconds  =>  720 nanoseconds
+        900.0 nanoseconds  =>  900 nanoseconds
+       1000.0 nanoseconds  =>  1 microsecond
+       1200.0 nanoseconds  =>  1200 nanoseconds
+       1440.0 nanoseconds  =>  1440 nanoseconds
+       1800.0 nanoseconds  =>  1800 nanoseconds
+       2400.0 nanoseconds  =>  2400 nanoseconds
+       3000.0 nanoseconds  =>  3 microseconds
+       3600.0 nanoseconds  =>  3600 nanoseconds
+       6000.0 nanoseconds  =>  6 microseconds
+       7000.0 nanoseconds  =>  7 microseconds
+      10000.0 nanoseconds  =>  10 microseconds
+      12000.0 nanoseconds  =>  12 microseconds
+      24000.0 nanoseconds  =>  24 microseconds
+      30000.0 nanoseconds  =>  30 microseconds
+      60000.0 nanoseconds  =>  60 microseconds
+     100000.0 nanoseconds  =>  100 microseconds
+    1000000.0 nanoseconds  =>  1 millisecond
+    7000000.0 nanoseconds  =>  7 milliseconds
+        1.0E7 nanoseconds  =>  10 milliseconds
+        1.2E7 nanoseconds  =>  12 milliseconds
+        2.4E7 nanoseconds  =>  24 milliseconds
+        3.0E7 nanoseconds  =>  30 milliseconds
+        6.0E7 nanoseconds  =>  60 milliseconds
+        1.0E8 nanoseconds  =>  100 milliseconds
+        1.0E9 nanoseconds  =>  1 second
+       1.0E12 nanoseconds  =>  1000 seconds
+         0.0 microseconds  =>  0 days
+         1.0 microseconds  =>  1 microsecond
+         7.0 microseconds  =>  7 microseconds
+        10.0 microseconds  =>  10 microseconds
+        12.0 microseconds  =>  12 microseconds
+        24.0 microseconds  =>  24 microseconds
+        30.0 microseconds  =>  30 microseconds
+        49.0 microseconds  =>  49 microseconds
+        60.0 microseconds  =>  60 microseconds
+        70.0 microseconds  =>  70 microseconds
+        84.0 microseconds  =>  84 microseconds
+       100.0 microseconds  =>  100 microseconds
+       120.0 microseconds  =>  120 microseconds
+       144.0 microseconds  =>  144 microseconds
+       168.0 microseconds  =>  168 microseconds
+       210.0 microseconds  =>  210 microseconds
+       240.0 microseconds  =>  240 microseconds
+       288.0 microseconds  =>  288 microseconds
+       300.0 microseconds  =>  300 microseconds
+       360.0 microseconds  =>  360 microseconds
+       420.0 microseconds  =>  420 microseconds
+       576.0 microseconds  =>  576 microseconds
+       600.0 microseconds  =>  600 microseconds
+       700.0 microseconds  =>  700 microseconds
+       720.0 microseconds  =>  720 microseconds
+       900.0 microseconds  =>  900 microseconds
+      1000.0 microseconds  =>  1 millisecond
+      1200.0 microseconds  =>  1200 microseconds
+      1440.0 microseconds  =>  1440 microseconds
+      1800.0 microseconds  =>  1800 microseconds
+      2400.0 microseconds  =>  2400 microseconds
+      3000.0 microseconds  =>  3 milliseconds
+      3600.0 microseconds  =>  3600 microseconds
+      6000.0 microseconds  =>  6 milliseconds
+      7000.0 microseconds  =>  7 milliseconds
+     10000.0 microseconds  =>  10 milliseconds
+     12000.0 microseconds  =>  12 milliseconds
+     24000.0 microseconds  =>  24 milliseconds
+     30000.0 microseconds  =>  30 milliseconds
+     60000.0 microseconds  =>  60 milliseconds
+    100000.0 microseconds  =>  100 milliseconds
+   1000000.0 microseconds  =>  1 second
+   7000000.0 microseconds  =>  7 seconds
+       1.0E7 microseconds  =>  10 seconds
+       1.2E7 microseconds  =>  12 seconds
+       2.4E7 microseconds  =>  24 seconds
+       3.0E7 microseconds  =>  30 seconds
+       6.0E7 microseconds  =>  1 minute
+       1.0E8 microseconds  =>  100 seconds
+       1.0E9 microseconds  =>  1000 seconds
+      1.0E12 microseconds  =>  1000000 seconds
+         0.0 milliseconds  =>  0 days
+         1.0 milliseconds  =>  1 millisecond
+         7.0 milliseconds  =>  7 milliseconds
+        10.0 milliseconds  =>  10 milliseconds
+        12.0 milliseconds  =>  12 milliseconds
+        24.0 milliseconds  =>  24 milliseconds
+        30.0 milliseconds  =>  30 milliseconds
+        49.0 milliseconds  =>  49 milliseconds
+        60.0 milliseconds  =>  60 milliseconds
+        70.0 milliseconds  =>  70 milliseconds
+        84.0 milliseconds  =>  84 milliseconds
+       100.0 milliseconds  =>  100 milliseconds
+       120.0 milliseconds  =>  120 milliseconds
+       144.0 milliseconds  =>  144 milliseconds
+       168.0 milliseconds  =>  168 milliseconds
+       210.0 milliseconds  =>  210 milliseconds
+       240.0 milliseconds  =>  240 milliseconds
+       288.0 milliseconds  =>  288 milliseconds
+       300.0 milliseconds  =>  300 milliseconds
+       360.0 milliseconds  =>  360 milliseconds
+       420.0 milliseconds  =>  420 milliseconds
+       576.0 milliseconds  =>  576 milliseconds
+       600.0 milliseconds  =>  600 milliseconds
+       700.0 milliseconds  =>  700 milliseconds
+       720.0 milliseconds  =>  720 milliseconds
+       900.0 milliseconds  =>  900 milliseconds
+      1000.0 milliseconds  =>  1 second
+      1200.0 milliseconds  =>  1200 milliseconds
+      1440.0 milliseconds  =>  1440 milliseconds
+      1800.0 milliseconds  =>  1800 milliseconds
+      2400.0 milliseconds  =>  2400 milliseconds
+      3000.0 milliseconds  =>  3 seconds
+      3600.0 milliseconds  =>  3600 milliseconds
+      6000.0 milliseconds  =>  6 seconds
+      7000.0 milliseconds  =>  7 seconds
+     10000.0 milliseconds  =>  10 seconds
+     12000.0 milliseconds  =>  12 seconds
+     24000.0 milliseconds  =>  24 seconds
+     30000.0 milliseconds  =>  30 seconds
+     60000.0 milliseconds  =>  1 minute
+    100000.0 milliseconds  =>  100 seconds
+   1000000.0 milliseconds  =>  1000 seconds
+   7000000.0 milliseconds  =>  7000 seconds
+       1.0E7 milliseconds  =>  10000 seconds
+       1.2E7 milliseconds  =>  200 minutes
+       2.4E7 milliseconds  =>  400 minutes
+       3.0E7 milliseconds  =>  500 minutes
+       6.0E7 milliseconds  =>  1000 minutes
+       1.0E8 milliseconds  =>  100000 seconds
+       1.0E9 milliseconds  =>  1000000 seconds
+      1.0E12 milliseconds  =>  1000000000 seconds
+              0.0 seconds  =>  0 days
+              1.0 seconds  =>  1 second
+              7.0 seconds  =>  7 seconds
+             10.0 seconds  =>  10 seconds
+             12.0 seconds  =>  12 seconds
+             24.0 seconds  =>  24 seconds
+             30.0 seconds  =>  30 seconds
+             49.0 seconds  =>  49 seconds
+             60.0 seconds  =>  1 minute
+             70.0 seconds  =>  70 seconds
+             84.0 seconds  =>  84 seconds
+            100.0 seconds  =>  100 seconds
+            120.0 seconds  =>  2 minutes
+            144.0 seconds  =>  144 seconds
+            168.0 seconds  =>  168 seconds
+            210.0 seconds  =>  210 seconds
+            240.0 seconds  =>  4 minutes
+            288.0 seconds  =>  288 seconds
+            300.0 seconds  =>  5 minutes
+            360.0 seconds  =>  6 minutes
+            420.0 seconds  =>  7 minutes
+            576.0 seconds  =>  576 seconds
+            600.0 seconds  =>  10 minutes
+            700.0 seconds  =>  700 seconds
+            720.0 seconds  =>  12 minutes
+            900.0 seconds  =>  15 minutes
+           1000.0 seconds  =>  1000 seconds
+           1200.0 seconds  =>  20 minutes
+           1440.0 seconds  =>  24 minutes
+           1800.0 seconds  =>  30 minutes
+           2400.0 seconds  =>  40 minutes
+           3000.0 seconds  =>  50 minutes
+           3600.0 seconds  =>  1 hour
+           6000.0 seconds  =>  100 minutes
+           7000.0 seconds  =>  7000 seconds
+          10000.0 seconds  =>  10000 seconds
+          12000.0 seconds  =>  200 minutes
+          24000.0 seconds  =>  400 minutes
+          30000.0 seconds  =>  500 minutes
+          60000.0 seconds  =>  1000 minutes
+         100000.0 seconds  =>  100000 seconds
+        1000000.0 seconds  =>  1000000 seconds
+        7000000.0 seconds  =>  7000000 seconds
+            1.0E7 seconds  =>  10000000 seconds
+            1.2E7 seconds  =>  200000 minutes
+            2.4E7 seconds  =>  400000 minutes
+            3.0E7 seconds  =>  500000 minutes
+            6.0E7 seconds  =>  1000000 minutes
+            1.0E8 seconds  =>  100000000 seconds
+            1.0E9 seconds  =>  1000000000 seconds
+           1.0E12 seconds  =>  9223372036854775807 nanoseconds
+              0.0 minutes  =>  0 days
+              1.0 minutes  =>  1 minute
+              7.0 minutes  =>  7 minutes
+             10.0 minutes  =>  10 minutes
+             12.0 minutes  =>  12 minutes
+             24.0 minutes  =>  24 minutes
+             30.0 minutes  =>  30 minutes
+             49.0 minutes  =>  49 minutes
+             60.0 minutes  =>  1 hour
+             70.0 minutes  =>  70 minutes
+             84.0 minutes  =>  84 minutes
+            100.0 minutes  =>  100 minutes
+            120.0 minutes  =>  2 hours
+            144.0 minutes  =>  144 minutes
+            168.0 minutes  =>  168 minutes
+            210.0 minutes  =>  210 minutes
+            240.0 minutes  =>  4 hours
+            288.0 minutes  =>  288 minutes
+            300.0 minutes  =>  5 hours
+            360.0 minutes  =>  6 hours
+            420.0 minutes  =>  7 hours
+            576.0 minutes  =>  576 minutes
+            600.0 minutes  =>  10 hours
+            700.0 minutes  =>  700 minutes
+            720.0 minutes  =>  12 hours
+            900.0 minutes  =>  15 hours
+           1000.0 minutes  =>  1000 minutes
+           1200.0 minutes  =>  20 hours
+           1440.0 minutes  =>  1 day
+           1800.0 minutes  =>  30 hours
+           2400.0 minutes  =>  40 hours
+           3000.0 minutes  =>  50 hours
+           3600.0 minutes  =>  60 hours
+           6000.0 minutes  =>  100 hours
+           7000.0 minutes  =>  7000 minutes
+          10000.0 minutes  =>  10000 minutes
+          12000.0 minutes  =>  200 hours
+          24000.0 minutes  =>  400 hours
+          30000.0 minutes  =>  500 hours
+          60000.0 minutes  =>  1000 hours
+         100000.0 minutes  =>  100000 minutes
+        1000000.0 minutes  =>  1000000 minutes
+        7000000.0 minutes  =>  7000000 minutes
+            1.0E7 minutes  =>  10000000 minutes
+            1.2E7 minutes  =>  200000 hours
+            2.4E7 minutes  =>  400000 hours
+            3.0E7 minutes  =>  500000 hours
+            6.0E7 minutes  =>  1000000 hours
+            1.0E8 minutes  =>  100000000 minutes
+            1.0E9 minutes  =>  9223372036854775807 nanoseconds
+           1.0E12 minutes  =>  9223372036854775807 nanoseconds
+                0.0 hours  =>  0 days
+                1.0 hours  =>  1 hour
+                7.0 hours  =>  7 hours
+               10.0 hours  =>  10 hours
+               12.0 hours  =>  12 hours
+               24.0 hours  =>  1 day
+               30.0 hours  =>  30 hours
+               49.0 hours  =>  49 hours
+               60.0 hours  =>  60 hours
+               70.0 hours  =>  70 hours
+               84.0 hours  =>  84 hours
+              100.0 hours  =>  100 hours
+              120.0 hours  =>  5 days
+              144.0 hours  =>  6 days
+              168.0 hours  =>  7 days
+              210.0 hours  =>  210 hours
+              240.0 hours  =>  10 days
+              288.0 hours  =>  12 days
+              300.0 hours  =>  300 hours
+              360.0 hours  =>  15 days
+              420.0 hours  =>  420 hours
+              576.0 hours  =>  24 days
+              600.0 hours  =>  25 days
+              700.0 hours  =>  700 hours
+              720.0 hours  =>  30 days
+              900.0 hours  =>  900 hours
+             1000.0 hours  =>  1000 hours
+             1200.0 hours  =>  50 days
+             1440.0 hours  =>  60 days
+             1800.0 hours  =>  75 days
+             2400.0 hours  =>  100 days
+             3000.0 hours  =>  125 days
+             3600.0 hours  =>  150 days
+             6000.0 hours  =>  250 days
+             7000.0 hours  =>  7000 hours
+            10000.0 hours  =>  10000 hours
+            12000.0 hours  =>  500 days
+            24000.0 hours  =>  1000 days
+            30000.0 hours  =>  1250 days
+            60000.0 hours  =>  2500 days
+           100000.0 hours  =>  100000 hours
+          1000000.0 hours  =>  1000000 hours
+          7000000.0 hours  =>  9223372036854775807 nanoseconds
+              1.0E7 hours  =>  9223372036854775807 nanoseconds
+              1.2E7 hours  =>  9223372036854775807 nanoseconds
+              2.4E7 hours  =>  9223372036854775807 nanoseconds
+              3.0E7 hours  =>  9223372036854775807 nanoseconds
+              6.0E7 hours  =>  9223372036854775807 nanoseconds
+              1.0E8 hours  =>  9223372036854775807 nanoseconds
+              1.0E9 hours  =>  9223372036854775807 nanoseconds
+             1.0E12 hours  =>  9223372036854775807 nanoseconds
+                 0.0 days  =>  0 days
+                 1.0 days  =>  1 day
+                 7.0 days  =>  7 days
+                10.0 days  =>  10 days
+                12.0 days  =>  12 days
+                24.0 days  =>  24 days
+                30.0 days  =>  30 days
+                49.0 days  =>  49 days
+                60.0 days  =>  60 days
+                70.0 days  =>  70 days
+                84.0 days  =>  84 days
+               100.0 days  =>  100 days
+               120.0 days  =>  120 days
+               144.0 days  =>  144 days
+               168.0 days  =>  168 days
+               210.0 days  =>  210 days
+               240.0 days  =>  240 days
+               288.0 days  =>  288 days
+               300.0 days  =>  300 days
+               360.0 days  =>  360 days
+               420.0 days  =>  420 days
+               576.0 days  =>  576 days
+               600.0 days  =>  600 days
+               700.0 days  =>  700 days
+               720.0 days  =>  720 days
+               900.0 days  =>  900 days
+              1000.0 days  =>  1000 days
+              1200.0 days  =>  1200 days
+              1440.0 days  =>  1440 days
+              1800.0 days  =>  1800 days
+              2400.0 days  =>  2400 days
+              3000.0 days  =>  3000 days
+              3600.0 days  =>  3600 days
+              6000.0 days  =>  6000 days
+              7000.0 days  =>  7000 days
+             10000.0 days  =>  10000 days
+             12000.0 days  =>  12000 days
+             24000.0 days  =>  24000 days
+             30000.0 days  =>  30000 days
+             60000.0 days  =>  60000 days
+            100000.0 days  =>  100000 days
+           1000000.0 days  =>  9223372036854775807 nanoseconds
+           7000000.0 days  =>  9223372036854775807 nanoseconds
+               1.0E7 days  =>  9223372036854775807 nanoseconds
+               1.2E7 days  =>  9223372036854775807 nanoseconds
+               2.4E7 days  =>  9223372036854775807 nanoseconds
+               3.0E7 days  =>  9223372036854775807 nanoseconds
+               6.0E7 days  =>  9223372036854775807 nanoseconds
+               1.0E8 days  =>  9223372036854775807 nanoseconds
+               1.0E9 days  =>  9223372036854775807 nanoseconds
+              1.0E12 days  =>  9223372036854775807 nanoseconds
+                      Inf  =>  Duration.Inf
+                     -Inf  =>  Duration.MinusInf
+                     +Inf  =>  Duration.Inf
+                  PlusInf  =>  Duration.Inf
+                 MinusInf  =>  Duration.MinusInf
diff --git a/test/files/jvm/duration-java/Test.java b/test/files/jvm/duration-java/Test.java
new file mode 100644
index 0000000000..02feb522b8
--- /dev/null
+++ b/test/files/jvm/duration-java/Test.java
@@ -0,0 +1,38 @@
+import scala.concurrent.util.Duration;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import static java.util.concurrent.TimeUnit.*;
+
+public class Test {
+  public static List<Double> inputs = Arrays.asList(0d, 1d, 7d, 10d, 12d, 24d, 30d, 60d, 100d, 1000d, 1e6);
+  public static List<Double> makeNumbers() {
+    ArrayList<Double> xs = new ArrayList<Double>();
+    for (Double n1: inputs) {
+      for (Double n2: inputs) {
+        Double n = n1 * n2;
+        if (!xs.contains(n))
+          xs.add(n);
+      }
+    }
+    Double[] arr = xs.toArray(new Double[0]);
+    Arrays.sort(arr);
+    return Arrays.asList(arr);
+  }
+
+  public static void p(Object x) {
+    System.out.println(x);
+  }
+  public static void main(String[] args) {
+    for (TimeUnit t : TimeUnit.values()) {
+      for (Double n: makeNumbers()) {
+        String s = "" + n + " " + t.toString().toLowerCase();
+        Duration d = Duration.create(n, t);
+        p(String.format("%25s  =>  %s", s, d));
+      }
+    }
+    for (String s: Arrays.asList("Inf", "-Inf", "+Inf", "PlusInf", "MinusInf")) {
+      Duration d = Duration.create(s);
+      p(String.format("%25s  =>  %s", s, d));
+    }
+  }
+}