public
Created

  • Download Gist
Events.scala
Scala
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
/*
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;
}

Please sign in to comment on this gist.

Something went wrong with that request. Please try again.