even more unit tests

tests/java-src/org/jnius/ChildVisibilityTest.java

@@ -0,0 +1,65 @@
+package org.jnius;
+
+import java.lang.String;
+
+public class ChildVisibilityTest extends VisibilityTest {
+    public String fieldChildPublic = "ChildPublic";
+    protected String fieldChildProtected = "ChildProtected";
+    private String fieldChildPrivate = "ChildPrivate";
+
+    static public String fieldChildStaticPublic = "ChildStaticPublic";
+    static protected String fieldChildStaticProtected = "ChildStaticProtected";
+    static private String fieldChildStaticPrivate = "ChildStaticPrivate";
+
+    public String methodChildPublic() {
+        return fieldChildPublic;
+    }
+
+    protected String methodChildProtected() {
+        return fieldChildProtected;
+    }
+
+    private String methodChildPrivate() {
+        return fieldChildPrivate;
+    }
+
+    protected boolean methodMultiArgs(boolean a, boolean b) {
+        return a & !b;
+    }
+
+    private boolean methodMultiArgs(boolean a, boolean b, boolean c) {
+        return a & !b & c;
+    }
+
+    // dummy method to avoid warning about unused methods
+    public String methodChildDummy() {
+        this.methodMultiArgs(true, true, false);
+        return this.methodChildPrivate();
+    }
+
+    static public String methodChildStaticPublic() {
+        return fieldChildStaticPublic;
+    }
+
+    static protected String methodChildStaticProtected() {
+        return fieldChildStaticProtected;
+    }
+
+    static private String methodChildStaticPrivate() {
+        return fieldChildStaticPrivate;
+    }
+
+    static protected boolean methodStaticMultiArgs(boolean a, boolean b) {
+        return a & !b;
+    }
+
+    static private boolean methodStaticMultiArgs(boolean a, boolean b, boolean c) {
+        return a & !b & c;
+    }
+
+    // dummy method to avoid warning about unused methods
+    static public String methodChildStaticDummy() {
+        ChildVisibilityTest.methodStaticMultiArgs(true, true, true);
+        return ChildVisibilityTest.methodChildStaticPrivate();
+    }
+}

tests/java-src/org/jnius/VisibilityTest.java

@@ -23,6 +23,10 @@ public class VisibilityTest {
         return fieldPrivate;
     }
 
