From 8b393126ebb5aee6cd6df047eb09e24d9b12d3c4 Mon Sep 17 00:00:00 2001 From: Jim Date: Sat, 11 Apr 2020 09:52:40 -0400 Subject: [PATCH] even more unit tests --- .../org/jnius/ChildVisibilityTest.java | 65 ++++++++++ tests/java-src/org/jnius/VisibilityTest.java | 8 ++ tests/test_visibility_all.py | 96 +++++++++++++- tests/test_visibility_public_only.py | 116 ++++++++++++++--- tests/test_visibility_public_protected.py | 118 ++++++++++++++++-- 5 files changed, 373 insertions(+), 30 deletions(-) create mode 100644 tests/java-src/org/jnius/ChildVisibilityTest.java diff --git a/tests/java-src/org/jnius/ChildVisibilityTest.java b/tests/java-src/org/jnius/ChildVisibilityTest.java new file mode 100644 index 0000000..086a5c1 --- /dev/null +++ b/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(); + } +} diff --git a/tests/java-src/org/jnius/VisibilityTest.java b/tests/java-src/org/jnius/VisibilityTest.java index a64437b..b338d74 100644 --- a/tests/java-src/org/jnius/VisibilityTest.java +++ b/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(); diff --git a/tests/test_visibility_all.py b/tests/test_visibility_all.py index 95b0140..3493a49 100644 --- a/tests/test_visibility_all.py +++ b/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)) diff --git a/tests/test_visibility_public_only.py b/tests/test_visibility_public_only.py index 16dde16..a6e8ac1 100644 --- a/tests/test_visibility_public_only.py +++ b/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) diff --git a/tests/test_visibility_public_protected.py b/tests/test_visibility_public_protected.py index c7e7c29..0b616a2 100644 --- a/tests/test_visibility_public_protected.py +++ b/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)