def test_args(self): from java.lang import String test = self class C(dynamic_proxy(TP.Args)): def tooMany(self): pass def tooFew(self, a): pass def addDuck(self, a, b): return a + b def star(self, *args): return ",".join(args) def varargs(self, delim, args): test.assertIsInstance(args, jarray(String)) return delim.join(args) c = C() c_Args = cast(TP.Args, c) with self.assertRaisesRegexp(PyException, args_error(1, 2)): c_Args.tooMany(42) with self.assertRaisesRegexp(PyException, args_error(2, 1)): c_Args.tooFew() self.assertEqual(3, c_Args.addDuck(jint(1), jint(2))) self.assertAlmostEqual(3.5, c_Args.addDuck(jfloat(1), jfloat(2.5))) self.assertEqual("helloworld", c_Args.addDuck("hello", "world")) self.assertEqual("", c_Args.star()) self.assertEqual("hello", c_Args.star("hello")) self.assertEqual("hello,world", c_Args.star("hello", "world")) with self.assertRaisesRegexp(TypeError, "cannot be applied"): c_Args.star("hello", "world", "again") self.assertEqual("hello,world,again", c.star("hello", "world", "again")) with self.assertRaisesRegexp(TypeError, args_error(1, 0, varargs=True)): c_Args.varargs() self.assertEqual("", c_Args.varargs(":")) self.assertEqual("hello", c_Args.varargs("|", "hello")) self.assertEqual("hello|world", c_Args.varargs("|", "hello", "world"))
def test_primitive(self): obj = jclass("com.chaquo.python.TestOverload$Primitive")() self.assertEqual(obj.resolve(True), 'boolean true') self.assertEqual(obj.resolve(jboolean(True)), 'boolean true') self.assertEqual(obj.resolve(42), 'long 42') self.assertEqual(obj.resolve(jbyte(42)), 'byte 42') self.assertEqual(obj.resolve(jshort(42)), 'short 42') self.assertEqual(obj.resolve(jint(42)), 'int 42') self.assertEqual(obj.resolve(jlong(42)), 'long 42') self.assertEqual(obj.resolve(1.23), 'double 1.23') self.assertEqual(obj.resolve(jfloat(1.23)), 'float 1.23') self.assertEqual(obj.resolve(jdouble(1.23)), 'double 1.23') # When passing an int, applicable integral overloads should be preferred over floating # overloads no matter what the value is. self.assertEqual(obj.resolve_SF(42), 'short 42') with self.too_big: obj.resolve_SF(100000) self.assertEqual(obj.resolve_SF(float(100000)), 'float 100000.0') self.assertEqual(obj.resolve_IJ(42), 'long 42') self.assertEqual(obj.resolve_IJ(jbyte(42)), 'int 42') self.assertEqual(obj.resolve_IJ(jshort(42)), 'int 42') self.assertEqual(obj.resolve_IJ(jint(42)), 'int 42') self.assertEqual(obj.resolve_IJ(jlong(42)), 'long 42') self.assertEqual(obj.resolve_BIF(42), 'int 42') self.assertEqual(obj.resolve_BIF(jbyte(42)), 'byte 42') self.assertEqual(obj.resolve_BIF(jshort(42)), 'int 42') self.assertEqual(obj.resolve_BIF(jint(42)), 'int 42') self.assertEqual(obj.resolve_BIF(jlong(42)), 'float 42.0') self.assertEqual(obj.resolve_BIF(jfloat(42)), 'float 42.0') with self.inapplicable: obj.resolve_BIF(jdouble(42)) # This may seem inconsistent, but it's what Java does. float and double are both # applicable when passing an int, and float is more specific. self.assertEqual(obj.resolve_FD(42), 'float 42.0') self.assertEqual(obj.resolve_FD(42.0), 'double 42.0') self.assertEqual(obj.resolve_FD(jdouble(42)), 'double 42.0')
def test_boxing(self): obj = jclass("com.chaquo.python.TestOverload$Boxing")() Boolean = jclass("java.lang.Boolean") self.assertEqual(obj.resolve_Z_Boolean(True), 'boolean true') self.assertEqual(obj.resolve_Z_Boolean(jboolean(True)), 'boolean true') self.assertEqual(obj.resolve_Z_Boolean(Boolean(True)), 'Boolean true') self.assertEqual(obj.resolve_Z_Object(True), 'boolean true') self.assertEqual(obj.resolve_Z_Object(jboolean(True)), 'boolean true') self.assertEqual(obj.resolve_Z_Object(Boolean(True)), 'Object true') Long = jclass("java.lang.Long") Short = jclass("java.lang.Short") # When passing a primitive, applicable primitive overloads should be preferred over # boxed overloads no matter what the value is. self.assertEqual(obj.resolve_S_Long(42), 'short 42') with self.too_big: obj.resolve_S_Long(100000) self.assertEqual(obj.resolve_S_Long(jlong(100000)), 'Long 100000') self.assertEqual(obj.resolve_S_Long(jbyte(42)), 'short 42') self.assertEqual(obj.resolve_S_Long(jshort(42)), 'short 42') with self.inapplicable: # Automatic primitive conversion cannot be combined with autoboxing (JLS 5.3). obj.resolve_S_Long(jint(42)) self.assertEqual(obj.resolve_S_Long(jlong(42)), 'Long 42') self.assertEqual(obj.resolve_S_Long(Long(42)), 'Long 42') with self.inapplicable: # Auto-unboxing is not currently implemented. obj.resolve_S_Long(Short(42)) self.assertEqual(obj.resolve_Short_L(42), 'long 42') self.assertEqual(obj.resolve_Short_L(100000), 'long 100000') self.assertEqual(obj.resolve_Short_L(jbyte(42)), 'long 42') self.assertEqual(obj.resolve_Short_L(jshort(42)), 'long 42') self.assertEqual(obj.resolve_Short_L(jint(42)), 'long 42') self.assertEqual(obj.resolve_Short_L(jlong(42)), 'long 42') self.assertEqual(obj.resolve_Short_L(Short(42)), 'Short 42') with self.ambiguous: obj.resolve_Short_Long(42) with self.too_big: # It would be better to give an ambiguous overload error, but this message should # be clear enough to indicate that the short overload is being considered, and the # programmer can then use a wrapper to exclude it. obj.resolve_Short_Long(100000) with self.inapplicable: obj.resolve_Short_Long(jbyte(42)) self.assertEqual(obj.resolve_Short_Long(jshort(42)), 'Short 42') with self.inapplicable: obj.resolve_Short_Long(jint(42)) self.assertEqual(obj.resolve_Short_Long(jlong(42)), 'Long 42') self.assertEqual(obj.resolve_Short_Long(jlong(100000)), 'Long 100000') with self.ambiguous: obj.resolve_Integer_Float(42) self.assertEqual(obj.resolve_Integer_Float(42.0), 'Float 42.0') self.assertEqual(obj.resolve_Integer_Float(jfloat(42)), 'Float 42.0') with self.ambiguous: obj.resolve_Float_Double(42) with self.ambiguous: obj.resolve_Float_Double(42.0) with self.inapplicable: obj.resolve_Float_Double(jint(42)) self.assertEqual(obj.resolve_Float_Double(jfloat(42)), 'Float 42.0') self.assertEqual(obj.resolve_Float_Double(jdouble(42)), 'Double 42.0')