[GR-10393] make test weakset run

PullRequest: graalpython/83

Author: cosminbasca

graalpython/com.oracle.graal.python.test/src/python_unittests.py

@@ -54,8 +54,11 @@
 # constants
 PATH_UNITTESTS = "graalpython/lib-python/3/test/"
 
-CSV_RESULTS_NAME = "unittests.csv"
-HTML_RESULTS_NAME = "unittests.html"
+_BASE_NAME = "unittests"
+TXT_RESULTS_NAME = "{}.txt".format(_BASE_NAME)
+CSV_RESULTS_NAME = "{}.csv".format(_BASE_NAME)
+HTML_RESULTS_NAME = "{}.html".format(_BASE_NAME)
+
 
 PTRN_ERROR = re.compile(r'^(?P<error>[A-Z][a-z][a-zA-Z]+):(?P<message>.*)$')
 PTRN_UNITTEST = re.compile(r'^#### running: graalpython/lib-python/3/test/(?P<unittest>.*)$')
@@ -117,7 +120,7 @@ def scp(results_file_path, destination_path, destination_name=None):
 
 
 def _run_unittest(test_path):
-    cmd = ["mx", "python3", "--python.CatchAllExceptions=true", test_path]
+    cmd = ["mx", "python3", "--python.CatchAllExceptions=true", test_path, "-v"]
     success, output = _run_cmd(cmd)
     output = '''
 ##############################################################
@@ -278,6 +281,13 @@ class Stat(object):
     TEST_PERCENT_PASS = "test_percent_pass"  # percentage of tests which pass from all running tests (all unittests)
 
 
+def save_as_txt(report_path, results):
+    with open(report_path, 'w') as TXT:
+        output = '\n'.join(results)
+        TXT.write(output)
+        return output
+
+
 def save_as_csv(report_path, unittests, error_messages, stats, current_date):
     rows = []
     with open(report_path, 'w') as CSV:
@@ -595,7 +605,10 @@ def _fmt(t):
         unittests = get_unittests(flags.tests_path, limit=flags.limit)
 
     results = run_unittests(unittests)
-    unittests, error_messages, stats = process_output('\n'.join(results))
+    txt_report_path = file_name(TXT_RESULTS_NAME, current_date)
+    output = save_as_txt(txt_report_path, results)
+
+    unittests, error_messages, stats = process_output(output)
 
     csv_report_path = file_name(CSV_RESULTS_NAME, current_date)
     rows, totals = save_as_csv(csv_report_path, unittests, error_messages, stats, current_date)
@@ -608,6 +621,7 @@ def _fmt(t):
 
     if flags.path:
         log("[SAVE] saving results to {} ... ", flags.path)
+        scp(txt_report_path, flags.path)
         scp(csv_report_path, flags.path)
         scp(html_report_path, flags.path)
 

graalpython/com.oracle.graal.python.test/src/tests/test_pyio.py

@@ -170,5 +170,7 @@ def test_builtin_open():
     except Exception as e:
         print(e)
         success = False
+    finally:
+        unlink(file_name)
 
     assert success

graalpython/com.oracle.graal.python.test/src/tests/test_set.py

@@ -39,6 +39,24 @@
 # Iterating by Sequence Index
 
 
+def assert_raises(err, fn, *args, **kwargs):
+    raised = False
+    try:
+        fn(*args, **kwargs)
+    except err:
+        raised = True
+    assert raised
+
+
+class PassThru(Exception):
+    pass
+
+
+def check_pass_thru():
+    raise PassThru
+    yield 1
+
+
 def test_set_or():
     s1 = {1, 2, 3}
     s2 = {4, 5, 6}
@@ -65,3 +83,64 @@ def test_set_remove():
 def test_set_le():
     assert set("a") <= set("abc")
 
+
+def test_difference():
+    word = 'simsalabim'
+    otherword = 'madagascar'
+    letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    s = set(word)
+    d = dict.fromkeys(word)
+
+    i = s.difference(otherword)
+    for c in letters:
+        assert (c in i) == (c in d and c not in otherword)
+
+    assert s == set(word)
+    assert type(i) == set
+    assert_raises(PassThru, s.difference, check_pass_thru())
+    assert_raises(TypeError, s.difference, [[]])
+
+    for C in set, frozenset, dict.fromkeys, str, list, tuple:
+        assert set('abcba').difference(C('cdc')) == set('ab')
+        assert set('abcba').difference(C('efgfe')) == set('abc')
+        assert set('abcba').difference(C('ccb')) == set('a')
+        assert set('abcba').difference(C('ef')) == set('abc')
+        assert set('abcba').difference() == set('abc')
+        assert set('abcba').difference(C('a'), C('b')) == set('c')
+
+
+def test_difference_update():
+    word = 'simsalabim'
+    otherword = 'madagascar'
+    s = set(word)
+
+    retval = s.difference_update(otherword)
+    assert retval == None
+
+    for c in (word + otherword):
+        if c in word and c not in otherword:
+            assert c in s
+        else:
+            assert c not in s
+
+    assert_raises(PassThru, s.difference_update, check_pass_thru())
+    assert_raises(TypeError, s.difference_update, [[]])
+    # assert_raises(TypeError, s.symmetric_difference_update, [[]])
+
+    for p, q in (('cdc', 'ab'), ('efgfe', 'abc'), ('ccb', 'a'), ('ef', 'abc')):
+        for C in set, frozenset, dict.fromkeys, str, list, tuple:
+            s = set('abcba')
+            assert s.difference_update(C(p)) == None
+            assert s == set(q)
+
+            s = set('abcdefghih')
+            s.difference_update()
+            assert s == set('abcdefghih')
+
+            s = set('abcdefghih')
+            s.difference_update(C('aba'))
+            assert s == set('cdefghih')
+
+            s = set('abcdefghih')
+            s.difference_update(C('cdc'), C('aba'))
+            assert s == set('efghih')

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/WeakRefModuleBuiltins.java

@@ -48,7 +48,10 @@
 import com.oracle.graal.python.builtins.objects.function.PFunction;
 import com.oracle.graal.python.builtins.objects.object.PythonObject;
 import com.oracle.graal.python.builtins.objects.referencetype.PReferenceType;
+import com.oracle.graal.python.builtins.objects.type.PythonClass;
 import com.oracle.graal.python.nodes.function.PythonBuiltinNode;
+import com.oracle.graal.python.runtime.exception.PythonErrorType;
+import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
 import com.oracle.truffle.api.dsl.NodeFactory;
 import com.oracle.truffle.api.dsl.Specialization;
@@ -65,15 +68,19 @@ protected List<? extends NodeFactory<? extends PythonBuiltinNode>> getNodeFactor
     @Builtin(name = "ReferenceType", minNumOfArguments = 2, maxNumOfArguments = 3, constructsClass = PReferenceType.class)
     @GenerateNodeFactory
     public abstract static class ReferenceTypeNode extends PythonBuiltinNode {
-
         @Specialization
-        public PReferenceType refType(Object cls, PythonObject pythonObject, PNone none) {
-            return factory().createReferenceType(pythonObject, null);
+        public PReferenceType refType(PythonClass cls, PythonObject pythonObject, PNone none) {
+            return factory().createReferenceType(cls, pythonObject, null);
         }
 
         @Specialization
-        public PReferenceType refType(Object cls, PythonObject pythonObject, PFunction callback) {
-            return factory().createReferenceType(pythonObject, callback);
+        public PReferenceType refType(PythonClass cls, PythonObject pythonObject, PFunction callback) {
+            return factory().createReferenceType(cls, pythonObject, callback);
+        }
+
+        @Fallback
+        public PReferenceType refType(Object cls, Object object, Object callback) {
+            throw raise(PythonErrorType.TypeError, "cannot create weak reference to '%p' object", object);
         }
     }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/referencetype/PReferenceType.java

@@ -38,12 +38,10 @@
  */
 package com.oracle.graal.python.builtins.objects.referencetype;
 
-import static com.oracle.graal.python.runtime.exception.PythonErrorType.TypeError;
-
 import java.lang.ref.WeakReference;
 
-import com.oracle.graal.python.PythonLanguage;
 import com.oracle.graal.python.builtins.objects.PNone;
+import com.oracle.graal.python.builtins.objects.PythonAbstractObject;
 import com.oracle.graal.python.builtins.objects.function.PArguments;
 import com.oracle.graal.python.builtins.objects.function.PFunction;
 import com.oracle.graal.python.builtins.objects.object.PythonBuiltinObject;
@@ -89,54 +87,44 @@ protected void finalize() throws Throwable {
     }
 
     private final WeakRefStorage store;
+    private int hash = -1;
 
     @TruffleBoundary
     public PReferenceType(PythonClass cls, PythonObject pythonObject, PFunction callback) {
         super(cls);
         this.store = new WeakRefStorage(this, pythonObject, callback);
     }
 
-    public Object __callback__() {
+    public Object getCallback() {
         if (this.store.callback == null) {
             return PNone.NONE;
         }
         return this.store.callback;
     }
 
     @TruffleBoundary
-    public Object __call__() {
-        Object referent = this.store.get();
-        return (referent == null) ? PNone.NONE : referent;
+    public PythonObject getObject() {
+        return this.store.get();
     }
 
-    @TruffleBoundary
-    public int getWeakRefCount() {
-        return (this.store.get() == null) ? 0 : 1;
+    public PythonAbstractObject getPyObject() {
+        PythonObject object = getObject();
+        return (object == null) ? PNone.NONE : object;
     }
 
-    @Override
-    public String toString() {
-        return "<" + pythonClass.getName() + " object at " + hashCode() + ">";
+    public int getWeakRefCount() {
+        return (this.getObject() == null) ? 0 : 1;
     }
 
-    @Override
-    @TruffleBoundary
-    public int hashCode() {
-        PythonObject referent = store.get();
-        if (referent != null) {
-            return referent.hashCode();
+    public int getHash() {
+        if (this.hash != -1) {
+            return this.hash;
         }
-        throw PythonLanguage.getCore().raise(TypeError);
-    }
 
-    @Override
-    @TruffleBoundary
-    public boolean equals(Object obj) {
-        PythonObject referent = store.get();
-        if (referent != null) {
-            return referent.equals(obj);
+        PythonObject object = getObject();
+        if (object != null) {
+            this.hash = object.hashCode();
         }
-        throw PythonLanguage.getCore().raise(TypeError);
+        return this.hash;
     }
-
 }