add unit tests for maps and sets

Author: bishabosha

compiler/src/dotty/tools/dotc/util/EqHashSet.scala

@@ -85,36 +85,6 @@ class EqHashSet[T](initialCapacity: Int = 8, capacityMultiple: Int = 2) extends
 
   override def +=(x: T): Unit = put(x)
 
-  override def remove(x: T): Boolean =
-    Stats.record(statsItem("remove"))
-    var idx = firstIndex(x)
-    var e: T | Null = entryAt(idx)
-    while e != null do
-      if isEqual(e.uncheckedNN, x) then
-        var hole = idx
-        while
-          idx = nextIndex(idx)
-          e = entryAt(idx)
-          e != null
-        do
-          val eidx = index(hash(e.uncheckedNN))
-          if isDense
-            || index(eidx - (hole + 1)) > index(idx - (hole + 1))
-               // entry `e` at `idx` can move unless `index(hash(e))` is in
-               // the (ring-)interval [hole + 1 .. idx]
-          then
-            setEntry(hole, e.uncheckedNN)
-            hole = idx
-        table(hole) = null
-        used -= 1
-        return true
-      idx = nextIndex(idx)
-      e = entryAt(idx)
-    false
-
-  override def -=(x: T): Unit =
-    remove(x)
-
   private def addOld(x: T) =
     Stats.record(statsItem("re-enter"))
     var idx = firstIndex(x)

compiler/src/dotty/tools/dotc/util/HashSet.scala

@@ -64,48 +64,29 @@ class HashSet[T](initialCapacity: Int = 8, capacityMultiple: Int = 2) extends Ge
     if used > limit then growTable()
     x
 
-  override def put(x: T): T =
-    Stats.record(statsItem("put"))
+  override def add(x: T): Boolean =
+    Stats.record(statsItem("enter"))
     var idx = firstIndex(x)
     var e: T | Null = entryAt(idx)
     while e != null do
-      // TODO: remove uncheckedNN when explicit-nulls is enabled for regule compiling
-      if isEqual(e.uncheckedNN, x) then return e.uncheckedNN
+      if isEqual(e.uncheckedNN, x) then return false // already entered
       idx = nextIndex(idx)
       e = entryAt(idx)
     addEntryAt(idx, x)
+    true // first entry
 
-  override def +=(x: T): Unit = put(x)
-
-  override def remove(x: T): Boolean =
-    Stats.record(statsItem("remove"))
+  override def put(x: T): T =
+    Stats.record(statsItem("put"))
     var idx = firstIndex(x)
     var e: T | Null = entryAt(idx)
     while e != null do
-      if isEqual(e.uncheckedNN, x) then
-        var hole = idx
-        while
-          idx = nextIndex(idx)
-          e = entryAt(idx)
-          e != null
-        do
-          val eidx = index(hash(e.uncheckedNN))
-          if isDense
-            || index(eidx - (hole + 1)) > index(idx - (hole + 1))
-               // entry `e` at `idx` can move unless `index(hash(e))` is in
-               // the (ring-)interval [hole + 1 .. idx]
-          then
-            setEntry(hole, e.uncheckedNN)
-            hole = idx
-        table(hole) = null
-        used -= 1
-        return true
+      // TODO: remove uncheckedNN when explicit-nulls is enabled for regule compiling
+      if isEqual(e.uncheckedNN, x) then return e.uncheckedNN
       idx = nextIndex(idx)
       e = entryAt(idx)
-    false
+    addEntryAt(idx, x)
 
-  override def -=(x: T): Unit =
-    remove(x)
+  override def +=(x: T): Unit = put(x)
 
   private def addOld(x: T) =
     Stats.record(statsItem("re-enter"))
@@ -125,7 +106,4 @@ class HashSet[T](initialCapacity: Int = 8, capacityMultiple: Int = 2) extends Ge
         val e: T | Null = oldTable(idx).asInstanceOf[T | Null]
         if e != null then addOld(e.uncheckedNN)
         idx += 1
-
-  override def iterator: Iterator[T] = new EntryIterator():
-    def entry(idx: Int) = entryAt(idx)
 }

