src/test/scala/instrumentation/Stats.scala

@@ -2,10 +2,7 @@ package instrumentation
 
 import java.lang.management.*
 
-/** A collection of methods that can be used to collect run-time statistics
-  * about Leon programs. This is mostly used to test the resources properties of
-  * Leon programs
-  */
+/** A collection of methods that can be used to collect run-time statistics */
 object Stats:
   def timed[T](code: => T)(cont: Long => Unit): T =
     var t1 = System.currentTimeMillis()

src/test/scala/midterm23/BarberShopSolutionTest.scala

+package midterm23
+
+import instrumentation.*
+import java.util.concurrent.atomic.AtomicInteger
+
+class BarberShopSolutionTest extends munit.FunSuite:
+  val implementations =
+    Map[String, (Int, Scheduler) => ScheduledBarberShopSolution](
+      "BarberShopSolution1" -> (new BarberShopSolution1(_)
+        with ScheduledBarberShopSolution(_)),
+      "BarberShopSolution2" -> (new BarberShopSolution2(_)
+        with ScheduledBarberShopSolution(_)),
+      "BarberShopSolution3" -> (new BarberShopSolution3(_)
+        with ScheduledBarberShopSolution(_))
+    )
+
+  for (name, makeShop) <- implementations do
+    for nCustomers <- 1 to 3 do
+      test(f"$name with $nCustomers customer(s)") {
+        testBarberShop(nCustomers, makeShop)
+      }

src/test/scala/midterm23/ScheduledBarberShopSolution.scala

+package midterm23
+
+import instrumentation.{MockedMonitor, Monitor, Scheduler}
+import java.util.concurrent.ConcurrentLinkedQueue
+import scala.jdk.CollectionConverters.IterableHasAsScala
+import scala.annotation.tailrec
+
+trait ScheduledBarberShopSolution(scheduler0: Scheduler)
+    extends AbstractBarberShopSolution:
+  enum Event:
+    case HairCut
+    case CustomerLeaves
+
+  val trace = ConcurrentLinkedQueue[Event]()
+
+  override def notifyBarber = scheduler0.exec { super.notifyBarber }(
+    "",
+    Some(res => f"read notifyBarber == $res")
+  )
+
+  override def notifyBarber_=(v: Boolean) =
+    scheduler0.exec { super.notifyBarber = v }(
+      f"write notifyBarber = $v"
+    )
+
+  override def notifyCustomer = scheduler0.exec { super.notifyCustomer }(
+    "",
+    Some(res => f"read notifyCustomer == $res")
+  )
+
+  override def notifyCustomer_=(v: Boolean) =
+    scheduler0.exec { super.notifyCustomer = v }(
+      f"write notifyCustomer = $v"
+    )
+
+  override def hairCut() =
+    log("hair cut")
+    trace.add(Event.HairCut)
+
+  def customerTrace(n: Int): Unit =
+    this.customer(n)
+    log("customer leaves")
+    trace.add(Event.CustomerLeaves)
+
+  private val _lockObj = new MockedMonitor:
+    override def scheduler: Scheduler = scheduler0
+
+  override def lockObj: Monitor = _lockObj
+
+  override def log(s: String): Unit = scheduler0.log(s)
+
+  def nHaircuts: Int =
+    trace.asScala.filter(_ == Event.HairCut).size
+
+  def customerLeftEarly(): Boolean =
+    @tailrec
+    def loop(it: Iterable[Event], n: Int): Boolean =
+      if it.isEmpty then false
+      else
+        val newN = it.head match
+          case Event.HairCut        => n + 1
+          case Event.CustomerLeaves => n - 1
+        if newN < 0 then true
+        else loop(it.tail, newN)
+    loop(trace.asScala, 0)

src/test/scala/midterm23/testBarberShop.scala

+package midterm23
+
+import instrumentation.{Scheduler, TestHelper}
+
+/** Tests a barber shop implementation.
+  *
+  * @param nCustomers
+  *   The number of customers to simulate.
+  * @param makeShop
+  *   A function that creates a barber shop given the number of customers and a
+  *   scheduler.
+  * @param checkEarlyCustomer
+  *   If true, checks that no customer left early, i.e. that there is always a
+  *   number of terminated customer threads equal or less than to the number of
+  *   haircuts done.
+  */
+def testBarberShop(
+    nCustomers: Int,
+    makeShop: (Int, Scheduler) => ScheduledBarberShopSolution,
+    checkEarlyCustomer: Boolean = true
+) =
+  TestHelper.testManySchedules(
+    nCustomers + 1,
+    scheduler =>
+      val barberShop = makeShop(nCustomers, scheduler)
+
+      (
+        (() => barberShop.barber())
+          :: (for i <- 1 to nCustomers
+          yield () => barberShop.customerTrace(i)).toList,
+        results =>
+          if barberShop.nHaircuts != nCustomers then
+            (false, f"Unexpected number of hair cuts: ${barberShop.nHaircuts}")
+          else if checkEarlyCustomer && barberShop.customerLeftEarly() then
+            (false, f"A customer left early")
+          else
+            (true, "")
+      )
+  )