+    public boolean methodMultiArgs(boolean a) {
+        return a;
+    }
+
     // dummy method to avoid warning methodPrivate() isn't used
     public String methodDummy() {
         return this.methodPrivate();
@@ -40,6 +44,10 @@ public class VisibilityTest {
         return fieldStaticPrivate;
     }
 
+    static public boolean methodStaticMultiArgs(boolean a) {
+        return a;
+    }
+
     // dummy method to avoid warning methodStaticPrivate() isn't used
     static public String methodStaticDummy() {
         return VisibilityTest.methodStaticPrivate();

tests/test_visibility_all.py

@@ -4,6 +4,7 @@ from __future__ import absolute_import
 import sys
 import unittest
 import jnius_config
+from jnius import JavaMultipleMethod
 from jnius.reflect import autoclass
 
 
@@ -23,7 +24,6 @@ def py2_encode(uni):
 class VisibilityAllTest(unittest.TestCase):
 
     def test_static_fields_all(self):
-
         Test = autoclass('org.jnius.VisibilityTest', include_protected=True, include_private=True)
 
         self.assertTrue(hasattr(Test, 'fieldStaticPublic'))
@@ -34,8 +34,26 @@ class VisibilityAllTest(unittest.TestCase):
         self.assertEqual(Test.fieldStaticProtected, py2_encode("StaticProtected"))
         self.assertEqual(Test.fieldStaticPrivate, py2_encode("StaticPrivate"))
 
-    def test_static_methods_all(self):
+    def test_child_static_fields_all(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=True)
 
+        self.assertTrue(hasattr(Test, 'fieldStaticPublic'))
+        self.assertTrue(hasattr(Test, 'fieldStaticProtected'))
+        self.assertTrue(hasattr(Test, 'fieldStaticPrivate'))
+
+        self.assertEqual(Test.fieldStaticPublic, py2_encode("StaticPublic"))
+        self.assertEqual(Test.fieldStaticProtected, py2_encode("StaticProtected"))
+        self.assertEqual(Test.fieldStaticPrivate, py2_encode("StaticPrivate"))
+
+        self.assertTrue(hasattr(Test, 'fieldChildStaticPublic'))
+        self.assertTrue(hasattr(Test, 'fieldChildStaticProtected'))
+        self.assertTrue(hasattr(Test, 'fieldChildStaticPrivate'))
+
+        self.assertEqual(Test.fieldChildStaticPublic, py2_encode("ChildStaticPublic"))
+        self.assertEqual(Test.fieldChildStaticProtected, py2_encode("ChildStaticProtected"))
+        self.assertEqual(Test.fieldChildStaticPrivate, py2_encode("ChildStaticPrivate"))
+
+    def test_static_methods_all(self):
         Test = autoclass('org.jnius.VisibilityTest', include_protected=True, include_private=True)
 
         self.assertTrue(hasattr(Test, 'methodStaticPublic'))
@@ -46,8 +64,26 @@ class VisibilityAllTest(unittest.TestCase):
         self.assertEqual(Test.methodStaticProtected(), py2_encode("StaticProtected"))
         self.assertEqual(Test.methodStaticPrivate(), py2_encode("StaticPrivate"))
 
-    def test_fields_all(self):
+    def test_child_static_methods_all(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=True)
 
+        self.assertTrue(hasattr(Test, 'methodStaticPublic'))
+        self.assertTrue(hasattr(Test, 'methodStaticProtected'))
+        self.assertTrue(hasattr(Test, 'methodStaticPrivate'))
+
+        self.assertEqual(Test.methodStaticPublic(), py2_encode("StaticPublic"))
+        self.assertEqual(Test.methodStaticProtected(), py2_encode("StaticProtected"))
+        self.assertEqual(Test.methodStaticPrivate(), py2_encode("StaticPrivate"))
+
+        self.assertTrue(hasattr(Test, 'methodChildStaticPublic'))
+        self.assertTrue(hasattr(Test, 'methodChildStaticProtected'))
+        self.assertTrue(hasattr(Test, 'methodChildStaticPrivate'))
+
+        self.assertEqual(Test.methodChildStaticPublic(), py2_encode("ChildStaticPublic"))
+        self.assertEqual(Test.methodChildStaticProtected(), py2_encode("ChildStaticProtected"))
+        self.assertEqual(Test.methodChildStaticPrivate(), py2_encode("ChildStaticPrivate"))
+
+    def test_fields_all(self):
         Test = autoclass('org.jnius.VisibilityTest', include_protected=True, include_private=True)
         test = Test()
 
@@ -59,8 +95,27 @@ class VisibilityAllTest(unittest.TestCase):
         self.assertEqual(test.fieldProtected, py2_encode("Protected"))
         self.assertEqual(test.fieldPrivate, py2_encode("Private"))
 
-    def test_methods_all(self):
+    def test_child_fields_all(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=True)
+        test = Test()
 
+        self.assertTrue(hasattr(test, 'fieldPublic'))
+        self.assertTrue(hasattr(test, 'fieldProtected'))
+        self.assertTrue(hasattr(test, 'fieldPrivate'))
+
+        self.assertEqual(test.fieldPublic, py2_encode("Public"))
+        self.assertEqual(test.fieldProtected, py2_encode("Protected"))
+        self.assertEqual(test.fieldPrivate, py2_encode("Private"))
+
+        self.assertTrue(hasattr(test, 'fieldChildPublic'))
+        self.assertTrue(hasattr(test, 'fieldChildProtected'))
+        self.assertTrue(hasattr(test, 'fieldChildPrivate'))
+
+        self.assertEqual(test.fieldChildPublic, py2_encode("ChildPublic"))
+        self.assertEqual(test.fieldChildProtected, py2_encode("ChildProtected"))
+        self.assertEqual(test.fieldChildPrivate, py2_encode("ChildPrivate"))
+
+    def test_methods_all(self):
         Test = autoclass('org.jnius.VisibilityTest', include_protected=True, include_private=True)
         test = Test()
 
@@ -71,3 +126,36 @@ class VisibilityAllTest(unittest.TestCase):
         self.assertEqual(test.methodPublic(), py2_encode("Public"))
         self.assertEqual(test.methodProtected(), py2_encode("Protected"))
         self.assertEqual(test.methodPrivate(), py2_encode("Private"))
+
+    def test_child_methods_all(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=True)
+        test = Test()
+
+        self.assertTrue(hasattr(test, 'methodChildPublic'))
+        self.assertTrue(hasattr(test, 'methodChildProtected'))
+        self.assertTrue(hasattr(test, 'methodChildPrivate'))
+
+        self.assertEqual(test.methodChildPublic(), py2_encode("ChildPublic"))
+        self.assertEqual(test.methodChildProtected(), py2_encode("ChildProtected"))
+        self.assertEqual(test.methodChildPrivate(), py2_encode("ChildPrivate"))
+
+    def test_static_multi_methods(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=True)
+
+        self.assertTrue(hasattr(Test, 'methodStaticMultiArgs'))
+        self.assertTrue(isinstance(Test.methodStaticMultiArgs, JavaMultipleMethod))
+
+        self.assertTrue(Test.methodStaticMultiArgs(True))
+        self.assertTrue(Test.methodStaticMultiArgs(True, False))
+        self.assertTrue(Test.methodStaticMultiArgs(True, False, True))
+
+    def test_multi_methods(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=True)
+        test = Test()
+
+        self.assertTrue(hasattr(test, 'methodMultiArgs'))
+        self.assertTrue(isinstance(Test.methodMultiArgs, JavaMultipleMethod))
+
+        self.assertTrue(test.methodMultiArgs(True))
+        self.assertTrue(test.methodMultiArgs(True, False))
+        self.assertTrue(test.methodMultiArgs(True, False, True))

tests/test_visibility_public_only.py

@@ -3,8 +3,11 @@ from __future__ import division
 from __future__ import absolute_import
 import sys
 import unittest
+import jnius_config
+from jnius import JavaMethod, JavaStaticMethod, JavaException
 from jnius.reflect import autoclass
 
+
 try:
     long
 except NameError:
@@ -20,7 +23,7 @@ def py2_encode(uni):
 
 class VisibilityPublicOnlyTest(unittest.TestCase):
 
-    def test_static_fields_public(self):
+    def test_static_fields_public_only(self):
         Test = autoclass('org.jnius.VisibilityTest', include_protected=False, include_private=False)
 
         self.assertTrue(hasattr(Test, 'fieldStaticPublic'))
@@ -29,7 +32,22 @@ class VisibilityPublicOnlyTest(unittest.TestCase):
 
         self.assertEqual(Test.fieldStaticPublic, py2_encode("StaticPublic"))
 
-    def test_static_methods_public(self):
+    def test_child_static_fields_public_only(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=False, include_private=False)
+
+        self.assertTrue(hasattr(Test, 'fieldStaticPublic'))
+        self.assertFalse(hasattr(Test, 'fieldStaticProtected'))
+        self.assertFalse(hasattr(Test, 'fieldStaticPrivate'))
+
+        self.assertEqual(Test.fieldStaticPublic, py2_encode("StaticPublic"))
+
+        self.assertTrue(hasattr(Test, 'fieldChildStaticPublic'))
+        self.assertFalse(hasattr(Test, 'fieldChildStaticProtected'))
+        self.assertFalse(hasattr(Test, 'fieldChildStaticPrivate'))
+
+        self.assertEqual(Test.fieldChildStaticPublic, py2_encode("ChildStaticPublic"))
+
+    def test_static_methods_public_only(self):
         Test = autoclass('org.jnius.VisibilityTest', include_protected=False, include_private=False)
 
         self.assertTrue(hasattr(Test, 'methodStaticPublic'))
@@ -38,22 +56,92 @@ class VisibilityPublicOnlyTest(unittest.TestCase):
 
         self.assertEqual(Test.methodStaticPublic(), py2_encode("StaticPublic"))
 
-    def test_fields_public(self):
+    def test_child_static_methods_public_only(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=False, include_private=False)
+
+        self.assertTrue(hasattr(Test, 'methodStaticPublic'))
+        self.assertFalse(hasattr(Test, 'methodStaticProtected'))
+        self.assertFalse(hasattr(Test, 'methodStaticPrivate'))
+
+        self.assertEqual(Test.methodStaticPublic(), py2_encode("StaticPublic"))
+
+        self.assertTrue(hasattr(Test, 'methodChildStaticPublic'))
+        self.assertFalse(hasattr(Test, 'methodChildStaticProtected'))
+        self.assertFalse(hasattr(Test, 'methodChildStaticPrivate'))
+
+        self.assertEqual(Test.methodChildStaticPublic(), py2_encode("ChildStaticPublic"))
+
+    def test_fields_public_only(self):
+
         Test = autoclass('org.jnius.VisibilityTest', include_protected=False, include_private=False)
-        public_only_test = Test()
+        test = Test()
 
-        self.assertTrue(hasattr(public_only_test, 'fieldPublic'))
-        self.assertFalse(hasattr(public_only_test, 'fieldProtected'))
-        self.assertFalse(hasattr(public_only_test, 'fieldPrivate'))
+        self.assertTrue(hasattr(test, 'fieldPublic'))
+        self.assertFalse(hasattr(test, 'fieldProtected'))
+        self.assertFalse(hasattr(test, 'fieldPrivate'))
 
-        self.assertEqual(public_only_test.fieldPublic, py2_encode("Public"))
+        self.assertEqual(test.fieldPublic, py2_encode("Public"))
+
+    def test_child_fields_public_only(self):
+
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=False, include_private=False)
+        test = Test()
+
+        self.assertTrue(hasattr(test, 'fieldPublic'))
+        self.assertFalse(hasattr(test, 'fieldProtected'))
+        self.assertFalse(hasattr(test, 'fieldPrivate'))
+
+        self.assertEqual(test.fieldPublic, py2_encode("Public"))
+
+        self.assertTrue(hasattr(test, 'fieldChildPublic'))
+        self.assertFalse(hasattr(test, 'fieldChildProtected'))
+        self.assertFalse(hasattr(test, 'fieldChildPrivate'))
+
+        self.assertEqual(test.fieldChildPublic, py2_encode("ChildPublic"))
+
+    def test_methods_public_only(self):
 
-    def test_methods_public(self):
         Test = autoclass('org.jnius.VisibilityTest', include_protected=False, include_private=False)
-        public_only_test = Test()
+        test = Test()
 
-        self.assertTrue(hasattr(public_only_test, 'methodPublic'))
-        self.assertFalse(hasattr(public_only_test, 'methodProtected'))
-        self.assertFalse(hasattr(public_only_test, 'methodPrivate'))
+        self.assertTrue(hasattr(test, 'methodPublic'))
+        self.assertFalse(hasattr(test, 'methodProtected'))
+        self.assertFalse(hasattr(test, 'methodPrivate'))
 
-        self.assertEqual(public_only_test.methodPublic(), py2_encode("Public"))
+        self.assertEqual(test.methodPublic(), py2_encode("Public"))
+
+    def test_child_methods_public_only(self):
+
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=False, include_private=False)
+        test = Test()
+
+        self.assertTrue(hasattr(test, 'methodChildPublic'))
+        self.assertFalse(hasattr(test, 'methodChildProtected'))
+        self.assertFalse(hasattr(test, 'methodChildPrivate'))
+
+        self.assertEqual(test.methodChildPublic(), py2_encode("ChildPublic"))
+
+    def test_static_multi_methods(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=False, include_private=False)
+
+        self.assertTrue(hasattr(Test, 'methodStaticMultiArgs'))
+        self.assertTrue(isinstance(Test.methodStaticMultiArgs, JavaStaticMethod))
+
+        self.assertTrue(Test.methodStaticMultiArgs(True))
+        with self.assertRaises(JavaException):
+            Test.methodStaticMultiArgs(True, False)
+        with self.assertRaises(JavaException):
+            Test.methodStaticMultiArgs(True, False, True)
+
+    def test_multi_methods(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=False, include_private=False)
+        test = Test()
+
+        self.assertTrue(hasattr(test, 'methodMultiArgs'))
+        self.assertTrue(isinstance(Test.methodMultiArgs, JavaMethod))
+
+        self.assertTrue(test.methodMultiArgs(True))
+        with self.assertRaises(JavaException):
+            test.methodMultiArgs(True, False)
+        with self.assertRaises(JavaException):
+           test.methodMultiArgs(True, False, True)