compiler/test/dotty/tools/dotc/util/EqHashMapTest.scala

@@ -0,0 +1,115 @@
+package dotty.tools.dotc.util
+
+import org.junit.Test
+import org.junit.Assert.*
+
+class EqHashMapTest:
+
+  var counter = 0
+
+  // basic identity hash, and reference equality, but with a counter for ordering
+  class Id:
+    val count = { counter += 1; counter }
+
+  val id1, id2, id3 = Id()
+
+  given Ordering[Id] = Ordering.by(_.count)
+
+  @Test
+  def invariant: Unit =
+    assert((id1 ne id2) && (id1 ne id3) && (id2 ne id3))
+
+  @Test
+  def newEmpty: Unit =
+    val m = EqHashMap[Id, Int]()
+    assert(m.size == 0)
+    assert(m.iterator.toList == Nil)
+
+  @Test
+  def update: Unit =
+    val m = EqHashMap[Id, Int]()
+    assert(m.size == 0 && !m.contains(id1))
+    m.update(id1, 1)
+    assert(m.size == 1 && m(id1) == 1)
+    m.update(id1, 2) // replace value
+    assert(m.size == 1 && m(id1) == 2)
+    m.update(id3, 3) // new key
+    assert(m.size == 2 && m(id1) == 2 && m(id3) == 3)
+
+  @Test
+  def getOrElseUpdate: Unit =
+    val m = EqHashMap[Id, Int]()
+    // add id1
+    assert(m.size == 0 && !m.contains(id1))
+    val added = m.getOrElseUpdate(id1, 1)
+    assert(added == 1 && m.size == 1 && m(id1) == 1)
+    // try add id1 again
+    val addedAgain = m.getOrElseUpdate(id1, 23)
+    assert(addedAgain != 23 && m.size == 1 && m(id1) == 1) // no change
+
+  private def fullMap() =
+    val m = EqHashMap[Id, Int]()
+    m.update(id1, 1)
+    m.update(id2, 2)
+    m
+
+  @Test
+  def remove: Unit =
+    val m = fullMap()
+    // remove id2
+    m.remove(id2)
+    assert(m.size == 1)
+    assert(m.contains(id1) && !m.contains(id2))
+    // remove id1
+    m -= id1
+    assert(m.size == 0)
+    assert(!m.contains(id1) && !m.contains(id2))
+
+  @Test
+  def lookup: Unit =
+    val m = fullMap()
+    assert(m.lookup(id1) == 1)
+    assert(m.lookup(id2) == 2)
+    assert(m.lookup(id3) == null)
+
+  @Test
+  def iterator: Unit =
+    val m = fullMap()
+    assert(m.iterator.toList.sorted == List(id1 -> 1,id2 -> 2))
+
+  @Test
+  def clear: Unit =
+    locally:
+      val s1 = fullMap()
+      s1.clear()
+      assert(s1.size == 0)
+    locally:
+      val s2 = fullMap()
+      s2.clear(resetToInitial = false)
+      assert(s2.size == 0)
+
+  // basic structural equality and hash code
+  class I32(val x: Int):
+    override def hashCode(): Int = x
+    override def equals(that: Any): Boolean = that match
+      case that: I32 => this.x == that.x
+      case _ => false
+
+  /** the hash set is based on reference equality, i.e. does not use universal equality */
+  @Test
+  def referenceEquality: Unit =
+    val i1, i2 = I32(1) // different instances
+
+    assert(i1.equals(i2)) // structural equality
+    assert(i1 ne i2) // reference inequality
+
+    val m = locally:
+      val m = EqHashMap[I32, Int]()
+      m(i1) = 23
+      m(i2) = 29
+      m
+
+    assert(m.size == 2 && m(i1) == 23 && m(i2) == 29)
+    assert(m.keysIterator.toSet == Set(i1)) // scala.Set delegates to universal equality
+  end referenceEquality
+

compiler/test/dotty/tools/dotc/util/EqHashSetTest.scala

