Changeset 4130 for trunk/ProjectFortress/tests

Timestamp:

09/05/09 14:21:41 (3 months ago)

Author:

sukyoungryu

Message:

[disambiguator] Fixed handling getters and setters in ExprDisambiguator?. Fixed libraries and tests using getters.

Location:

trunk/ProjectFortress/tests

Files:

• ArrayListQuick.fss (modified) (3 diffs)
• BadBounds.fss (modified) (3 diffs)
• EqualityOverloadBug.fss (modified) (1 diff)
• Exception.fss (modified) (2 diffs)
• ExceptionScoping.fss (modified) (1 diff)
• HeapTest.fss (modified) (5 diffs)
• ListTest.fss (modified) (2 diffs)
• MapTest.fss (modified) (3 diffs)
• ObjectToStringTest.fss (modified) (1 diff)
• PureListQuick.fss (modified) (3 diffs)
• RangePrototype.fss (modified) (4 diffs)
• Region.fss (modified) (1 diff)
• SetTest.fss (modified) (1 diff)
• SkipListTest.fss (modified) (3 diffs)
• TransactionalArrayShakedown.fss (modified) (1 diff)
• WordCountSmall.fss (modified) (1 diff)
• array3test.fss (modified) (1 diff)
• asifTest.fss (modified) (2 diffs)
• atomicList.fss (modified) (2 diffs)
• booleanGuard.fss (modified) (1 diff)
• deepHierarchy.fss (modified) (1 diff)
• extendAny.fss (modified) (1 diff)
• extendException.fss (modified) (1 diff)
• fmTest2.fss (modified) (3 diffs)
• fmTest3.fss (modified) (3 diffs)
• intPrim.fss (modified) (1 diff)
• longPrim.fss (modified) (1 diff)
• maybeTest.fss (modified) (2 diffs)
• naiveSeq.fss (modified) (1 diff)
• naturalsTest.fss (modified) (2 diffs)
• nestedInst.fss (modified) (2 diffs)
• realArith.fss (modified) (2 diffs)
• spuriousSelf.fss (modified) (1 diff)
• subArray.fss (modified) (5 diffs)
• testRR32.fss (modified) (2 diffs)
• testRecImport.fss (modified) (2 diffs)
• whileTest.fss (modified) (1 diff)
• zeno.fss (modified) (1 diff)

trunk/ProjectFortress/tests/ArrayListQuick.fss

@@ -22 +22 @@
 assertStr[\T\](a:ZZ32, b:ZZ32, s:String, l: List[\T\]) =
   if a=/=b then
-    fail(a "=/=" b ": " s l.asString())
+    fail(a "=/=" b ": " s l.asString)
   end
 
 assertStr[\T\](a:Boolean, s:String, l: List[\T\]) =
   if NOT a then
-    fail("Failed assertion: " s l.asString())
+    fail("Failed assertion: " s l.asString)
   end
 
 assertStr[\T\](a:Boolean, s:String, l: List[\T\], r: List[\T\]) =
   if NOT a then
-    fail("Failed assertion: " s l.asString() " and " r.asString())
+    fail("Failed assertion: " s l.asString " and " r.asString)
   end
 