tests/test_visibility_public_protected.py

@@ -3,8 +3,11 @@ from __future__ import division
 from __future__ import absolute_import
 import sys
 import unittest
+import jnius_config
+from jnius import JavaMultipleMethod, JavaException
 from jnius.reflect import autoclass
 
+
 try:
     long
 except NameError:
@@ -22,6 +25,7 @@ class VisibilityPublicProtectedTest(unittest.TestCase):
 
     def test_static_fields_public_protected(self):
         Test = autoclass('org.jnius.VisibilityTest', include_protected=True, include_private=False)
+
         self.assertTrue(hasattr(Test, 'fieldStaticPublic'))
         self.assertTrue(hasattr(Test, 'fieldStaticProtected'))
         self.assertFalse(hasattr(Test, 'fieldStaticPrivate'))
@@ -29,6 +33,23 @@ class VisibilityPublicProtectedTest(unittest.TestCase):
         self.assertEqual(Test.fieldStaticPublic, py2_encode("StaticPublic"))
         self.assertEqual(Test.fieldStaticProtected, py2_encode("StaticProtected"))
 
+    def test_child_static_fields_public_protected(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=False)
+
+        self.assertTrue(hasattr(Test, 'fieldStaticPublic'))
+        self.assertTrue(hasattr(Test, 'fieldStaticProtected'))
+        self.assertFalse(hasattr(Test, 'fieldStaticPrivate'))
+
+        self.assertEqual(Test.fieldStaticPublic, py2_encode("StaticPublic"))
+        self.assertEqual(Test.fieldStaticProtected, py2_encode("StaticProtected"))
+
+        self.assertTrue(hasattr(Test, 'fieldChildStaticPublic'))
+        self.assertTrue(hasattr(Test, 'fieldChildStaticProtected'))
+        self.assertFalse(hasattr(Test, 'fieldChildStaticPrivate'))
+
+        self.assertEqual(Test.fieldChildStaticPublic, py2_encode("ChildStaticPublic"))
+        self.assertEqual(Test.fieldChildStaticProtected, py2_encode("ChildStaticProtected"))
+
     def test_static_methods_public_protected(self):
         Test = autoclass('org.jnius.VisibilityTest', include_protected=True, include_private=False)
 
