Changeset 810

Timestamp:

Jul 29, 2012 9:59:49 AM (12 years ago)

Author:

Anya Helene Bagge

Message:

<-> => ==

Location:

trunk/magnolia-tests/src

Files:

• declarations (added)
• declarations/Procedures.mg (added)
• mutification/Mutification.mg (modified) (2 diffs)
• override/Override.mg (modified) (3 diffs)
• toplevel/Operators.mg (modified) (2 diffs)
• toplevel/Renaming.mg (modified) (2 diffs)

trunk/magnolia-tests/src/mutification/Mutification.mg

@@ -20 +20 @@
                 var tmp : Integer;
                 call two(tmp);
-                assert two() <-> tmp;
+                assert two() == tmp;
                 
                 call four(tmp);
-                assert four() <-> tmp;
+                assert four() == tmp;
         
                 var fortytwo = (one() + one() + one() + one()) * ten() + one() + one();
@@ -29 +29 @@
                 call add(tmp, one());
                 call add(tmp, one());
-                assert fortytwo <-> tmp;
+                assert fortytwo == tmp;
         }
 }

trunk/magnolia-tests/src/override/Override.mg

@@ -18 +18 @@
 
         procedure check() {
-                assert bar(zero()) <-> one() doc{should call procedure bar, returning one};
-                assert bar(one()) <-> one() doc{should call procedure bar, returning one};
-                assert bar(two()) <-> one() doc{should call procedure bar, returning one};
-                assert foo(zero()) <-> one() doc{should call default foo, calling function bar, returning one};
-                assert foo(one()) <-> one() doc{should call default foo, calling function bar, returning one};
-                assert foo(two()) <-> one() doc{should call default foo, calling function bar, returning one};
+                assert bar(zero()) == one() doc{should call procedure bar, returning one};
+                assert bar(one()) == one() doc{should call procedure bar, returning one};
+                assert bar(two()) == one() doc{should call procedure bar, returning one};
+                assert foo(zero()) == one() doc{should call default foo, calling function bar, returning one};
+                assert foo(one()) == one() doc{should call default foo, calling function bar, returning one};
+                assert foo(two()) == one() doc{should call default foo, calling function bar, returning one};
                 var x = one();
                 call bar(x);
-                assert x <-> one() doc{should call procedure bar, giving one};
+                assert x == one() doc{should call procedure bar, giving one};
         }
 }
@@ -40 +40 @@
         
         procedure check() {
-                assert bar(one()) <-> zero() doc{should call function bar, returning zero};
-                assert bar(zero()) <-> zero() doc{should call function bar, returning zero};
-                assert bar(two()) <-> zero() doc{should call function bar, returning zero};
-                assert foo(zero()) <-> zero() doc{should call default foo, calling bar, returning zero};
-                assert foo(one()) <-> zero() doc{should call default foo, calling bar, returning zero};
-                assert foo(two()) <-> zero() doc{should call default foo, calling bar, returning zero};
+                assert bar(one()) == zero() doc{should call function bar, returning zero};
+                assert bar(zero()) == zero() doc{should call function bar, returning zero};
+                assert bar(two()) == zero() doc{should call function bar, returning zero};
+                assert foo(zero()) == zero() doc{should call default foo, calling bar, returning zero};
+                assert foo(one()) == zero() doc{should call default foo, calling bar, returning zero};
+                assert foo(two()) == zero() doc{should call default foo, calling bar, returning zero};
                 var x = one();
                 call bar(x);
-                assert x <-> one() doc{should call procedure bar, giving one};
+                assert x == one() doc{should call procedure bar, giving one};
         }
 }
@@ -62 +62 @@
         
         procedure check() {
-                assert bar(zero()) <-> one() doc{should call procedure bar, returning one};
-                assert bar(one()) <-> one() doc{should call procedure bar, returning one};
-                assert bar(two()) <-> one() doc{should call procedure bar, returning one};
-                assert foo(zero()) <-> two() doc{should call default foo, calling bar, returning zero};
-                assert foo(one()) <-> two() doc{should call overridden foo, returning two};
-                assert foo(two()) <-> two() doc{should call overridden foo, calling bar, returning two};
+                assert bar(zero()) == one() doc{should call procedure bar, returning one};
+                assert bar(one()) == one() doc{should call procedure bar, returning one};
+                assert bar(two()) == one() doc{should call procedure bar, returning one};
+                assert foo(zero()) == two() doc{should call default foo, calling bar, returning zero};
+                assert foo(one()) == two() doc{should call overridden foo, returning two};
+                assert foo(two()) == two() doc{should call overridden foo, calling bar, returning two};
                 var x = one();
                 call bar(x);
-                assert x <-> one() doc{should call procedure bar, giving one};
+                assert x == one() doc{should call procedure bar, giving one};
         }
 }

trunk/magnolia-tests/src/toplevel/Operators.mg

@@ -3 +3 @@
 axiom renamed(decls : \decllist, decl : \decl, renaming : \renaming) {
         assert decl in decls => decl[renaming] in decls[renaming];
+}
+
+test testRenamed() {
+        assert renamed(A, A.foo, [foo => bar]);
 }
 
@@ -22 +26 @@
 }
 
-test testRenamed() {
-        assert renamed(A, A.foo, [foo => bar]);
-}
-
 concept A = {
         procedure foo() { call foo(); }

trunk/magnolia-tests/src/toplevel/Renaming.mg

@@ -1 +1 @@
 module toplevel.Renaming;
-
+/*
 concept A = {
         type A;
@@ -43 +43 @@
         assert CDArenamed == CDArenamed2;
 }
+
+
+implementation RenamingNameClash = {
+        type T;
+        function f(t : T) : T = t;
+        function g(t : T) : T = f(t);
+}[g => f]
+*/
+implementation Foo = 
+on signature {
+        type U;
+        function g(t : T) : T = f(t) ;
+}[g => f]
+defines {
+//      function f(t : T) : T = f(t);
+}
+
+implementation Bar = on {
+        type T;
+        function f(t : T) : T;
+}
+defines {} @ Baz[U => T]
+
+implementation Baz = on {
+        type U;
+        function f(t : U) : U;
+}
+defines {
+        function g(t : U) : U = f(t);
+}
+
+
+implementation A = defines {
+        type T;
+        function f(t : T) : T = t;
+        function g(t : T) : T = f(t);
+} 
+
+implementation B = (defines {
+        type T;
+        function f(t : T) : T = t;
+        function g(t : T) : T = f(t);
+        
+})  + extend A
+
+/*
+implementation C = defines {
+        type T;
+        function f(t : T) : T = t;
+        function h(t : T) : T = t;
+}
+*/