Removed junk from the test, accidentally deleted test restored

idea/testData/checker/Constructors.jet

@@ -48,16 +48,4 @@ class NoCPI {
   var ab = <error>1</error>
     get() = 1
     set(v) {}
-}
-
-a.select(it => it.toString()).where(it => it < 1)
-a.select{it.toString()}.where{it < 1}
-
-
-for (a in 1..10)
-
-for ((val a, val b) in range)
-
-for ((a, b) in range) {
-  is Foo => sdgfsdg
 }

idea/testData/psi/examples/priorityqueues/BinaryHeap.jet

@@ -0,0 +1,89 @@
+class BinaryHeap<T>(_data : IIterable<T>, compare : Comparison<T> = naturalOrder<T>) : IPriorityQueue<T> {
+  private val data : IMutableList<T> = new ArrayList(_data)
+
+  {
+    for (val i in data.size / 2 .. 0) {
+      siftDown(i)
+    }
+  }
+
+  override fun extract() : T {
+    if (this.isEmpty)
+      throw new UnderflowException()
+    data.swap(0, data.lastIndex)
+    data.remove(data.lastIndex)
+    siftDown(0)
+  }
+
+  override fun add(item : T) {
+    data.add(item)
+    siftUp(data.lastItem)
+  }
+
+  private fun siftDown(index : Int) {
+    var current = index
+    while (current.left.exists) {
+      var min = current
+      if (current.left.value < min.value) {
+        min = current.left
+      }
+      if (current.right.exists && current.right.value < min.value) {
+        min = current.right
+      }
+      if (min == current) break
+      data.swap(min, current)
+      current = min
+    }
+  }
+
+  private fun siftUp(index : Int) {
+    if (!current.exists) return
+    var current = index
+    while (current.parent.exists) {
+      if (current.value < current.parent.value) {
+        data.swap(current, current.parent)
+        current = current.parent
+      }
+    }
+  }
+
+  private extension HeapIndex for Int {
+    val parent : Int
+      get() = (this - 1) / 2
+
+
+    val left : Int
+      get() = this * 2 + 1
+
+
+    val right : Int
+      get() = this * 2 + 2
+
+
+    val value : T = foo.bar()
+      get() = data[this]
+      set(it) {
+        $value = it
+      }
+
+
+    val exists : Boolean
+      get() = (this < data.size) && (this >= 0)
+
+  }
+
+  private extension for T {
+    fun compareTo(other : T) : Int = compare(this, other)
+  }
+
+}
+
+fun <T> IMutableList<T>.swap(a : Int, b : Int) {
+  val t = this[a]
+  this[a] = this[b]
+  this[b] = t
+}
+
+val <T> IList<T>.lastIndex : Int
+  get() = this.size - 1
+