@@ -0,0 +1,119 @@
+package dotty.tools.dotc.util
+
+import org.junit.Test
+import org.junit.Assert.*
+
+class EqHashSetTest:
+
+  var counter = 0
+
+  // basic identity hash, and reference equality, but with a counter for ordering
+  class Id:
+    val count = { counter += 1; counter }
+
+  val id1, id2, id3 = Id()
+
+  given Ordering[Id] = Ordering.by(_.count)
+
+  @Test
+  def invariant: Unit =
+    assert((id1 ne id2) && (id1 ne id3) && (id2 ne id3))
+
+  @Test
+  def newEmpty: Unit =
+    val s = EqHashSet[Id]()
+    assert(s.size == 0)
+    assert(s.iterator.toList == Nil)
+
+  @Test
+  def put: Unit =
+    val s = EqHashSet[Id]()
+    // put id1
+    assert(s.size == 0 && !s.contains(id1))
+    s += id1
+    assert(s.size == 1 && s.contains(id1))
+    // put id2
+    assert(!s.contains(id2))
+    s.put(id2)
+    assert(s.size == 2 && s.contains(id1) && s.contains(id2))
+    // put id3
+    s ++= List(id3)
+    assert(s.size == 3 && s.contains(id1) && s.contains(id2) && s.contains(id3))
+
+  @Test
+  def add: Unit =
+    val s = EqHashSet[Id]()
+    // add id1
+    assert(s.size == 0 && !s.contains(id1))
+    val added = s.add(id1)
+    assert(added && s.size == 1 && s.contains(id1))
+    // try add id1 again
+    val addedAgain = s.add(id1)
+    assert(!addedAgain && s.size == 1 && s.contains(id1)) // no change
+
+  @Test
+  def construct: Unit =
+    val s = EqHashSet.from(List(id1,id2,id3))
+    assert(s.size == 3)
+    assert(s.contains(id1) && s.contains(id2) && s.contains(id3))
+
+  @Test
+  def remove: Unit =
+    val s = EqHashSet.from(List(id1,id2,id3))
+    // remove id2
+    s.remove(id2)
+    assert(s.size == 2)
+    assert(s.contains(id1) && !s.contains(id2) && s.contains(id3))
+    // remove id1
+    s -= id1
+    assert(s.size == 1)
+    assert(!s.contains(id1) && !s.contains(id2) && s.contains(id3))
+    // remove id3
+    s --= List(id3)
+    assert(s.size == 0)
+    assert(!s.contains(id1) && !s.contains(id2) && !s.contains(id3))
+
+  @Test
+  def lookup: Unit =
+    val s = EqHashSet.from(List(id1, id2))
+    assert(s.lookup(id1) eq id1)
+    assert(s.lookup(id2) eq id2)
+    assert(s.lookup(id3) eq null)
+
+  @Test
+  def iterator: Unit =
+    val s = EqHashSet.from(List(id1,id2,id3))
+    assert(s.iterator.toList.sorted == List(id1,id2,id3))
+
+  @Test
+  def clear: Unit =
+    locally:
+      val s1 = EqHashSet.from(List(id1,id2,id3))
+      s1.clear()
+      assert(s1.size == 0)
+    locally:
+      val s2 = EqHashSet.from(List(id1,id2,id3))
+      s2.clear(resetToInitial = false)
+      assert(s2.size == 0)
+
+  // basic structural equality and hash code
+  class I32(val x: Int):
+    override def hashCode(): Int = x
+    override def equals(that: Any): Boolean = that match
+      case that: I32 => this.x == that.x
+      case _ => false
+
+  /** the hash map is based on reference equality, i.e. does not use universal equality */
+  @Test
+  def referenceEquality: Unit =
+    val i1, i2 = I32(1) // different instances
+
+    assert(i1.equals(i2)) // structural equality
+    assert(i1 ne i2) // reference inequality
+
+    val s = EqHashSet.from(List(i1,i2))
+
+    assert(s.size == 2 && s.contains(i1) && s.contains(i2))
+    assert(s.iterator.toSet == Set(i1)) // scala.Set delegates to universal equality
+  end referenceEquality
+