/ - Diff - Aquarium - Greek Research and Technology Network's projects

     import gr.grnet.aquarium.util.yaml._
     import java.util.Date
     import java.io.{ByteArrayInputStream, InputStreamReader, InputStream}
     import gr.grnet.aquarium.logic.accounting.dsl.DSLTimeSpec
     /**
      * A parser for the Aquarium accounting DSL.
-...
         } catch {
           case e => throw new DSLParseException("Error parsing cron string: " + e.getMessage)
+        }
         def splitMultiVals(input: String): List[Int] = {
         def splitMultiVals(ii : Int): List[Int] = {
           val input = cron.get(ii).toString
           if (input.equals("*"))
             return (-1).until(0).toList
           if (input.contains('-')) {
             (-1).until(0).toList
           else if (input.contains('-')) {
             val ints = input.split('-')
             ints(0).toInt.until(ints(1).toInt + 1).toList
           } else if (input.contains(',')) {
             input.split(',').map{i => i.toInt}.toList
           } else {
           } else if (input.contains(','))
             input.split(',').map(_.toInt).toList
            else
             input.toInt.until(input.toInt + 1).toList
+          }
+        }
         splitMultiVals(cron.get(0).toString).map(
           a => splitMultiVals(cron.get(1).toString).map(
             b => splitMultiVals(cron.get(2).toString).map(
               c => splitMultiVals(cron.get(3).toString).map(
                 d => splitMultiVals(cron.get(4).toString).map(
                   e => DSLTimeSpec(a, b, c, d, e)
+                )
               ).flatten
             ).flatten
           ).flatten
         ).flatten.toList
         for { a <- splitMultiVals(0)
               b <- splitMultiVals(1)
               c <- splitMultiVals(2)
               d <- splitMultiVals(3)
               e <- splitMultiVals(4)  } yield
           DSLTimeSpec(a,b,c,d,e)
+      }
+    }

     package gr.grnet.aquarium.logic.accounting.dsl
     import java.util.Date
     /**
      * A DSL time bounded item whose effectivity is constrained by well defined time bounds.
      * All time bounded items also support inheritance.
-...
                                                                   val effective: DSLTimeFrame)
     extends DSLItem {
       def toTimeslot : Timeslot = Timeslot(effective.from,effective.to.getOrElse(new Date(Long.MaxValue)))
       override def toMap(): Map[String, Any] = {
         val data = new scala.collection.mutable.HashMap[String, Any]()
         data +=  ("name" -> name)

     package gr.grnet.aquarium.logic.accounting.dsl
     import java.util.Calendar
     import java.util.{GregorianCalendar, Date, Calendar}
     import collection.mutable
     /**
      * Represents an instance of an expanded cronstring declaration. Enforces,
-...
+     *
      * @author Georgios Gousios <gousiosg@gmail.com>
      */
     case class DSLTimeSpec(
       min: Int,
       hour: Int,
       dom: Int,
       mon: Int,
       dow: Int
     ) extends DSLItem {
       case class DSLTimeSpec(
         min: Int,
         hour: Int,
         dom: Int,
         mon: Int,
         dow: Int
       ) extends DSLItem {
       //Preconditions to force correct values on object creation
       assert(0 <= min && 60 > min)
       assert(0 <= hour && 24 > hour)
-...
       assert(-1 <= mon && 12 > mon && mon != 0)
       assert(-1 <= dow && 7 > dow)
       def expandTimeSpec(from: Date,  to: Date) : List[Date] = {
         val c = new GregorianCalendar()
         c.setTime { /*adjust time given from "from" variable  */
           c.setTime(from)
           c.set(Calendar.MINUTE,this.min)
           c.set(Calendar.HOUR_OF_DAY,this.hour)
           /*if(c.getTimeInMillis < from.getTime) {
             //c.add(Calendar.DAY_OF_YEAR, 1)
            // assert(c.getTimeInMillis >= from.getTime,c.getTime + " >=" + from) /* sanity check */
           }*/
           c.getTime
+       }
        def equals () : Boolean =
           (this.mon < 0  || c.get(Calendar.MONTH) == this.getCalendarMonth()) &&
           (this.dom < 0  || c.get(Calendar.DAY_OF_MONTH) == this.dom) &&
           (this.dow < 0  || c.get(Calendar.DAY_OF_WEEK) == this.getCalendarDow())
         val result = new mutable.ListBuffer[Date]()
         //Console.err.println("\n\nBEGIN\n\n")
         while (c.getTimeInMillis <= to.getTime) {
           val b : Boolean = equals
           //Console.err.println(c.getTime +  "\t\t"  + to + " ==>" + (if(b) "YES" else "NO"))
           if (b) result += new Date(c.getTime.getTime)
           c.add(Calendar.DAY_OF_YEAR, 1)
+        }
         //Console.err.println("\n\nEND\n\n")
         result.toList
+      }
       /** Day of week conversions to stay compatible with [[java.util.Calendar]] */
       def getCalendarDow(): Int = dow match {
       private def getCalendarDow(): Int = dow match {
         case 0 => Calendar.SUNDAY
         case 1 => Calendar.MONDAY
         case 2 => Calendar.TUESDAY
-...
+      }
       /** Month conversions to stay compatible with [[java.util.Calendar]] */
       def getCalendarMonth(): Int = mon match {
       private def getCalendarMonth(): Int = mon match {
         case 1 => Calendar.JANUARY
         case 2 => Calendar.FEBRUARY
         case 3 => Calendar.MARCH

     import gr.grnet.aquarium.util.DateUtils
     import java.util.{Date, GregorianCalendar, Calendar}
     import scala.collection.immutable
     import java.util
     /**
      * Utility functions to use when working with DSL types.
-...
     trait DSLUtils extends DateUtils {
       val maxdate = new Date(Int.MaxValue * 1000L)
       val mindate = new Date(0)
       /**
        * Resolves the effective algorithm for each chunk of the
-...
       def resolveEffectiveAlgorithmsForTimeslot(timeslot: Timeslot,
                                                agr: DSLAgreement):
       immutable.SortedMap[Timeslot, DSLAlgorithm] =
         resolveEffective[DSLAlgorithm](timeslot, Some(agr.algorithm))
         resolveEffective[DSLAlgorithm](timeslot, agr.algorithm)
       /**
        * Resolves the effective price list for each chunk of the
-...
       def resolveEffectivePricelistsForTimeslot(timeslot: Timeslot,
                                                 agr: DSLAgreement):
       immutable.SortedMap[Timeslot, DSLPriceList] =
         resolveEffective[DSLPriceList](timeslot, Some(agr.pricelist))
         resolveEffective[DSLPriceList](timeslot,agr.pricelist)
       /**
        * Splits the provided timeslot into chunks according to the validity
-...
        * returns a map whose keys are the timeslot chunks and the values
        * correspond to the effective time bounded item (algorithm or pricelist).
        */
       def resolveEffective[T <: DSLTimeBoundedItem[T]](timeslot: Timeslot,
                                                        tbi: Option[T]):
       def resolveEffective[T <: DSLTimeBoundedItem[T]](timeslot: Timeslot,policy: T):
       immutable.SortedMap[Timeslot, T] = {
         val policy = tbi match {
           case None => return immutable.SortedMap[Timeslot, T]()
           case _ => tbi.get
+        }
         // The following check that the policy is applicable within
         // the timeframe of the requested resolution
         assert(timeslot.to.before(policy.effective.to.getOrElse(maxdate)),
           "Policy effectivity ends before expansion timeslot")
         assert(timeslot.from.after(policy.effective.from),
           "Policy effectivity starts after expansion timeslot")
         val eff = allEffectiveTimeslots(policy.effective,
           Timeslot(oneYearBack(timeslot.from, policy.effective.from),
           oneYearAhead (timeslot.to, policy.effective.to.getOrElse(maxdate))))
     //    logger.debug("effective timeslots: %d".format(eff.size))
         immutable.SortedMap[Timeslot, T]() ++
           timeslot.overlappingTimeslots(eff).flatMap {
             t => Map(t -> policy)
           assert(policy.toTimeslot contains timeslot,"Policy does not contain timeslot")
          /* Get a list of all effective/expanded policy timeslots within
             a timeslot specified by "variable timeslot".
           * NOTICE: The returned timeslots may be slightly out of "timeslot" bounds
           *         so we need to invoke overlappingTimeslots and nonOverlapping timeslots
           */
          val all_timeslots = allEffectiveTimeslots(policy.effective,timeslot)
          val timeslots_IN_policy = timeslot.overlappingTimeslots(all_timeslots)
          val timeslots_NOT_IN_policy = timeslot.nonOverlappingTimeslots(all_timeslots)
           immutable.SortedMap[Timeslot, T]() ++
           /*add [timeslots -> policy] covered by this policy*/
           timeslots_IN_policy.flatMap {
              effective_timeslot => Map(effective_timeslot -> policy)
           } ++
           timeslot.nonOverlappingTimeslots(eff).flatMap {
             t => resolveEffective(t, policy.overrides)
           /*add [timeslots -> policy] covered by parent policies */
           timeslots_NOT_IN_policy.flatMap { /* search the policy hierarchy for effective timeslots not covered by this policy.*/
             not_effective_timeslot => policy.overrides match {
               case None => immutable.SortedMap[Timeslot, T]() /*Nothing to do. TODO: throw exception ?*/
               case Some(parent_policy) => resolveEffective(not_effective_timeslot,parent_policy) /* search the policy hierarchy*/
+            }
+          }
+      }
       /**
        * Get a list of timeslots within which a timeframe is not effective.
        */
       def ineffectiveTimeslots(spec: DSLTimeFrameRepeat, from: Date, to: Option[Date]):
         List[Timeslot] = {
         buildNotEffectiveList(effectiveTimeslots(spec, from, to)) sortWith sorter
+      }
       private def buildNotEffectiveList(l :List[Timeslot]) :
         List[Timeslot] = {
         if (l.isEmpty) return List()
         if (l.tail.isEmpty) return List()
         assert(l.head.to.getTime < l.tail.head.from.getTime)
         Timeslot(new Date(l.head.to.getTime + 1),
           new Date(l.tail.head.from.getTime - 1)) :: buildNotEffectiveList(l.tail)
+      }
       /**
        * Merges overlapping timeslots. The merge is exhaustive only if the
        * provided list is sorted in increasing timeslot from order.
        * Utility function to put timeslots in increasing start timestamp order
        */
       def mergeOverlaps(list: List[Timeslot]): List[Timeslot] =
         list.foldLeft(List[Timeslot]()) {
           (a, b) =>
             if (a.isEmpty)
               List(b)
             else if (a.tail.isEmpty)
               a.head.merge(b)
             else {
               val merged = a.tail.head.merge(b)
               a ++ (if (merged.size == 1) merged else List(b))
+            }
+        }
       /**
        * Get a list of all timeslots within which the provided time frame
        * is effective.
        */
       def allEffectiveTimeslots(spec: DSLTimeFrame):
       List[Timeslot] = {
         val l = spec.repeat.flatMap {
           r => effectiveTimeslots(r, spec.from, spec.to)
         } sortWith sorter
         mergeOverlaps(l)
+      }
       private def sorter(x: Timeslot, y: Timeslot) : Boolean =   y.from after x.from
       /**
        * Get a list of all timeslots within which a timeframe
        * is effective, whithin the provided time bounds.
        */
       def allEffectiveTimeslots(spec: DSLTimeFrame, t: Timeslot):
       List[Timeslot] = {
         //A timeframe with no repetition defined
         if (spec.repeat.isEmpty) {
       List[Timeslot] =
         if (spec.repeat.isEmpty) { //A  simple timeframe with no repetition defined
           val fromDate = if (spec.from.before(t.from)) t.from else spec.from
           val toDate = if (spec.to.getOrElse(t.to).after(t.to)) t.to else spec.to.getOrElse(t.to)
           return List(Timeslot(fromDate, toDate))
+        }
         val l = spec.repeat.flatMap {
           r => effectiveTimeslots(r, t.from, Some(t.to))
         } sortWith sorter
         mergeOverlaps(l)
+      }
           List(Timeslot(fromDate, toDate))
         } /* otherwise for all repetitions determine timeslots*/
         else mergeOverlaps(for { r <- spec.repeat
                                 ts <- effectiveTimeslots(r, t.from, t.to) }
                            yield ts)
       /**
        * Get a list of all timeslots within which a time frame is active.
        * If the to date is None, the expansion takes place within a timeframe
        * between `from .. from` + 1 year. The result is returned sorted by
        * timeframe start date.
        * Merges overlapping timeslots.
        */
       def effectiveTimeslots(spec: DSLTimeFrameRepeat, from: Date, to: Option[Date]):
         List[Timeslot] = {
         val endDate = to match {
           case None => //One year from now
             val c = new GregorianCalendar()
             c.setTime(from)
             c.add(Calendar.YEAR, 1)
             c.getTime
           case Some(y) => y
+        }
       private[logic] def mergeOverlaps(list: List[Timeslot]): List[Timeslot] =
         (list sortWith sorter).foldLeft(List[Timeslot]()) {
           case (Nil,b) =>
             List(b)
           case (hd::Nil,b) =>
             if (hd overlaps  b) (hd merge b)::Nil
             else b::hd::Nil
           case (a @ hd::tl,b) =>
             if(hd overlaps b) (hd merge b)::tl
             else b :: a
           }.reverse
         coExpandTimespecs(spec.start.zip(spec.end), from, endDate) sortWith sorter
+      }
       /**
        * Utility function to put timeslots in increasing start timestamp order
        */
       def sorter(x: Timeslot, y: Timeslot) : Boolean =
         if (y.from after x.from) true else false
       /**
        * Calculate periods of activity for a list of timespecs
        */
       private def coExpandTimespecs(input: List[(DSLTimeSpec, DSLTimeSpec)],
                                     from: Date, to: Date): List[Timeslot] = {
         if (input.size == 0) return List()
         expandTimeSpec(input.head._1, from, to).zip(
           expandTimeSpec(input.head._2, from, to)).map(
             l => Timeslot(l._1, l._2)
           ) ++
           coExpandTimespecs(input.tail, from, to)
+      }
       /**
        * Expand a List of timespecs.
        */
       def expandTimeSpecs(spec: List[DSLTimeSpec], from: Date,  to: Date):
         List[Date] =
         spec.flatMap { t => expandTimeSpec(t, from, to)}
       /**
        * Get the list of time points prescribed by the provided timespec,
        * within the timeframe between from and to.
        * Get a list of all timeslots within which a time frame is active.
          The result is returned sorted by timeframe start date.
        */
       def expandTimeSpec(spec: DSLTimeSpec, from: Date,  to: Date) : List[Date] = {
         val adjusted = adjustToTime(from, spec.hour, spec.min)
         findDays(adjusted, to, {
           c =>
             (if (spec.mon >= 0) {c.get(Calendar.MONTH) == spec.getCalendarMonth()} else true) &&
             (if (spec.dom >= 0) {c.get(Calendar.DAY_OF_MONTH) == spec.dom} else true) &&
             (if (spec.dow >= 0) {c.get(Calendar.DAY_OF_WEEK) == spec.getCalendarDow()} else true)
         })
+      }
       def effectiveTimeslots(spec: DSLTimeFrameRepeat, from: Date, to : Date):
         List[Timeslot] =
           for { (h1,h2) <- spec.start zip spec.end
                 (d1,d2) <- h1.expandTimeSpec(from, to) zip h2.expandTimeSpec(from, to)
+              }
           yield Timeslot(d1,d2)
+    }

     import scala.collection.mutable
     import annotation.tailrec
     import gr.grnet.aquarium.util.date.MutableDateCalc
     import gr.grnet.aquarium.logic.accounting.dsl.Timeslot
     /**
      * A representation of a timeslot with a start and end date.
-...
       assert(to != null)
       assert(from.before(to), "from = %s, to = %s".format(new MutableDateCalc(from), new MutableDateCalc(to)))
       def startsBefore(t: Timeslot) : Boolean = this.from.before(t.from)
       def startsBefore(t: Timeslot) : Boolean =  start < t.start
       def startsAfter(t: Timeslot) : Boolean = this.from.after(t.from)
       def startsAfter(t: Timeslot) : Boolean =   start > t.start
       def endsBefore(t: Timeslot) : Boolean = this.to.before(t.to)
       def endsBefore(t: Timeslot) : Boolean = end < t.end
       def endsAfter(t: Timeslot) : Boolean = this.to.after(t.to)
       def endsAfter(t: Timeslot) : Boolean =  end > t.end
       def after(t: Timeslot): Boolean = if (this.from.after(t.to)) true else false
       def after(t: Timeslot): Boolean =  start > t.end
       def before(t: Timeslot): Boolean = if (this.to.before(t.from)) true else false
       def before(t: Timeslot): Boolean = end < t.start
       def start : Long =  this.from.getTime
       def end : Long =  this.to.getTime
       /**
        * Check whether this time slot fully contains the provided one.
        */
       def contains(t: Timeslot) : Boolean = {
         if (this.from.getTime <= t.from.getTime &&
           this.to.getTime >= t.to.getTime)
           return true
         return false
+      }
       def contains(t: Timeslot) : Boolean = this.start <= t.start && this.end >= t.end
       def containsTimeInMillis(millis: Long) =  start <= millis && millis <= end
       def containsTimeInMillis(millis: Long) = {
         fromMillis <= millis && millis <= toMillis
+      }
       /**
        * Check whether this timeslot contains the provided time instant.
        */
       def includes(t: Date) : Boolean =
         if (from.before(t) && to.after(t)) true else false
       private def includes(t: Date) : Boolean = start <= t.getTime &&  t.getTime <= end
       /**
        * Check whether this timeslot overlaps with the provided one.
        */
       def overlaps(t: Timeslot) : Boolean = {
         if (contains(t) || t.contains(this))
           return true
         if (this.includes(t.from) || this.includes(t.to))
           return true
       def overlaps(t: Timeslot) : Boolean =
         contains(t) || t.contains(this) || this.includes(t.from) || this.includes(t.to)
         false
+      }
       /**
        * Merges this timeslot with the provided one. If the timeslots overlap,
-...
          * overlap, the returned list contains both timeslots in increasing start
        * date order.
        */
       def merge(t: Timeslot) : List[Timeslot] = {
         if (overlaps(t)) {
           val nfrom = if (from.before(t.from)) from else t.from
           val nto   = if (to.after(t.to)) to else t.to
           List(Timeslot(nfrom, nto))
         } else
           if (this.from.before(t.from))
             List(this, t)
           else
             List(t, this)
       def merge(t: Timeslot) : Timeslot  = {
        assert(overlaps(t),this +" has no overlap with " + t)
        val nfrom = if (start < t.start) from else t.from
        val nto   = if (end > t.end) to else t.to
        Timeslot(nfrom, nto)
+      }
       /**
        * Split the timeslot in two parts at the provided timestamp, if the
        * timestamp falls within the timeslot boundaries.
        */
       def slice(d: Date) : List[Timeslot] =
         if (includes(d))
        def slice(d: Date) : List[Timeslot] =
         if (includes(d) && d.getTime != start && d.getTime != end)
           List(Timeslot(from, d), Timeslot(d,to))
         else
           List(this)
       /**
        * Find and return the timeslots within which this Timeslot overrides
        * with the provided list of timeslots. For example if:
-...
+       *
        * the result will be: `List(Timeslot(7,8), Timeslot(11,15))`
        */
       def overlappingTimeslots(list: List[Timeslot]) : List[Timeslot] = {
       def overlappingTimeslots(list: List[Timeslot]) : List[Timeslot] =
         list.foldLeft(List[Timeslot]()) { (ret,t) =>
           if (t.contains(this)) this :: ret
           else if (this.contains(t)) t :: ret
           else if (t.overlaps(this) && t.startsBefore(this)) slice(t.to).head :: ret
           else if (t.overlaps(this) && t.startsAfter(this))  slice(t.from).last :: ret
           else ret
         }.reverse
         val result = new mutable.ListBuffer[Timeslot]()
         list.foreach {
           t =>
             if (t.contains(this)) result += this
             else if (this.contains(t)) result += t
             else if (t.overlaps(this) && t.startsBefore(this)) result += this.slice(t.to).head
             else if (t.overlaps(this) && t.startsAfter(this)) result += this.slice(t.from).last
+        }
         result.toList
+      }
       /**
        * Find and return the timeslots whithin which this Timeslot does not
-...
+       *
        * the result will be: `List(Timeslot(9,10), Timeslot(15,20))`
        */
       def nonOverlappingTimeslots(list: List[Timeslot]): List[Timeslot] = {
         val overlaps = list.filter(t => this.overlaps(t))
         if (overlaps.isEmpty)
           return List(this)
         def build(acc: List[Timeslot], listPart: List[Timeslot]): List[Timeslot] = {
           listPart match {
             case Nil => acc
             case x :: Nil => build(acc, List())
             case x :: y :: rest =>
               build(acc ++ List(Timeslot(x.to,  y.from)), y :: rest)
+          }
       def nonOverlappingTimeslots(list: List[Timeslot]): List[Timeslot] =
         overlappingTimeslots(list) sortWith {_.start < _.start} match  {
           case Nil => List(this)
           case over =>
             val (head,last) = (over.head,over.last)
             val hd = if (head.start > this.start) List(Timeslot(this.from, head.from)) else List()
             val tl = if (last.end < this.end) List(Timeslot(last.to, this.to)) else List()
             hd ++ over.tail.foldLeft((List[Timeslot](),over.head)) {
               case ((l,x),y) => (l ++ List(Timeslot(x.to,  y.from)),y)
             }._1  ++ tl
+        }
         val head = overlaps.head
         val last = overlaps.reverse.head
         val start = if (head.startsAfter(this)) List(Timeslot(this.from, head.from)) else List()
         val end = if (last.endsBefore(this)) List(Timeslot(last.to, this.to)) else List()
         start ++ build(List(), overlaps) ++ end
+      }
       /**
        * Align a list of consecutive timeslots to the boundaries
        * defined by this timeslot. Elements that do not overlap
-...
       def deltaMillis = to.getTime - from.getTime
       def fromMillis = from.getTime
       def toMillis   = to.getTime
       def myString : String = "Timeslot(" + this.start + "," + this.end + ")"
       //override def toString() = myString
       override def toString() = toDateString
       def toDateString = "Timeslot(%s, %s)".format(new MutableDateCalc(from), new MutableDateCalc(to))

         else
           limit
+      }
       /**
        * Search within
        */
       def findDays(from: Date, to: Date, f: Calendar => Boolean) : List[Date] = {
         val c = new GregorianCalendar()
         val result = new mutable.ListBuffer[Date]()
         c.setTime(from)
         while (c.getTime().getTime <= to.getTime) {
           if (f(c))
             result += new Date(c.getTime.getTime)
           c.add(Calendar.DAY_OF_YEAR, 1)
+        }
         result.toList
+      }
       /**
        * Adjust time in the provided date to the provided values
        */
       def adjustToTime(d: Date, h: Int,  m: Int): Date = {
         assert((0 <= h) && (h <= 23))
         assert((0 <= m) && (m <= 59))
         val c = new GregorianCalendar()
         c.setTime(d)
         c.roll(Calendar.MINUTE, m - c.get(Calendar.MINUTE))
         c.roll(Calendar.HOUR_OF_DAY, h - c.get(Calendar.HOUR_OF_DAY))
         c.getTime
+      }
+    }

     import gr.grnet.aquarium.util.TestMethods
     import gr.grnet.aquarium.logic.accounting.dsl._
     import annotation.tailrec
     import java.util.Date
     import java.util.{Calendar, Date}
     class DSLUtilsTest extends DSLTestBase with DSLUtils with TestMethods {
      /* @Test
       def testFindDays() = {
         var start = new Date(1321530829000L) // 17/11/2011 13:54:02
         var end = new Date(1353160515000L)   // 17/11/2012 13:55:15
         var result = findDays(start, end, {
           c =>
             c.get(Calendar.DAY_OF_WEEK) == 5}
+        )
         assertEquals(53, result.size)
+      }
       @Test
       def testAdjustTime() = {
         var d = new Date(1321615962000L)        // 18/11/2011 13:32:42
         var target = new Date(1321573542000L)   // 18/11/2011 01:45:42
         val result = adjustToTime(d, 1, 45)
         assertEquals(target, result)
         assertThrows(adjustToTime(d, 1, 62))
       }*/
       @Test
       def testExpandTimeSpec = {
         val from =  new Date(1321621969000L) //Fri Nov 18 15:12:49 +0200 2011
         val to =  new Date(1324214719000L)   //Sun Dec 18 15:25:19 +0200 2011
         var a = DSLTimeSpec(33, 12, -1, -1, 3)
         var result = expandTimeSpec(a, from, to)
         var result = a.expandTimeSpec(from, to)
         assertEquals(4, result.size)
         a = DSLTimeSpec(33, 12, -1, 10, 3)   // Timespec falling outside from-to
         result = expandTimeSpec(a, from, to)
         result = a.expandTimeSpec(from, to)
         assertEquals(0, result.size)
         // Would only return an entry if the 1rst of Dec 2011 is Thursday
         a = DSLTimeSpec(33, 12, 1, -1, 3)
         result = expandTimeSpec(a, from, to)
         result = a.expandTimeSpec(from, to)
         assertEquals(0, result.size)
         // The 9th of Dec 2011 is Friday
         //Console.err.println("\n\nBEGIN CALCULATION\t\t" + from + "\t\t" + to +  "\n\n")
         a = DSLTimeSpec(33, 12, 9, -1, 5)
         result = expandTimeSpec(a, from, to)
         result = a.expandTimeSpec(from, to)
         //Console.err.println("\n\nEND CALCULATION: " + result +"\n\n")
         assertEquals(1, result.size)
         // Every day
         a = DSLTimeSpec(33, 12, -1, -1, -1)
         result = expandTimeSpec(a, from, to)
         result = a.expandTimeSpec(from, to)
         assertEquals(31, result.size)
         //Console.err.println("\n\n@BEGIN CALCULATION\t\t" + from + "\t\t" + to +  "\n\n")
         a = DSLTimeSpec(33, 12, -1, -1, 5)
         result = a.expandTimeSpec(from, to)
         //Console.err.println("\n\n@END CALCULATION: " + result +"\n\n")
     //    assertEquals(1, result.size)
+      }
       @Test
       /*@Test
       def testExpandTimeSpecs = {
         val from =  new Date(1321621969000L) //Fri Nov 18 15:12:49 +0200 2011
         val to =  new Date(1324214719000L)   //Sun Dec 18 15:25:19 +0200 2011
-...
         result = expandTimeSpecs(List(a,b), from, to)
         assertNotEmpty(result)
         assertEquals(34, result.size)
+      }
       }*/
       @Test
       def testMergeOverlaps = {
         var l = List(Timeslot(new Date(12345000), new Date(13345000)),
           Timeslot(new Date(12845000), new Date(13845000)))
         var l = List(Timeslot(new Date(3), new Date(5)),Timeslot(new Date(1), new Date(3)))
         var result = mergeOverlaps(l)
         assertEquals(1, result.size)
         assertEquals(Timeslot(new Date(12345000), new Date(13845000)), result.head)
         assertEquals(Timeslot(new Date(1), new Date(5)), result.head)
         l = l ++ List(Timeslot(new Date(13645000), new Date(14845000)))
         l = l ++ List(Timeslot(new Date(4), new Date(6)))
         result = mergeOverlaps(l)
         assertEquals(1, result.size)
         assertEquals(Timeslot(new Date(12345000), new Date(14845000)), result.head)
         assertEquals(Timeslot(new Date(1), new Date(6)), result.head)
         l = l ++ List(Timeslot(new Date(15845000), new Date(16845000)))
         l = l ++ List(Timeslot(new Date(7), new Date(8)))
         result = mergeOverlaps(l)
         assertEquals(2, result.size)
         assertEquals(Timeslot(new Date(12345000), new Date(14845000)), result.head)
         assertEquals(Timeslot(new Date(15845000), new Date(16845000)), result.tail.head)
         assertEquals(Timeslot(new Date(1), new Date(6)), result.head)
         assertEquals(Timeslot(new Date(7), new Date(8)), result.tail.head)
         l = l ++ List(Timeslot(new Date(2), new Date(20)))
         result = mergeOverlaps(l)
         assertEquals(1, result.size)
         assertEquals(Timeslot(new Date(1), new Date(20)), result.head)
+      }
       @Test
-...
           "00 14 * * *"
+        )
         var result = effectiveTimeslots(repeat, from, Some(to))
         var result = effectiveTimeslots(repeat, from,to)
         assertNotEmpty(result)
         testSuccessiveTimeslots(result)
-...
           parseCronString("00 14 * Sep *"),
           "00 12 * May *",
           "00 14 * Sep *")
         result = effectiveTimeslots(repeat, from, Some(to))
         result = effectiveTimeslots(repeat, from,to)
         assertEquals(0, result.size)
         repeat = DSLTimeFrameRepeat(
-...
           parseCronString("00 14 * * 1"),
           "00 12 * * 5",
           "00 14 * * 1")
         result = effectiveTimeslots(repeat, from, Some(to))
         testSuccessiveTimeslots(result)
         result = effectiveTimeslots(repeat, from, to)
         //testSuccessiveTimeslots(result)
         assertEquals(4, result.size)
         repeat = DSLTimeFrameRepeat(
-...
           parseCronString("00 14 * * Tue,Thu,Sat"),
           "00 12 * * Mon,Wed,Fri",
           "00 14 * * Tue,Thu,Sat")
         result = effectiveTimeslots(repeat, from, Some(to))
         testSuccessiveTimeslots(result)
         result = effectiveTimeslots(repeat, from, to)
         //testSuccessiveTimeslots(result)
         assertEquals(13, result.size)
         repeat = DSLTimeFrameRepeat(
-...
           "00 00 * May *",
           "59 23 * Sep *")
         result = effectiveTimeslots(repeat, new Date(1304121600000L),
           Some(new Date(1319932800000L)))
           new Date(1319932800000L))
         assertNotEmpty(result)
+      }
-...
         assertEquals(1, result.size)
+      }
       @Test
      /* @Test
       def testNonEffectiveTimeslots = {
         val from =  new Date(1321621969000L) //Fri Nov 18 15:12:49 +0200 2011
         val to =  new Date(1324214719000L)   //Sun Dec 18 15:25:19 +0200 2011
-...
         assertEquals(30, result.size)
         testSuccessiveTimeslots(result)
         //printTimeslots(result)
+      }
       }*/
       @Test
       /*@Test
       def testTimeContinuum : Unit = {
         val from =  new Date(1321621969000L) //Fri Nov 18 15:12:49 +0200 2011
         val to =  new Date(1324214719000L)   //Sun Dec 18 15:25:19 +0200 2011
-...
         testNoGaps(continuum)
         return
+      }
       } */
       @Test
       def testFindEffective = {

     class DateUtilsTest extends DateUtils with TestMethods {
       @Test
       def testFindDays() = {
         var start = new Date(1321530829000L) // 17/11/2011 13:54:02
         var end = new Date(1353160515000L)   // 17/11/2012 13:55:15
         var result = findDays(start, end, {
           c =>
             c.get(Calendar.DAY_OF_WEEK) == 5}
+        )
         assertEquals(53, result.size)
+      }
       @Test
       def testAdjustTime() = {
         var d = new Date(1321615962000L)        // 18/11/2011 13:32:42
         var target = new Date(1321573542000L)   // 18/11/2011 01:45:42
         val result = adjustToTime(d, 1, 45)
         assertEquals(target, result)
         assertThrows(adjustToTime(d, 1, 62))
+      }
+    }

       @Test
       def testNonOverlappingTimeslots = {
         var t = Timeslot(new Date(7), new Date(20))
         val list = List(Timeslot(new Date(1), new Date(3)),
           Timeslot(new Date(6), new Date(8)),
           Timeslot(new Date(11), new Date(15)))
         var t = Timeslot(new Date(7L), new Date(20L))
         val list = List(Timeslot(new Date(1L), new Date(3L)),
           Timeslot(new Date(6L), new Date(8L)),
           Timeslot(new Date(11L), new Date(15L)))
         var result = t.nonOverlappingTimeslots(list)
         assertEquals(2, result.size)
         assertEquals(2L, result.size)
         t = Timeslot(new Date(9), new Date(20))
         t = Timeslot(new Date(9L), new Date(20L))
         result = t.nonOverlappingTimeslots(list)
         assertEquals(2, result.size)
-...
         assertEquals(1, result.size)
         assertEquals(t, result.head)
+      }
       @Test
       def testAlign = {
         var t = Timeslot(new Date(7), new Date(20))
         var list = List(Timeslot(new Date(1), new Date(3)),
           Timeslot(new Date(6), new Date(8)),
           Timeslot(new Date(11), new Date(15)))
         var aligned = t.align(list)
         assertEquals(2, aligned.size)
         assertEquals(Timeslot(new Date(7), new Date(8)), aligned.head)
         list = list ++ List(Timeslot(new Date(19), new Date(22)))
         aligned = t.align(list)
         assertEquals(3, aligned.size)
         assertEquals(Timeslot(new Date(7), new Date(8)), aligned.head)
         assertEquals(Timeslot(new Date(19), new Date(20)), aligned.last)
         // Real-world failure, test whether aligned timeslot contains this
         t = Timeslot(
           new MutableDateCalc(2012, 1, 1).goPlusHours(3).toDate,
           new MutableDateCalc(2012, 1, 2).goPlusHours(4).toDate)
         val dc20110101 = new MutableDateCalc(2011, 1, 1)
         val dc20111101 = new MutableDateCalc(2011, 11, 1)
         val polTs = List(Timeslot(dc20110101.toDate, dc20110101.copy.goPlusYears(2).toDate))
         val agrTs = List(Timeslot(dc20111101.toDate, new Date(Long.MaxValue)))
         val alignedPolTs = t.align(polTs)
         assertEquals(1, alignedPolTs.size)
         assertEquals(t.to, alignedPolTs.last.to)
         val alignedAgrTs = t.align(agrTs)
         assertEquals(1, alignedAgrTs.size)
         assertEquals(t.to, alignedAgrTs.last.to)
+      }
+    }

Aquarium

Revision d8b5447f