Events.scala

/*
  BSD3 license
  ------------

  Copyright (c) 2013, Petr Pudlák
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

  - Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.
  - Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.
  - Neither the name of the author nor the names of contributors
    may be used to endorse or promote products derived from this software
    without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  POSSIBILITY OF SUCH DAMAGE.
*/
import org.scalatest._
import org.scalatest.PropSpec
import org.scalatest.prop.PropertyChecks
import org.scalatest.matchers.ShouldMatchers

/**
 * A helper testing class that records a timestamp each time its
 * [[Event.record]] method is called. Timestamps don't represent any
 * absolute time, they are only meant to be compared to each other to
 * determine when an event ocurred compared to other events.
 */
class Event(implicit c: Event.Counter = Event.sharedCounter)
  extends Function0[Unit]
{
  private[this] var _marks = new ArrayBuffer[Event.Mark];

  /**
   * Requests a new time mark from [[Event.Counter]] and records it.
   */
  def record() {
    _marks += c.mark();
  }

  /**
   * An alias for [[record]].
   */
  override def apply(): Unit = record();

  /**
   * Returns an identity function whose side effect is calling [[record()]].
   */
  def id[R]: R => R =
    (x: R) => { record(); x; }

  /**
   * Calls [[record()]] and then evaluates the given computation.
   */
  def fn[R](f: => R): R =
    { record(); f; }
  /**
   * Augments a given function with calling [[record()]].
   */
  def fn0[R](f: () => R): () => R =
    () => { record(); f(); }
  /**
   * Augments a given function with calling [[record()]].
   */
  def fn1[A,R](f: (A) => R): (A) => R =
    (x: A) => { record(); f(x); }
  /**
   * Augments a given function with calling [[record()]].
   */
  def fn2[A,B,R](f: (A,B) => R): (A,B) => R =
    (x: A, y: B) => { record(); f(x, y); }

  /**
   * Returns the list of accumulated marks.
   */
  def marks: Traversable[Event.Mark] = _marks;


  /**
   * Returns the number of times this event was invoked.
   */
  def count: Int = marks.size;
  /**
   * Checks that this event was invoked just once.
   */
  def justOnce =
    count should be (1);
  /**
   * Check that this event ocurred only after all the given events.
   * Note that this condition is trivially satisfied if this event
   * has never been invoked.
   */
  def mustAfter(es: Event*) {
    for(e <- es;
        i <- e.marks;
        j <- this.marks)
      i should be < j;
  }
  /**
   * Check that this event ocurred only before all the given events.
   * Note that this condition is trivially satisfied if this event
   * has never been invoked.
   */
  def mustBefore(es: Event*) {
    for(e <- es;
        i <- e.marks;
        j <- this.marks)
      i should be > j;
  }
}

object Event {
  type Mark = Int
  class Counter {
    private[this] val lock = new Object;
    private[this] var counter: Mark = 0;

    /**
     * Create a new mark. Every time the function is called,
     * it returns a mark that his higher than the previous onme.
     */
    def mark(): Mark = lock.synchronized {
      counter += 1;
      counter;
    }
  }

  implicit val sharedCounter = new Counter;
}