@@ -64 +64 @@
   ll : List[\ZZ32\] := l
   for i <- seq(0#sz) do
-      (e,ll0) = ll.extractLeft().get()
+      (e,ll0) = ll.extractLeft.get
       assertStr(e,i,"extractLeft wrong in ",ll)
-      assertStr(ll.left().get(),i,"left wrong in ",ll)
+      assertStr(ll.left.get,i,"left wrong in ",ll)
       ll := ll0
   end
-  assertStr(ll.isEmpty()," not empty after extractLeft(); it's ",ll)
+  assertStr(ll.isEmpty," not empty after extractLeft; it's ",ll)
   ll := l
   for i <- seq(1#sz) do
-      (ll0,e) = ll.extractRight().get()
+      (ll0,e) = ll.extractRight.get
       assertStr(e,sz-i,"extractRight wrong in ",ll)
-      assertStr(ll.right().get(),sz-i,"right wrong in ",ll)
+      assertStr(ll.right.get,sz-i,"right wrong in ",ll)
       ll := ll0
   end
-  assertStr(ll.isEmpty()," not empty after extractRight(); it's ",ll)
+  assertStr(ll.isEmpty," not empty after extractRight; it's ",ll)
 end
 
@@ -126 +126 @@
       chkPop(ivli,0,i,2)
       print(".")
-      rli=li.reverse()
+      rli=li.reverse
       for j <- 0#i do
           print(".")

trunk/ProjectFortress/tests/BadBounds.fss

@@ -22 +22 @@
                  3 4
                  5 6]
-  println ("b lower bounds " b.bounds().lower() )
-  println ("b upper bounds " b.bounds().upper() )
-  println ("b.bounds = " b.bounds())
+  println ("b lower bounds " b.bounds.lower )
+  println ("b upper bounds " b.bounds.upper )
+  println ("b.bounds = " b.bounds)
 
   bShifted = b.bounds ≫ (2,5)
@@ -33 +33 @@
   assert(bShifted ≪ (2,5), b.bounds)
 
-  for (i,j) <- b.indices() do
+  for (i,j) <- b.indices do
       println("b[" i "," j "] = " b[i,j])
   end
 
-  for (i,j) <- sequential(b.indices()) do
+  for (i,j) <- sequential(b.indices) do
       println("b[" i "," j "] = " b[i,j])
   end
@@ -54 +54 @@
   assert(cShifted ≪ (2, 5, 8), c.bounds)
 
-  for (i,j,k) <- c.indices() do
+  for (i,j,k) <- c.indices do
             println ("c[" i "," j "," k "] = " c[i,j,k] )
   end
-  for (i,j,k) <- sequential(c.indices()) do
+  for (i,j,k) <- sequential(c.indices) do
             println ("c[" i "," j "," k "] = " c[i,j,k] )
   end
-  println ("c lower bounds " c.bounds().lower() )
-  println ("c upper bounds " c.bounds().upper() )
-  println ("c.bounds = " c.bounds())
+  println ("c lower bounds " c.bounds.lower )
+  println ("c upper bounds " c.bounds.upper )
+  println ("c.bounds = " c.bounds)
 
 end

trunk/ProjectFortress/tests/EqualityOverloadBug.fss

@@ -20 +20 @@
 
 object Bar extends Equality[\Bar\]
-  asString():Bar = "Bar"
+  getter asString():Bar = "Bar"
   opr =(self, _:Bar): Boolean = do println("OK Bar"); true end
 end

trunk/ProjectFortress/tests/Exception.fss

@@ -20 +20 @@
 
 object Scooby extends CheckedException
-    asString(): String = "ScoobyDoobyDoo"
+    getter asString(): String = "ScoobyDoobyDoo"
 end
 
 object Shaggy extends CheckedException
-    asString(): String = "RuhRohRaggy"
+    getter asString(): String = "RuhRohRaggy"
 end
 
@@ -113 +113 @@
         Shaggy => x := e
     end
-    assert(x.asString(), "RuhRohRaggy", "Test5: Improper binding of exception");
+    assert(x.asString, "RuhRohRaggy", "Test5: Improper binding of exception");
 end
 

trunk/ProjectFortress/tests/ExceptionScoping.fss

@@ -35 +35 @@
     try
         try
-            Nothing[\ZZ32\].get()
+            Nothing[\ZZ32\].get
         catch x
             FailCalled => fail("Caught FailCalled!!")

trunk/ProjectFortress/tests/HeapTest.fss

@@ -22 +22 @@
 
 checkFull(h0: Heap[\ZZ32,ZZ32\], n:ZZ32): () =
-    if h0.isEmpty() then
+    if h0.isEmpty then
         if NOT (n=0) then fail("empty with n=/=0") end
     else
         flags : Array[\Boolean,ZZ32\] = array[\Boolean\](n).fill(false)
-        (k:ZZ32, v:ZZ32, h:Heap[\ZZ32,ZZ32\]) := h0.extractMinimum().get()
+        (k:ZZ32, v:ZZ32, h:Heap[\ZZ32,ZZ32\]) := h0.extractMinimum().get
         k_prev : ZZ32 := k
         expected: ZZ32 := 1
         flags[v] := true
         failed : Boolean := false
-        while NOT h.isEmpty() AND expected <= n do
-            (k,v,h) := h.extractMinimum().get()
+        while NOT h.isEmpty AND expected <= n do
+            (k,v,h) := h.extractMinimum().get
             if k < k_prev then
                 println("FAIL: Keys " k_prev " and " k " out of order.")
@@ -44 +44 @@
             expected += 1
         end
-        if NOT h.isEmpty() then
+        if NOT h.isEmpty then
             println("FAIL: Too many elements.")
             failed := true
@@ -55 +55 @@
             expected := 0
             println(h.asDebugString)
-            while NOT h.isEmpty() AND expected <= n do
-                (k,v,h) := h.extractMinimum().get()
+            while NOT h.isEmpty AND expected <= n do
+                (k,v,h) := h.extractMinimum().get
                 println(expected ": min = (" k "," v ")")
                 println(h.asDebugString)
@@ -87 +87 @@
     assert(n,sz," size versus computed size")
     if (sz > 0) then
-        (mn_k, mn_v) = h.minimum().get()
-        assert(mn,mn_k," computed minimum versus .minimum()")
+        (mn_k, mn_v) = h.minimum.get
+        assert(mn,mn_k," computed minimum versus .minimum")
     end
   end
@@ -137 +137 @@
         slgs = s lg s
         print(s "\t" slgs)
-        testHeap(s,lazy[\ZZ32,ZZ32\],(0#s).indexValuePairs())
+        testHeap(s,lazy[\ZZ32,ZZ32\],(0#s).indexValuePairs)
         testHeap(s,lazy[\ZZ32,ZZ32\],(0#s).map[\(ZZ32,ZZ32)\](spread))
-        testHeap(s,pairing[\ZZ32,ZZ32\],(0#s).indexValuePairs())
+        testHeap(s,pairing[\ZZ32,ZZ32\],(0#s).indexValuePairs)
         testHeap(s,pairing[\ZZ32,ZZ32\],(0#s).map[\(ZZ32,ZZ32)\](spread))
         println()

trunk/ProjectFortress/tests/ListTest.fss

@@ -28 +28 @@
 
     assert(|list'|,3," |list'|")
-    assert(list'.left().get(),3," list'.left()")
+    assert(list'.left.get,3," list'.left")
     assert(list'.drop(1),<|5 asif ZZ32,7|>," list'.drop(1)")
     assert((list'.drop(1))[1], 7," list'.drop(1)[1]")
@@ -35 +35 @@
     assert(BIG AND [e <- list''] e IN l, true,
            l, " doesn't contain all of ", list'')
-    assert(l.indexOf(8).get(),3,l,".indexOf(8)")
-    assert(list'.isEmpty(), false, list', ".isEmpty()")
+    assert(l.indexOf(8).get,3,l,".indexOf(8)")
+    assert(list'.isEmpty, false, list', ".isEmpty")
     assert(l.filter(fiveOrMore).map[\ZZ32\](fn x => 10 x),
            <|50 asif ZZ32,70,80,60|>,"filter . map")

trunk/ProjectFortress/tests/MapTest.fss

@@ -43 +43 @@
     perm : ZZ32[5] = [ 3 4 1 0 2 ]
     expect : String[5] = [("" "Nathi") "Peter" "Emily" "David" "Elias"]
-    for (v,k) <- seq(expect.indexValuePairs()) do
+    for (v,k) <- seq(expect.indexValuePairs) do
         init(k,v)
     end
@@ -54 +54 @@
     db''={("" "David") asif String|->3 asif ZZ32, "Elias"|->4, "Peter"|->1, "Nathi"|->0, "Emily"|->2}
     check(db'')
-    db' = {[\String,ZZ32\] k|->v | (v,k) <- expect.indexValuePairs() }
+    db' = {[\String,ZZ32\] k|->v | (v,k) <- expect.indexValuePairs }
     check(db')
     db : Map[\String,ZZ32\] = {[\String,ZZ32\] expect[i]|->i  |  i <- perm }
@@ -60 +60 @@
     db0 = db UNION db' (*'*)
     check(db0)
-    db1 = BIG UNION [(v,k) <- expect.indexValuePairs()] { k asif String|-> v asif ZZ32 }
+    db1 = BIG UNION [(v,k) <- expect.indexValuePairs] { k asif String|-> v asif ZZ32 }
     check(db1)
-    db2 = BIG UPLUS [(v,k) <- expect.indexValuePairs()] { k asif String |-> v asif ZZ32 }
+    db2 = BIG UPLUS [(v,k) <- expect.indexValuePairs] { k asif String |-> v asif ZZ32 }
     check(db2)
-    db3 = BIG UNION [i <- expect.indices()] { expect[v] asif String |-> v asif ZZ32 | v <- 0:i }
+    db3 = BIG UNION [i <- expect.indices] { expect[v] asif String |-> v asif ZZ32 | v <- 0:i }
     check(db3)
     assert(db.member("Empty"),Nothing[\ZZ32\],"absent member")
     assert(db.member("Empty",77),77,"absent member with default 77")
-    for (v,k) <- expect.indexValuePairs() do
+    for (v,k) <- expect.indexValuePairs do
         assert(db.member(k),Just[\ZZ32\](v),"present member")
         assert(db[k],v,"present member")

trunk/ProjectFortress/tests/ObjectToStringTest.fss

@@ -30 +30 @@
 run() : () = do
     r = object end
-    println(r.asString())
-    println(Foo(17,"Hello there").asString())
-    println(Fue[\ZZ32\](17,"Hello there").asString())
-    println(Bar(17,"Hello there").asString())
+    println(r.asString)
+    println(Foo(17,"Hello there").asString)
+    println(Fue[\ZZ32\](17,"Hello there").asString)
+    println(Bar(17,"Hello there").asString)
   end
 

trunk/ProjectFortress/tests/PureListQuick.fss

@@ -22 +22 @@
 assertStr[\T\](a:ZZ32, b:ZZ32, s:String, l: List[\T\]) =
   if a=/=b then
-    fail(a "=/=" b ": " s l.asString())
+    fail(a "=/=" b ": " s l.asString)
   end
 
 assertStr[\T\](a:Boolean, s:String, l: List[\T\]) =
   if NOT a then
-    fail("Failed assertion: " s l.asString())
+    fail("Failed assertion: " s l.asString)
   end
 
 assertStr[\T\](a:Boolean, s:String, l: List[\T\], r: List[\T\]) =
   if NOT a then
-    fail("Failed assertion: " s l.asString() " and " r.asString())
+    fail("Failed assertion: " s l.asString " and " r.asString)
   end
 
@@ -64 +64 @@
   ll : List[\ZZ32\] := l
   for i <- seq(0#sz) do
-      (e,ll0) = ll.extractLeft().get()
+      (e,ll0) = ll.extractLeft.get
       assertStr(e,i,"extractLeft wrong in ",ll)
-      assertStr(ll.left().get(),i,"left wrong in ",ll)
+      assertStr(ll.left.get,i,"left wrong in ",ll)
       ll := ll0
   end
-  assertStr(ll.isEmpty()," not empty after extractLeft(); it's ",ll)
+  assertStr(ll.isEmpty," not empty after extractLeft; it's ",ll)
   ll := l
   for i <- seq(1#sz) do
-      (ll0,e) = ll.extractRight().get()
+      (ll0,e) = ll.extractRight.get
       assertStr(e,sz-i,"extractRight wrong in ",ll)
-      assertStr(ll.right().get(),sz-i,"right wrong in ",ll)
+      assertStr(ll.right.get,sz-i,"right wrong in ",ll)
       ll := ll0
   end
-  assertStr(ll.isEmpty()," not empty after extractRight(); it's ",ll)
+  assertStr(ll.isEmpty," not empty after extractRight; it's ",ll)
 end
 
@@ -126 +126 @@
       chkPop(ivli,0,i,2)
       print(".")
-      rli=li.reverse()
+      rli=li.reverse
       for j <- 0#i do
           print(".")

trunk/ProjectFortress/tests/RangePrototype.fss

@@ -323 +323 @@
         assert(dumpShow(r),dumpShow(rr))
     end
-    for r <- pairFulls, (i1,i2) <- r.bounds() do
+    for r <- pairFulls, (i1,i2) <- r.bounds do
         assert(r[i1,i2] IN r, true, r,"[",i1,",",i2,"] = ",r[i1,i2]," not in")
     end
@@ -455 +455 @@
     end
     print("\nunlike ne")
-    for (i,rs) <- testScalarRangess.indexValuePairs(), ss <- testScalarRangess[0#i], r <- rs, s <- ss do
+    for (i,rs) <- testScalarRangess.indexValuePairs, ss <- testScalarRangess[0#i], r <- rs, s <- ss do
         assert(r=s, false, r, "=", s)
         assert(s=r, false, s, "=", r)
@@ -461 +461 @@
     end
     print("\ncommutativity of equality")
-    for rs <- testScalarRangess, (i,t) <- rs.indexValuePairs(), u <- rs[#i] do
+    for rs <- testScalarRangess, (i,t) <- rs.indexValuePairs, u <- rs[#i] do
         eq = (t=u)
         if eq =/= (u=t) then
@@ -502 +502 @@
     print("\nempty indexed")
     compactScalarRanges = <| c | r <- fullScalarRanges,
-                        c <- if r.stride()=1 then <|r,r.bounds()|> else <|r.bounds()|> end |>
+                        c <- if r.stride=1 then <|r,r.bounds|> else <|r.bounds|> end |>
     for i <- compactScalarRanges, i.isEmpty, j <- testScalarRanges do
         s = i.narrowToRange(j)

trunk/ProjectFortress/tests/Region.fss

@@ -29 +29 @@
     all[6] := "Howdy"
     assert(region(all).isLocalTo(Global))
-    for (i,v) <- all.indexValuePairs() do
+    for (i,v) <- all.indexValuePairs do
         assert(all.region(i).isLocalTo(region(all)))
         assert(region(v).isLocalTo(Global))

trunk/ProjectFortress/tests/SetTest.fss

@@ -67 +67 @@
     sets: (Set[\ZZ32\])[4] = [b c d e]
 
-    for s <- sets, (i,v') <- s.indexValuePairs() do
+    for s <- sets, (i,v') <- s.indexValuePairs do
         assert(i+1,v'," indexValuePairs wrong for ",s)
     end

trunk/ProjectFortress/tests/SkipListTest.fss

@@ -37 +37 @@
   database1 := add(database1, "Paul", 7)
 
-  println(database1.asString())
+  println(database1.asString)
   println(|database1|)
 
@@ -47 +47 @@
   database2 := add(database2, "Smeagol", 73)
 
-  println(database2.asString())
+  println(database2.asString)
   println(|database2|)
 
-  println(database1.merge(database2).asString())
+  println(database1.merge(database2).asString)
 
-  println(database1.asString())
+  println(database1.asString)
 
   database1 := remove(database1, "Emily")
-  println(database1.asString())
+  println(database1.asString)
   database1 := remove(database1, "David")
-  println(database1.asString())
+  println(database1.asString)
   database1 := remove(database1, "Nathi")
-  println(database1.asString())
+  println(database1.asString)
   database1 := remove(database1, "Paul")
-  println(database1.asString())
+  println(database1.asString)
   database1 := remove(database1, "John")
-  println(database1.asString())
+  println(database1.asString)
   database1 := remove(database1, "Cathy")
-  println(database1.asString())
+  println(database1.asString)
   println(|database1|)
 
@@ -76 +76 @@
   init("David", 3)
   init("David", 3)
-  println(database.asString())
+  println(database.asString)
   println(database.getSize())
   remove("David")
   remove("David")
   remove("David")
-  println(database.asString())
+  println(database.asString)
   println(database.getSize())
   remove("David")
   remove("David")
   remove("David")
-  println(database.asString())
+  println(database.asString)
   println(database.getSize())
   *)

trunk/ProjectFortress/tests/TransactionalArrayShakedown.fss

@@ -37 +37 @@
             fail(i " !!! " v)
         end
-    pre = SUM [(i,v)<-a.indexValuePairs()] body(i,v)
+    pre = SUM [(i,v)<-a.indexValuePairs] body(i,v)
     println(pre " pre and " (1000-pre) " post")
   end

trunk/ProjectFortress/tests/WordCountSmall.fss

@@ -49 +49 @@
     var start:ZZ32 := 0
 
-    while (current < s.size()) do
+    while (current < s.size) do
         if isDelimiter(s[current]) then
            count := count - 1

trunk/ProjectFortress/tests/array3test.fss

@@ -24 +24 @@
                                   17 18 19 20
                                   21 22 23 24 ]
-  cstr = c.asString()
+  cstr = c.asString
   assert(c.bounds, (0,0,0)#(3,4,2), "Bounds of c wrong")
   cexpect = "[0#3,0#4,0#2]\n[ 1 2 3 4\n  5 6 7 8\n  9 10 11 12 ;;\n  13 14 15 16\n  17 18 19 20\n  21 22 23 24 ]"
-  assert(cstr,cexpect,"asString() of Array3")
+  assert(cstr,cexpect,"asString of Array3")
   assert(c,c,"equality on Array3")
 end

trunk/ProjectFortress/tests/asifTest.fss

@@ -38 +38 @@
 
 object Bar extends Foo
-    asString(): String = "Bar"
+    getter asString(): String = "Bar"
     passFoo(): Boolean = false
     passBar(): Boolean = true
@@ -46 +46 @@
 
 object Baz extends Foo
-    asString(): String = "Baz"
+    getter asString(): String = "Baz"
     passFoo(): Boolean = false
     passQuux(): Boolean = false

trunk/ProjectFortress/tests/atomicList.fss

@@ -20 +20 @@
 
 trait List[\E\] comprises {Elem[\E\], Empty[\E\]}
+   getter isEmpty():Boolean
+   getter asString():()
    car():E
    cdr():List[\E\]
    cons(x:E):List[\E\]
-   isEmpty():Boolean
-   asString():()
    count():ZZ32
 end
@@ -31 +31 @@
 
 object Empty[\E\] extends List[\E\]
+   getter asString() = " Empty"
+   getter isEmpty() = true
    car():E = throw ListError("Empty List has no car")
    cdr():List[\E\] = throw ListError(" Empty List has no cdr")
    cons(z:E) =  Elem[\E\](z, self)
-   asString() = " Empty"
-   isEmpty() = true
    count() = 0
 end
 
 object Elem[\E\](val:E, rest:List[\E\]) extends List[\E\]
+   getter asString() = " " val ", " rest.asString
+   getter isEmpty() = false
    car():E = val
    cdr():List[\E\] = rest
    cons(z:E) = Elem[\E\](z,self)
-   asString() = " " val ", " rest.asString()
-   isEmpty() = false
    count() = 1 + cdr().count()
 end

trunk/ProjectFortress/tests/booleanGuard.fss

@@ -27 +27 @@
     assert(b,a.filter(fn (x)=>x>2)," x>2")
     d = <| x | x <- a, false |>
-    assert(d.isEmpty(), "not isEmpty false")
+    assert(d.isEmpty, "not isEmpty false")
     e = <| 17 | _ <- true |>
     assert(e,<|17|>,"true =/= <|17|>")

trunk/ProjectFortress/tests/deepHierarchy.fss

@@ -49 +49 @@
 
 object D0[\E\]() extends { Finger[\E\] }
-  asString() = "0"
+  getter asString() = "0"
 end
 

trunk/ProjectFortress/tests/extendAny.fss

@@ -23 +23 @@
 
 object Infinity extends Any
-  asString()="Infinity"
+  getter asString()="Infinity"
 end
 

trunk/ProjectFortress/tests/extendException.fss

@@ -22 +22 @@
 
 object Infinity extends Exception
-  asString() = "Infinity"
+  getter asString() = "Infinity"
 end
 

trunk/ProjectFortress/tests/fmTest2.fss

@@ -24 +24 @@
 object rat(i:ZZ32, j:ZZ32)
 
+  getter asString():String = "(" i ", " j ")"
   (* Not sure why, but "self.i" fails below *)
   opr OPLUS(self, other:rat):rat = rat(i OPLUS other.i, j OPLUS other.j)
@@ -30 +31 @@
   (* this next is not called, but it makes for a tricky overloading *)
   opr OTIMES(other:ZZ32, self):rat = rat(self.i OTIMES other, self.j OTIMES other)
-  asString():String = "(" i ", " j ")"
   area():ZZ32 = i OTIMES j
 end
@@ -36 +36 @@
 run():()=do
   a:rat = rat(1,0)
-  println a.asString()
+  println a.asString
 
   b:rat = rat(0,1)
-  println b.asString()
+  println b.asString
 
   c = a OPLUS b
-  println c.asString()
+  println c.asString
 
   d = c OTIMES (2 OTIMES 2)
-  println d.asString()
+  println d.asString
 
 end

trunk/ProjectFortress/tests/fmTest3.fss

@@ -24 +24 @@
 object rat[\T\](i:ZZ32, j:ZZ32)
 
+  getter asString():String = "(" i ", " j ")"
   (* Not sure why, but "self.i" fails below *)
   opr OPLUS(self, other:rat[\T\]):rat[\T\] = rat[\T\](i OPLUS other.i, j OPLUS other.j)
@@ -30 +31 @@
   (* this next is not called, but it makes for a tricky overloading *)
   opr OTIMES(other:ZZ32, self):rat[\T\] = rat[\T\](self.i OTIMES other, self.j OTIMES other)
-  asString():String = "(" i ", " j ")"
   area():ZZ32 = i OTIMES j
 end
@@ -38 +38 @@
 run():()=do
   a:rat[\S\] = rat[\S\](1,0)
-  println a.asString()
+  println a.asString
 
   b:rat[\S\] = rat[\S\](0,1)
-  println b.asString()
+  println b.asString
 
   c = a OPLUS b
-  println c.asString()
+  println c.asString
 
   d = c OTIMES (2 OTIMES 2)
-  println d.asString()
+  println d.asString
 
 end

trunk/ProjectFortress/tests/intPrim.fss

@@ -25 +25 @@
 run() = do
     a:ZZ32 = 0
-    tstEq("Minimum", a.minimum() - 1, a.maximum())
-    tstEq("Maximum", a.maximum() + 1, a.minimum())
+    tstEq("Minimum", a.minimum - 1, a.maximum)
+    tstEq("Maximum", a.maximum + 1, a.minimum)
     tstEq("Add",  124867 + -(234597), -109730 )
     tstEq("Sub",  124867 -  234597, -109730 )

trunk/ProjectFortress/tests/longPrim.fss

@@ -25 +25 @@
 run() = do
     a:ZZ64 = 0
-    tstEq("Minimum", a.minimum() - 1, a.maximum())
-    tstEq("Maximum", a.maximum() + 1, a.minimum())
+    tstEq("Minimum", a.minimum - 1, a.maximum)
+    tstEq("Maximum", a.maximum + 1, a.minimum)
     tstEq("Add",  widen(124867) + -(234597), widen(-109730) )
     tstEq("Sub",  widen(124867) -  234597, widen(-109730) )

trunk/ProjectFortress/tests/maybeTest.fss

@@ -23 +23 @@
   b = Just[\Boolean\](true)
   println(b)
-  assert(NOT a.holds(), "Nothing holds()")
-  assert(b.holds(),"NOT b.holds()")
-  if a then fail("Nothing holds() in if") end
+  assert(NOT a.holds, "Nothing holds")
+  assert(b.holds,"NOT b.holds")
+  if a then fail("Nothing holds in if") end
   if b then () else fail("b holds in if") end
   if r <- b then assert(r,"NOT r <- b (single clause)") end
   if r <- b then assert(r,"NOT r <- b") else fail("r<-b does not hold") end
-  assert(b.get(),"NOT b.get()")
+  assert(b.get,"NOT b.get")
   assert(a, Nothing[\ZZ32\], "nothing =/= nothing")
   deny(a, b, "nothing = just")
@@ -50 +50 @@
   end
   assert(times,1," WRONG number of times.")
-  assert(a.asString(),"Nothing","Nothing.asString()")
-  assert(b.asString(),"Just(true)", "Just(true).asString()")
+  assert(a.asString,"Nothing","Nothing.asString")
+  assert(b.asString,"Just(true)", "Just(true).asString")
 end
 

trunk/ProjectFortress/tests/naiveSeq.fss

@@ -28 +28 @@
 object NewRange(lo:ZZ32,sz:ZZ32) extends Generator[\ZZ32\]
   getter size() = sz
+  getter asString() = "[" lo "#" sz "]"
   opr |self| : ZZ32 = sz
-  asString() = "[" lo "#" sz "]"
   generate[\R\](r:Reduction[\R\], m:ZZ32->R): R =
     if sz < 1 then

trunk/ProjectFortress/tests/naturalsTest.fss

@@ -23 +23 @@
   b = Just[\Boolean\](true)
   println(b)
-  assert(NOT a.holds(), "Nothing holds()")
-  assert(b.holds(),"NOT b.holds()")
-  if a then fail("Nothing holds() in if") end
+  assert(NOT a.holds, "Nothing holds")
+  assert(b.holds,"NOT b.holds")
+  if a then fail("Nothing holds in if") end
   if b then () else fail("b holds in if") end
   if r <- b then assert(r,"NOT r <- b (single clause)") end
   if r <- b then assert(r,"NOT r <- b") else fail("r<-b does not hold") end
-  assert(b.get(),"NOT b.get()")
+  assert(b.get,"NOT b.get")
   assert(a, Nothing[\ZZ32\], "nothing =/= nothing")
   deny(a, b, "nothing = just")
@@ -50 +50 @@
   end
   assert(times,1," WRONG number of times.")
-  assert(a.asString(),"Nothing","Nothing.asString()")
-  assert(b.asString(),"Just(true)", "Just(true).asString()")
+  assert(a.asString,"Nothing","Nothing.asString")
+  assert(b.asString,"Just(true)", "Just(true).asString")
 end
 

trunk/ProjectFortress/tests/nestedInst.fss

@@ -28 +28 @@
 
 object D1[\E\]() extends { D14[\E\] }
-  asString()="1"
+  getter asString()="1"
 end
 
@@ -34 +34 @@
   println("Starting instantiation")
   e = D1[\ZZ32\]()
-  println(e.asString())
+  println(e.asString)
   ()
 end

trunk/ProjectFortress/tests/realArith.fss

@@ -35 +35 @@
   assert(x MIN z, x)
   assert(x MAX z, z)
-  assert((x MIN NaN).isNaN(), true)
-  assert((x MAX NaN).isNaN(), true)
+  assert((x MIN NaN).isNaN, true)
+  assert((x MAX NaN).isNaN, true)
   assert(-x, -14)
   assert(x + y, 28)
@@ -80 +80 @@
   assert(|/ -4.5 \|, -4)
   assert(truncate (-4.5), -4)
-  assert(x.isNaN(), false)
-  assert(x.isInfinite(), false)
-  assert(infinity.isInfinite(), true)
-  assert(x.isNumber(), true)
-  assert(x.isFinite(), true)
-  assert(infinity.isFinite(), false)
+  assert(x.isNaN, false)
+  assert(x.isInfinite, false)
+  assert(infinity.isInfinite, true)
+  assert(x.isNumber, true)
+  assert(x.isFinite, true)
+  assert(infinity.isFinite, false)
   assert(Just(7.0), Just(7.0))
   assert(Just(z), Just(z))
   (* If we do not give explicit type instantiation below, it fails... *)
-  assert(x.check(), Just[\RR64\](x))
-  assert(infinity.check(), Nothing[\RR64\])
-  assert(NaN.check(), Nothing[\RR64\])
+  assert(x.check, Just[\RR64\](x))
+  assert(infinity.check, Nothing[\RR64\])
+  assert(NaN.check, Nothing[\RR64\])
 
-  assert(x.check_star(), Just[\RR64\](x))
-  assert(infinity.check_star(), Just[\RR64\](infinity))
-  assert(NaN.check_star(), Nothing[\RR64\])
+  assert(x.check_star, Just[\RR64\](x))
+  assert(infinity.check_star, Just[\RR64\](infinity))
+  assert(NaN.check_star, Nothing[\RR64\])
 
   (* We want to implement hexadecimal literals. *)
-  assert((x / x).rawBits(), 4607182418800017408)
+  assert((x / x).rawBits, 4607182418800017408)
   assert(x MINNUM z, x)
   assert(x MAXNUM z, z)

trunk/ProjectFortress/tests/spuriousSelf.fss

@@ -32 +32 @@
 
 trait List[\E\] extends { Indexed[\E,ZZ32\] } excludes { Number, HasRank }
-  getter bounds(): Range[\ZZ32\] = 0#size()
+  getter bounds(): Range[\ZZ32\] = 0#self.size
 
   (*************************************************************

trunk/ProjectFortress/tests/subArray.fss

@@ -23 +23 @@
     lo = b.left.get - a.bounds.lower
     s = b.stride
-    for (i,v) <- a.indexValuePairs() do
+    for (i,v) <- a.indexValuePairs do
         assert(s i + lo, v, "a[", i, "]", a, b)
     end
@@ -30 +30 @@
 eqToRange2(a:Array[\ZZ32,(ZZ32,ZZ32)\], b:Range[\(ZZ32,ZZ32)\]): () = do
     assert(|a|, |b|, "Size mismatch",a,b)
-    (lo1, lo2) = b.lower()
-    for (i,v) <- a.indexValuePairs() do
+    (lo1, lo2) = b.lower
+    for (i,v) <- a.indexValuePairs do
       (x,y) = i
       assert(v, 3 (x + lo1) + y + lo2, "a[",x,",",y,"]")
@@ -39 +39 @@
 eqToRange3(a:Array[\ZZ32,(ZZ32,ZZ32,ZZ32)\], b:Range[\(ZZ32,ZZ32,ZZ32)\]): () = do
     assert(|a|, |b|, "Size mismatch",a,b)
-    (lo1, lo2, lo3) = b.lower()
-    for (i,v) <- a.indexValuePairs() do
+    (lo1, lo2, lo3) = b.lower
+    for (i,v) <- a.indexValuePairs do
       (x,y,z) = i
       assert(v, 2 (2 (z + lo3) + x + lo1) + y + lo2, "a[",x,",",y,",",z,"]",a,b)
@@ -74 +74 @@
 
     a2 : ZZ32[3,3] = [0 1 2 ; 3 4 5; 6 7 8]
-    eqToRange2(a2,a2.indices())
-    eqToRange2(a2[#],a2.indices())
+    eqToRange2(a2,a2.indices)
+    eqToRange2(a2[#],a2.indices)
     a2' = a2[(0,1)#(2,2)] (*'*)
     eqToRange2(a2',(0,1)#(2,2)) (*'*)
@@ -92 +92 @@
 
     a3 : ZZ32[2,2,2] = [0 1; 2 3;; 4 5 ; 6 7]
-    eqToRange3(a3,a3.indices())
-    eqToRange3(a3[:],a3.indices())
+    eqToRange3(a3,a3.indices)
+    eqToRange3(a3[:],a3.indices)
     eqToRange3(a3[(0,0,1)#(2,1,1)],(0,0,1)#(2,1,1))
     eqToRange3(a3[#(2,1,2)],(0,0,0)#(2,1,2))

trunk/ProjectFortress/tests/testRR32.fss

@@ -46 +46 @@
   assert(x MIN z, x)
   assert(x MAX z, z)
-  assert((x MIN NaN).isNaN(), true)
-  assert((x MAX NaN).isNaN(), true)
+  assert((x MIN NaN).isNaN, true)
+  assert((x MAX NaN).isNaN, true)
   assert(-x, narrow(-14.0))
   assert(x + y, sum)
@@ -80 +80 @@
   assert(|/ w \|, nfour)
   assert(truncate w, nfour)
-  assert(x.isNaN(), false)
-  assert(x.isInfinite(), false)
-  assert(infinity.isInfinite(), true)
-  assert(x.isNumber(), true)
-  assert(x.isFinite(), true)
-  assert(infinity.isFinite(), false)
+  assert(x.isNaN, false)
+  assert(x.isInfinite, false)
+  assert(infinity.isInfinite, true)
+  assert(x.isNumber, true)
+  assert(x.isFinite, true)
+  assert(infinity.isFinite, false)
   assert(Just(v), Just(v))
   assert(Just(z), Just(z))
   (* If we do not give explicit type instantiation below, it fails... *)
-  assert(x.check(), Just[\RR32\](x))
-  assert(infinity.check(), Nothing[\RR32\])
-  assert(NaN.check(), Nothing[\RR32\])
+  assert(x.check, Just[\RR32\](x))
+  assert(infinity.check, Nothing[\RR32\])
+  assert(NaN.check, Nothing[\RR32\])
 
-  assert(x.check_star(), Just[\RR32\](x))
-  assert(infinity.check_star(), Just[\RR32\](infinity))
-  assert(NaN.check_star(), Nothing[\RR32\])
+  assert(x.check_star, Just[\RR32\](x))
+  assert(infinity.check_star, Just[\RR32\](infinity))
+  assert(NaN.check_star, Nothing[\RR32\])
 
   (* We want to implement hexadecimal literals. *)
-  assert((x / x).rawBits(), 1065353216)
+  assert((x / x).rawBits, 1065353216)
   assert(x MINNUM z, x)
   assert(x MAXNUM z, z)

trunk/ProjectFortress/tests/testRecImport.fss

@@ -22 +22 @@
 
 object MyOdd extends Odd
+  getter asString():String = "MyOdd"
   anEven():Even = MyEven
-  asString():String = "MyOdd"
 end
 
 object MyEven extends Even
+  getter asString():String = "MyEven"
   anOdd():Odd = MyOdd
-  asString():String = "MyEven"
 end
 
@@ -38 +38 @@
     assert(even(-8),"even(-8)")
     assert(NOT odd(-8),"odd(-8)")
-    assert(MyOdd.asString(),"MyOdd", "MyOdd")
-    assert(MyEven.asString(),"MyEven", "MyEven")
-    assert(MyEven.anOdd().asString(),"MyOdd", "MyEven.anOdd")
-    assert(MyEven.anOdd().anEven().asString(),"MyEven", "MyEven.anOdd.anEven")
+    assert(MyOdd.asString,"MyOdd", "MyOdd")
+    assert(MyEven.asString,"MyEven", "MyEven")
+    assert(MyEven.anOdd().asString,"MyOdd", "MyEven.anOdd")
+    assert(MyEven.anOdd().anEven().asString,"MyEven", "MyEven.anOdd.anEven")
   end
 

trunk/ProjectFortress/tests/whileTest.fss

@@ -21 +21 @@
 
 neqOrMaybe(a: ReadableArray[\ZZ32,ZZ32\], i:ZZ32): Maybe[\(ZZ32,ZZ32)\] =
-    if i NOTIN a.bounds() OR: a[i] =/= i+7 then
+    if i NOTIN a.bounds OR: a[i] =/= i+7 then
         Nothing[\(ZZ32,ZZ32)\]
     else

trunk/ProjectFortress/tests/zeno.fss

@@ -99 +99 @@
 showHist():() = do
     mx = BIG MAX histogram
-    indexFieldWidth : ZZ32 = BIG MAX [(i,v) <- histogram.indexValuePairs(), v=/=0] |"" i| - 1
+    indexFieldWidth : ZZ32 = BIG MAX [(i,v) <- histogram.indexValuePairs, v=/=0] |"" i| - 1
     valueFieldWidth : ZZ32 = |"" mx| - 1
     println("mx = " mx)
     histogramLength = 75 - indexFieldWidth - valueFieldWidth
-    for (i,v) <- sequential(histogram.indexValuePairs()), v =/= 0 do
+    for (i,v) <- sequential(histogram.indexValuePairs), v =/= 0 do
         iAsString = "" i
         print(prepad(indexFieldWidth, iAsString) ": ")