Version dependent error messages (#643)

* Fix error message in `complex()` for Python 3.5.3+ * Fix error for `chr()` and Python 3.6+ * Fix error message in bytes for Python 3.6+ * Fix unorderable types error messages * Fix error message for bytes `__add__` method Python 3.6+ * Linting issues * Change how `not_implemented_versions` is used There is an option to specify in which Python versions certain test cases would fail. Before this commit, versions would be specified as floats. This changes it from floats to strings, which seems more intuitive. * Fix error message for string `__add__` Python 3.6+ * Fix few version differences in json module * Small changes in few tests * Change format error message for Python 3.6 * Mark docstring tests as expected failure math module's docstring changed in Python 3.5. For now it's ok to mark respective tests as failing.
beeware · Aug 30, 2017 · c85d032 · c85d032
1 parent 439bebf
commit c85d032
Show file tree

Hide file tree

Showing 26 changed files with 1,332 additions and 126 deletions.
diff --git a/batavia/builtins/bytes.js b/batavia/builtins/bytes.js
@@ -3,6 +3,7 @@ var Buffer = require('buffer').Buffer
 var exceptions = require('../core').exceptions
 var callables = require('../core').callables
 var type_name = require('../core').type_name
+var constants = require('../core').constants
 var types = require('../types')
 var iter = require('./iter')
 
@@ -26,7 +27,19 @@ function bytes(args, kwargs) {
     } else if (args.length === 1) {
         var arg = args[0]
         if (arg === null) {
-            throw new exceptions.TypeError.$pyclass("'NoneType' object is not iterable")
+            switch (constants.BATAVIA_MAGIC) {
+                case constants.BATAVIA_MAGIC_34:
+                case constants.BATAVIA_MAGIC_35a0:
+                case constants.BATAVIA_MAGIC_35:
+                case constants.BATAVIA_MAGIC_353:
+                    throw new exceptions.TypeError.$pyclass(
+                        "'NoneType' object is not iterable"
+                    )
+                case constants.BATAVIA_MAGIC_36:
+                    throw new exceptions.TypeError.$pyclass(
+                        "cannot convert 'NoneType' object to bytes"
+                    )
+            }
         } else if (types.isinstance(arg, types.Int)) {
             // bytes(int) -> bytes array of size given by the parameter initialized with null bytes
             // Batavia ints are BigNumbers, so we need to unpack the value from the BigNumber Array.
@@ -98,9 +111,19 @@ function bytes(args, kwargs) {
             return new types.Bytes(Buffer.from(buffer_args))
         } else {
             // the argument is not one of the special cases, and not an iterable, so...
-            throw new exceptions.TypeError.$pyclass(
-            //    "'" + type_name(val) + "' object is not iterable");
-            "'" + type_name(arg) + "' object is not iterable")
+            switch (constants.BATAVIA_MAGIC) {
+                case constants.BATAVIA_MAGIC_34:
+                case constants.BATAVIA_MAGIC_35a0:
+                case constants.BATAVIA_MAGIC_35:
+                case constants.BATAVIA_MAGIC_353:
+                    throw new exceptions.TypeError.$pyclass(
+                        "'" + type_name(arg) + "' object is not iterable"
+                    )
+                case constants.BATAVIA_MAGIC_36:
+                    throw new exceptions.TypeError.$pyclass(
+                        "cannot convert '" + type_name(arg) + "' object to bytes"
+                    )
+            }
         }
     } else if (args.length >= 2 && args.length <= 3) {
         //    bytes(string, encoding[, errors]) -> bytes

diff --git a/batavia/builtins/chr.js b/batavia/builtins/chr.js
@@ -17,6 +17,7 @@ function chr(args, kwargs) {
             case constants.BATAVIA_MAGIC_35a0:
             case constants.BATAVIA_MAGIC_35:
             case constants.BATAVIA_MAGIC_353:
+            case constants.BATAVIA_MAGIC_36:
                 throw new exceptions.TypeError.$pyclass('chr() takes exactly one argument (' + args.length + ' given)')
 
             default:

diff --git a/batavia/core/exceptions.js b/batavia/core/exceptions.js
@@ -441,4 +441,13 @@ ZeroDivisionError.prototype.__class__.$pyclass = ZeroDivisionError
 
 exceptions.ZeroDivisionError = ZeroDivisionError.prototype.__class__
 
+var JSONDecodeError = function(msg) {
+    Exception.call(this, 'JSONDecodeError', msg)
+}
+JSONDecodeError.prototype = Object.create(Exception.prototype)
+JSONDecodeError.prototype.__class__ = new Type('JSONDecodeError', [Exception.prototype.__class__])
+JSONDecodeError.prototype.__class__.$pyclass = JSONDecodeError
+
+exceptions.JSONDecodeError = JSONDecodeError.prototype.__class__
+
 module.exports = exceptions
diff --git a/batavia/core/types/NoneType.js b/batavia/core/types/NoneType.js
@@ -4,6 +4,7 @@
 var PyObject = require('./Object')
 var basic_types = require('./Type')
 var exceptions = require('../exceptions')
+var constants = require('../constants')
 
 function NoneType() {
     PyObject.call(this)
@@ -48,11 +49,37 @@ NoneType.prototype.__setattr__ = function(attr, value) {
  **************************************************/
 
 NoneType.prototype.__lt__ = function(other) {
-    throw new exceptions.TypeError.$pyclass('unorderable types: NoneType() < ' + basic_types.type_name(other) + '()')
+    switch (constants.BATAVIA_MAGIC) {
+        case constants.BATAVIA_MAGIC_34:
+        case constants.BATAVIA_MAGIC_35a0:
+        case constants.BATAVIA_MAGIC_35:
+        case constants.BATAVIA_MAGIC_353:
+            throw new exceptions.TypeError.$pyclass(
+                'unorderable types: NoneType() < ' + basic_types.type_name(other) + '()'
+            )
+        case constants.BATAVIA_MAGIC_36:
+            throw new exceptions.TypeError.$pyclass(
+                "'<' not supported between instances of 'NoneType' and '" +
+                basic_types.type_name(other) + "'"
+            )
+    }
 }
 
 NoneType.prototype.__le__ = function(other) {
-    throw new exceptions.TypeError.$pyclass('unorderable types: NoneType() <= ' + basic_types.type_name(other) + '()')
+    switch (constants.BATAVIA_MAGIC) {
+        case constants.BATAVIA_MAGIC_34:
+        case constants.BATAVIA_MAGIC_35a0:
+        case constants.BATAVIA_MAGIC_35:
+        case constants.BATAVIA_MAGIC_353:
+            throw new exceptions.TypeError.$pyclass(
+                'unorderable types: NoneType() <= ' + basic_types.type_name(other) + '()'
+            )
+        case constants.BATAVIA_MAGIC_36:
+            throw new exceptions.TypeError.$pyclass(
+                "'<=' not supported between instances of 'NoneType' and '" +
+                basic_types.type_name(other) + "'"
+            )
+    }
 }
 
 NoneType.prototype.__eq__ = function(other) {
@@ -64,11 +91,37 @@ NoneType.prototype.__ne__ = function(other) {
 }
 
 NoneType.prototype.__gt__ = function(other) {
-    throw new exceptions.TypeError.$pyclass('unorderable types: NoneType() > ' + basic_types.type_name(other) + '()')
+    switch (constants.BATAVIA_MAGIC) {
+        case constants.BATAVIA_MAGIC_34:
+        case constants.BATAVIA_MAGIC_35a0:
+        case constants.BATAVIA_MAGIC_35:
+        case constants.BATAVIA_MAGIC_353:
+            throw new exceptions.TypeError.$pyclass(
+                'unorderable types: NoneType() > ' + basic_types.type_name(other) + '()'
+            )
+        case constants.BATAVIA_MAGIC_36:
+            throw new exceptions.TypeError.$pyclass(
+                "'>' not supported between instances of 'NoneType' and '" +
+                basic_types.type_name(other) + "'"
+            )
+    }
 }
 
 NoneType.prototype.__ge__ = function(other) {
-    throw new exceptions.TypeError.$pyclass('unorderable types: NoneType() >= ' + basic_types.type_name(other) + '()')
+    switch (constants.BATAVIA_MAGIC) {
+        case constants.BATAVIA_MAGIC_34:
+        case constants.BATAVIA_MAGIC_35a0:
+        case constants.BATAVIA_MAGIC_35:
+        case constants.BATAVIA_MAGIC_353:
+            throw new exceptions.TypeError.$pyclass(
+                'unorderable types: NoneType() >= ' + basic_types.type_name(other) + '()'
+            )
+        case constants.BATAVIA_MAGIC_36:
+            throw new exceptions.TypeError.$pyclass(
+                "'>=' not supported between instances of 'NoneType' and '" +
+                basic_types.type_name(other) + "'"
+            )
+    }
 }
 
 NoneType.prototype.__contains__ = function(other) {

diff --git a/batavia/core/types/NotImplementedType.js b/batavia/core/types/NotImplementedType.js
@@ -4,6 +4,7 @@
 var PyObject = require('./Object')
 var basic_types = require('./Type')
 var exceptions = require('../exceptions')
+var constants = require('../constants')
 
 function NotImplementedType() {
     PyObject.call(this)
@@ -42,11 +43,37 @@ NotImplementedType.prototype.__str__ = function() {
  **************************************************/
 
 NotImplementedType.prototype.__lt__ = function(other) {
-    throw new exceptions.TypeError.$pyclass('unorderable types: NotImplementedType() < ' + basic_types.type_name(other) + '()')
+    switch (constants.BATAVIA_MAGIC) {
+        case constants.BATAVIA_MAGIC_34:
+        case constants.BATAVIA_MAGIC_35a0:
+        case constants.BATAVIA_MAGIC_35:
+        case constants.BATAVIA_MAGIC_353:
+            throw new exceptions.TypeError.$pyclass(
+                'unorderable types: NotImplementedType() < ' + basic_types.type_name(other) + '()'
+            )
+        case constants.BATAVIA_MAGIC_36:
+            throw new exceptions.TypeError.$pyclass(
+                "'<' not supported between instances of 'NotImplementedType' and '" +
+                basic_types.type_name(other) + "'"
+            )
+    }
 }
 
 NotImplementedType.prototype.__le__ = function(other) {
-    throw new exceptions.TypeError.$pyclass('unorderable types: NotImplementedType() <= ' + basic_types.type_name(other) + '()')
+    switch (constants.BATAVIA_MAGIC) {
+        case constants.BATAVIA_MAGIC_34:
+        case constants.BATAVIA_MAGIC_35a0:
+        case constants.BATAVIA_MAGIC_35:
+        case constants.BATAVIA_MAGIC_353:
+            throw new exceptions.TypeError.$pyclass(
+                'unorderable types: NotImplementedType() <= ' + basic_types.type_name(other) + '()'
+            )
+        case constants.BATAVIA_MAGIC_36:
+            throw new exceptions.TypeError.$pyclass(
+                "'<=' not supported between instances of 'NotImplementedType' and '" +
+                basic_types.type_name(other) + "'"
+            )
+    }
 }
 
 NotImplementedType.prototype.__eq__ = function(other) {
@@ -58,11 +85,37 @@ NotImplementedType.prototype.__ne__ = function(other) {
 }
 
 NotImplementedType.prototype.__gt__ = function(other) {
-    throw new exceptions.TypeError.$pyclass('unorderable types: NotImplementedType() > ' + basic_types.type_name(other) + '()')
+    switch (constants.BATAVIA_MAGIC) {
+        case constants.BATAVIA_MAGIC_34:
+        case constants.BATAVIA_MAGIC_35a0:
+        case constants.BATAVIA_MAGIC_35:
+        case constants.BATAVIA_MAGIC_353:
+            throw new exceptions.TypeError.$pyclass(
+                'unorderable types: NotImplementedType() > ' + basic_types.type_name(other) + '()'
+            )
+        case constants.BATAVIA_MAGIC_36:
+            throw new exceptions.TypeError.$pyclass(
+                "'>' not supported between instances of 'NotImplementedType' and '" +
+                basic_types.type_name(other) + "'"
+            )
+    }
 }
 
 NotImplementedType.prototype.__ge__ = function(other) {
-    throw new exceptions.TypeError.$pyclass('unorderable types: NotImplementedType() >= ' + basic_types.type_name(other) + '()')
+    switch (constants.BATAVIA_MAGIC) {
+        case constants.BATAVIA_MAGIC_34:
+        case constants.BATAVIA_MAGIC_35a0:
+        case constants.BATAVIA_MAGIC_35:
+        case constants.BATAVIA_MAGIC_353:
+            throw new exceptions.TypeError.$pyclass(
+                'unorderable types: NotImplementedType() >= ' + basic_types.type_name(other) + '()'
+            )
+        case constants.BATAVIA_MAGIC_36:
+            throw new exceptions.TypeError.$pyclass(
+                "'>=' not supported between instances of 'NotImplementedType' and '" +
+                basic_types.type_name(other) + "'"
+            )
+    }
 }
 
 NotImplementedType.prototype.__contains__ = function(other) {

diff --git a/batavia/modules/json/decoder.js b/batavia/modules/json/decoder.js
@@ -3,6 +3,7 @@ var core = require('../../core')
 var PyObject = core.Object
 var exceptions = core.exceptions
 var callables = core.callables
+var constants = core.constants
 var validateParams = require('./utils').validateParams
 
 function JSONDecoder() {
@@ -63,7 +64,11 @@ JSONDecoder.prototype.decode = function(s) {
     try {
         ret = JSON.parse(s, reviver)
     } catch (e) {
-        throw new exceptions.ValueError.$pyclass(e.message)
+        if (constants.BATAVIA_MAGIC === constants.BATAVIA_MAGIC_34) {
+            throw new exceptions.ValueError.$pyclass(e.message)
+        } else {
+            throw new exceptions.JSONDecodeError.$pyclass(e.message)
+        }
     }
     return ret
 }
@@ -94,7 +99,6 @@ var loads = function(args, kwargs) {
     delete params['encoding']
     params['strict'] = true
 
-    // TODO(abonie): possible bug here? see test_cls in tests
     var dec = callables.call_function(cls, [], params)
     return callables.call_method(dec, 'decode', [s])
 }
@@ -132,5 +136,6 @@ load.$pyargs = true
 module.exports = {
     'loads': loads,
     'load': load,
+    'JSONDecodeError': exceptions.JSONDecodeError,
     'JSONDecoder': _JSONDecoder
 }
diff --git a/batavia/modules/json/encoder.js b/batavia/modules/json/encoder.js
@@ -2,6 +2,8 @@ var PyObject = require('../../core').Object
 var create_pyclass = require('../../core').create_pyclass
 var callables = require('../../core').callables
 var exceptions = require('../../core').exceptions
+var constants = require('../../core').constants
+var type_name = require('../../core').type_name
 var types = require('../../types')
 var builtins = require('../../builtins')
 var validateParams = require('./utils').validateParams
@@ -176,9 +178,19 @@ var make_encode = function(
             } else if (default_) {
                 ret = encode(callables.call_function(default_, [obj]), indent_level)
             } else {
-                throw new exceptions.TypeError.$pyclass(
-                    obj.toString() + ' is not JSON serializable'
-                )
+                switch (constants.BATAVIA_MAGIC) {
+                    case constants.BATAVIA_MAGIC_34:
+                    case constants.BATAVIA_MAGIC_35a0:
+                    case constants.BATAVIA_MAGIC_35:
+                    case constants.BATAVIA_MAGIC_353:
+                        throw new exceptions.TypeError.$pyclass(
+                            obj.toString() + ' is not JSON serializable'
+                        )
+                    case constants.BATAVIA_MAGIC_36:
+                        throw new exceptions.TypeError.$pyclass(
+                            "Object of type '" + type_name(obj) + "' is not JSON serializable"
+                        )
+                }
             }
 
             if (seen !== undefined) {