[pypy-svn] r24677 - pypy/dist/pypy/objspace/test

[auc at codespeak.net]

Author: auc
Date: Tue Mar 21 14:52:03 2006
New Revision: 24677

Modified:
   pypy/dist/pypy/objspace/test/test_logicobjspace.py
Log:
updated tests


Modified: pypy/dist/pypy/objspace/test/test_logicobjspace.py
==============================================================================
--- pypy/dist/pypy/objspace/test/test_logicobjspace.py	(original)
+++ pypy/dist/pypy/objspace/test/test_logicobjspace.py	Tue Mar 21 14:52:03 2006
@@ -5,7 +5,7 @@
     def setup_class(cls):
         cls.space = gettestobjspace('logic')
 
-    def test_simple(self):
+    def test_simple_bind(self):
         X = newvar()
         assert is_free(X)
         bind(X, 1)
@@ -14,7 +14,7 @@
         assert is_bound(1)
         raises(TypeError, bind, 1, 2)
 
-    def test_setitem(self):
+    def test_setitem_bind(self):
         x = newvar()
         d = {5: x}
         d[6] = x
@@ -27,7 +27,14 @@
         for x in [d[5], d[6], d[7][0]]:
             assert is_bound(d[5])
 
-    def test_unbound_unification_simple(self):
+    def test_bind_to_self(self):
+        X = newvar()
+        assert is_free(X)
+        bind(X, X)
+        bind(X, 1)
+        assert X == 1
+
+    def test_bind_aliased(self):
         X = newvar()
         Y = newvar()
         bind(X, Y)
@@ -49,32 +56,32 @@
             return x + 1
         raises(RuntimeError, f, X)
 
-    def test_bind_to_self(self):
-        X = newvar()
-        bind(X, X)
-        bind(X, 1)
-        assert X == 1
 
     def test_eq_unifies_simple(self):
         X = newvar()
         Y = newvar()
-        assert X == Y
+        unify(X, Y)
+        unify(X, 1)
         assert X == 1
         assert is_bound(Y)
         assert Y == 1
+        assert X == Y
 
-    def test_ne_of_unified_vars(self):
+    def test_ne_of_unified_unbound_vars(self):
         X = newvar()
         Y = newvar()
+        unify(X, Y)
         assert X == Y
         assert not X != Y
 
     def test_cmp(self):
         X = newvar()
         Y = newvar()
+        unify(X, Y)
         assert cmp(X, Y) == 0
         assert is_free(X)
         assert is_free(Y)
+        unify(X, 1)
         assert X == 1
         assert is_bound(Y)
         assert Y == 1
@@ -82,7 +89,82 @@
     def test_is(self):
         X = newvar()
         x = 1
-        assert X is x
+        assert 1 is 1
+        assert not(2 is 1)
+        assert X is X
+        bind(X, x)
         assert X == 1
         assert X is x
+        assert not(X is 2)
+
+    def test_unify_free(self):
+        X, Y = newvar(), newvar()
+        unify(X, Y)
+        assert X == Y
+        unify(X, 1)
+        assert X == 1
+        assert Y == 1
+        
+        
+
+class AppTest_LogicThreads(object):
+
+    def setup_class(cls):
+        cls.space = gettestobjspace('logic')
+
+
+    def notest_eager_producer_consummer(self):
+
+        def generate(n, limit):
+            print "generate", n, limit
+            if n < limit:
+                return (n, generate(n + 1, limit))
+            return (None, None)
+
+        def sum(L, a):
+            print "sum", a
+            head, Tail = newvar(), newvar()
+            unify(L, (head, Tail))
+            if head != None:
+                return sum(Tail, head + a)
+            return a
+
+        X = newvar()
+        S = newvar()
+        unify(S, uthread(sum, X, 0))
+        unify(X, uthread(generate, 0, 10))
+
+        assert S == 45
+
+
+    def notest_lazy_producer_consummer(self):
+
+        def lgenerate(n, L):
+            """wait-needed version of generate"""
+            print "generator waits on L being needed"
+            wait_needed(L)
+            Tail = newvar()
+            L == (n, Tail)
+            print "generator bound L to", L
+            lgenerate(n+1, Tail)
+
+        def lsum(L, a, limit):
+            """this version of sum controls the generator"""
+            print "sum", a
+            if limit > 0:
+                Head, Tail = newvar(), newvar()
+                print "sum waiting on L"
+                L == (Head, Tail) # or Head, Tail == L ?
+                return lsum(Tail, a+Head, limit-1)
+            else:
+                return a
+
+        print "lazy producer consummer"
+        print "before"
+        Y = newvar()
+        T = newvar()
+        uthread(lgenerate, 0, Y)
+        T == uthread(lsum, Y, 0, 10)
+        print "after"
 
+        print T