@@ -39,24 +60,97 @@ class VisibilityPublicProtectedTest(unittest.TestCase):
         self.assertEqual(Test.methodStaticPublic(), py2_encode("StaticPublic"))
         self.assertEqual(Test.methodStaticProtected(), py2_encode("StaticProtected"))
 
+    def test_child_static_methods_public_protected(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=False)
+
+        self.assertTrue(hasattr(Test, 'methodStaticPublic'))
+        self.assertTrue(hasattr(Test, 'methodStaticProtected'))
+        self.assertFalse(hasattr(Test, 'methodStaticPrivate'))
+
+        self.assertEqual(Test.methodStaticPublic(), py2_encode("StaticPublic"))
+        self.assertEqual(Test.methodStaticProtected(), py2_encode("StaticProtected"))
+
+        self.assertTrue(hasattr(Test, 'methodChildStaticPublic'))
+        self.assertTrue(hasattr(Test, 'methodChildStaticProtected'))
+        self.assertFalse(hasattr(Test, 'methodChildStaticPrivate'))
+
+        self.assertEqual(Test.methodChildStaticPublic(), py2_encode("ChildStaticPublic"))
+        self.assertEqual(Test.methodChildStaticProtected(), py2_encode("ChildStaticProtected"))
+
     def test_fields_public_protected(self):
+
         Test = autoclass('org.jnius.VisibilityTest', include_protected=True, include_private=False)
-        public_only_test = Test()
+        test = Test()
 
-        self.assertTrue(hasattr(public_only_test, 'fieldPublic'))
-        self.assertTrue(hasattr(public_only_test, 'fieldProtected'))
-        self.assertFalse(hasattr(public_only_test, 'fieldPrivate'))
+        self.assertTrue(hasattr(test, 'fieldPublic'))
+        self.assertTrue(hasattr(test, 'fieldProtected'))
+        self.assertFalse(hasattr(test, 'fieldPrivate'))
 
-        self.assertEqual(public_only_test.fieldPublic, py2_encode("Public"))
-        self.assertEqual(public_only_test.fieldProtected, py2_encode("Protected"))
+        self.assertEqual(test.fieldPublic, py2_encode("Public"))
+        self.assertEqual(test.fieldProtected, py2_encode("Protected"))
+
+    def test_child_fields_public_protected(self):
+
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=False)
+        test = Test()
+
+        self.assertTrue(hasattr(test, 'fieldPublic'))
+        self.assertTrue(hasattr(test, 'fieldProtected'))
+        self.assertFalse(hasattr(test, 'fieldPrivate'))
+
+        self.assertEqual(test.fieldPublic, py2_encode("Public"))
+        self.assertEqual(test.fieldProtected, py2_encode("Protected"))
+
+        self.assertTrue(hasattr(test, 'fieldChildPublic'))
+        self.assertTrue(hasattr(test, 'fieldChildProtected'))
+        self.assertFalse(hasattr(test, 'fieldChildPrivate'))
+
+        self.assertEqual(test.fieldChildPublic, py2_encode("ChildPublic"))
+        self.assertEqual(test.fieldChildProtected, py2_encode("ChildProtected"))
 
     def test_methods_public_protected(self):
+
         Test = autoclass('org.jnius.VisibilityTest', include_protected=True, include_private=False)
-        public_only_test = Test()
+        test = Test()
 
-        self.assertTrue(hasattr(public_only_test, 'methodPublic'))
-        self.assertTrue(hasattr(public_only_test, 'methodProtected'))
-        self.assertFalse(hasattr(public_only_test, 'methodPrivate'))
+        self.assertTrue(hasattr(test, 'methodPublic'))
+        self.assertTrue(hasattr(test, 'methodProtected'))
+        self.assertFalse(hasattr(test, 'methodPrivate'))
 
-        self.assertEqual(public_only_test.methodPublic(), py2_encode("Public"))
-        self.assertEqual(public_only_test.methodProtected(), py2_encode("Protected"))
+        self.assertEqual(test.methodPublic(), py2_encode("Public"))
+        self.assertEqual(test.methodProtected(), py2_encode("Protected"))
+
+    def test_child_methods_public_protected(self):
+
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=False)
+        test = Test()
+
+        self.assertTrue(hasattr(test, 'methodChildPublic'))
+        self.assertTrue(hasattr(test, 'methodChildProtected'))
+        self.assertFalse(hasattr(test, 'methodChildPrivate'))
+
+        self.assertEqual(test.methodChildPublic(), py2_encode("ChildPublic"))
+        self.assertEqual(test.methodChildProtected(), py2_encode("ChildProtected"))
+
+    def test_static_multi_methods(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=False)
+
+        self.assertTrue(hasattr(Test, 'methodStaticMultiArgs'))
+        self.assertTrue(isinstance(Test.methodStaticMultiArgs, JavaMultipleMethod))
+
+        self.assertTrue(Test.methodStaticMultiArgs(True))
+        self.assertTrue(Test.methodStaticMultiArgs(True, False))
+        with self.assertRaises(JavaException):
+            Test.methodStaticMultiArgs(True, False, True)
+
+    def test_multi_methods(self):
+        Test = autoclass('org.jnius.ChildVisibilityTest', include_protected=True, include_private=False)
+        test = Test()
+
+        self.assertTrue(hasattr(test, 'methodMultiArgs'))
+        self.assertTrue(isinstance(Test.methodMultiArgs, JavaMultipleMethod))
+
+        self.assertTrue(test.methodMultiArgs(True))
+        self.assertTrue(test.methodMultiArgs(True, False))
+        with self.assertRaises(JavaException):
+           test.methodMultiArgs(True, False, True)