"""
Bad input to __import__ raises a Java exception.
"""
import support
try:
__import__('')
except ValueError, e:
support.compare(e, "Empty module name")
"""
Coercion of Integer and Number.
"""
import support
support.compileJava("test091j.java")
import test091j
r = test091j.takeInt(12)
support.compare(r, "takeInt")
r = test091j.takeInteger(12)
support.compare(r, "takeInteger")
r = test091j.takeNumber(12)
support.compare(r, "takeNumber")
"""
"""
import support
def mkspam(a):
f = open("test080m.py", "w")
f.write("def Spam(): return '%s'" % a)
f.close()
mkspam("foo")
import test080m
spam1 = test080m.Spam()
support.compare(spam1, "foo")
import time
time.sleep(2)
mkspam("bar")
reload(test080m)
spam2 = test080m.Spam()
support.compare(spam2, "bar")
import support t = (1, 2, 3) list(t).reverse() support.compare(t, "1, 2, 3")
""" Check properites of the exceptions module. """ import support import exceptions support.compare(exceptions.__doc__, "standard exception class hierarchy") support.compare(exceptions.__name__, "exceptions") #support.compare(exceptions.__file__, r"Lib\\exceptions.py")
"""
"TypeError: can't instantiate abstract class" thrown for class with no public constructors
"""
import support
import java
try:
java.lang.Math()
except TypeError, e:
support.compare(e, "no public constructors for")
"""
__getslice__ method never called for Python instances
"""
import support
class F:
def __getitem__(self, *args):
return '__getitem__ ' + ` args `
def __getslice__(self, *args):
return '__getslice__ ' + ` args `
f = F()
support.compare(f[1:1], "__getslice__ \(1, 1\)")
""" Check properites of the exceptions module. """ import support import exceptions support.compare(exceptions.__doc__, "standard exception class hierarchy") support.compare(exceptions.__name__, "exceptions") #support.compare(exceptions.__file__, r"Lib\\exceptions.py")
"""
Unbound methods not indicated properly in repr
"""
import support
class Foo:
def bar(s):
pass
r = repr(Foo.bar)
support.compare(r, "<unbound method")
class Test:
text = Data()
class Factory:
def createTest(x):
return Test()
factory = Factory()
foo = factory.createTest()
from java import io
import sys
filename = "test101.out"
fout = io.ObjectOutputStream(io.FileOutputStream(filename))
fout.writeObject(foo)
fout.close()
fin = io.ObjectInputStream(io.FileInputStream(filename))
foo = fin.readObject()
fin.close()
support.compare(foo, "<(__main__|test101).Test instance")
support.compare(foo.text, "<(__main__|test101).Data instance")
support.compare(foo.text.data, "Hello World")
"""
Try reloading a javaclass located on sys.path.
"""
import support
import java
import sys
def mkspam(a):
f = open("test081j.java", "w")
f.write("""
public class test081j {
public static String spam() { return "%s"; }
public static void %s() {}
}
""" % (a, a))
f.close()
support.compileJava("test081j.java")
mkspam("foo")
import test081j
spam1 = test081j.spam()
support.compare(spam1, "foo")
"""
Check calling an instance method with a class instance.
"""
import support
class foo:
def bar():
return "bar"
try:
foo.bar()
except TypeError, e:
support.compare(e, "with \w* ?instance")
else:
raise support.TestError("Should raise TypeError")
"""
import support
support.compileJava("test277p/Test.java")
from test277p import Test
cnt = 0
class pytest(Test):
def initialize(self):
global cnt
Test.initialize(self)
cnt += 1
pt = pytest()
support.compare(cnt, "2")
cnt = 0
import java
pt = java.lang.Class.newInstance(pytest)
support.compare(cnt, "2")
"""
Test keywords to import builtin.
"""
import support
impl_names = ['java']
# Will only return anygui :P
try:
impls = [__import__('anygui.impl.%sgui' % name,
fromlist=['%sgui' % name]) for name in impl_names]
except TypeError, e:
support.compare(e, "__import__\(\) takes no keyword arguments");
else:
support.TestError("Should raise a TypeError")
"""
"""
import support
support.compileJava("classes/test208j.java")
import test208j
import test208j1
import test208j2
p=[test208j2()]
support.compare(test208j.foo(p), "test208j2\[\]")
p=[test208j1()]
support.compare(test208j.foo(p), "test208j1\[\]")
def mkj2(v):
f = open("classes/test092m/test092j2.java", "w")
f.write(j2file % v);
f.close();
support.compileJava("classes/test092m/test092j2.java")
import sys
mkj1("1")
mkj2("2")
import test092m
foo = test092m.test092j2()
support.compare(foo.j1Version, "j1 Version 1")
support.compare(foo.j2Version, "j2 Version 2")
mkj1("3")
mkj2("4")
#
# Removed. Reloading java packages is not supposed to work
#
#reload(test092m)
#
#foo = test092m.test092j2()
#support.compare(foo.j1Version, "j1 Version 3")
#support.compare(foo.j2Version, "j2 Version 4")
"""
[ 522423 ] cStringIO has no reset() method
"""
import support
import cStringIO
s = cStringIO.StringIO("abcdef")
s.read(3)
s.reset()
support.compare(s.read(3), "abc")
support.compare(s.read(3), "def")
"""
no exception when too many arguments for format string
"""
import support
try:
r = '%d' % (1, 2)
except TypeError, e:
support.compare(e, "not all arguments converted")
"""
Create a new Module.
"""
import support
from org.python.core import PyModule, PyInstance
test = PyModule("test", {})
exec "a = 2" in test.__dict__
support.compare(len(test.__dict__), "3")
#test = PyInstance.__tojava__(test, PyModule)
exec "b = 3" in test.__dict__
support.compare(len(test.__dict__), "4")
def f(*args, **kw):
#print args, kw
support.compare(args, "(1, 2, 3)")
support.compare(kw, "{'foo': 'bar'}")
from pawt import swing, test
class TableModel0(swing.table.AbstractTableModel):
columnNames = "First Name", "Last Name","Sport","# of Years","Vegetarian"
data = [("Mary", "Campione", "Snowboarding", 5, java.lang.Boolean(0))]
def getColumnCount(self):
return len(self.columnNames)
def getRowCount(self):
return len(self.data)
def getColumnName(self, col):
return self.columnNames[col]
def getValueAt(self, row, col):
return self.data[row][col]
def getColumnClass(self, c):
return java.lang.Class.getClass(self.getValueAt(0, c))
def isCellEditable(self, row, col):
return col >= 2
model0 = TableModel0()
support.compare(model0.getColumnClass(0), "java.lang.String")
support.compare(model0.getColumnClass(1), "java.lang.String")
support.compare(model0.getColumnClass(2), "java.lang.String")
support.compare(model0.getColumnClass(3), "java.lang.Integer")
support.compare(model0.getColumnClass(4), "java.lang.Boolean")
return "test182c." + self.super__tstOverrideProtected()
def tstOverrideFinalProtected(self):
return "test182c." + self.super__tstOverrideFinalProtected()
def tstOverrideFinalPublic(self):
return "test182c." + test182j.tstOverrideFinalPublic(self)
def tstAbstractPublic(self):
return "test182c.tstAbstractPublic"
def tstAbstractProtected(self):
return "test182c.tstAbstractProtected"
i = test182c()
support.compare(i.tstPublic(), "tstPublic")
support.compare(i.tstProtected(), "tstProtected")
support.compare(i.super__tstFinalProtected(), "tstFinalProtected")
support.compare(i.tstFinalPublic(), "tstFinalPublic")
support.compare(i.tstOverridePublic(), "test182c.tstOverridePublic")
support.compare(i.tstOverrideProtected(), "test182c.tstOverrideProtected")
support.compare(i.tstOverrideFinalProtected(),
"test182c.tstOverrideFinalProtected")
support.compare(i.tstOverrideFinalPublic(), "test182c.tstOverrideFinalPublic")
support.compare(i.tstAbstractPublic(), "test182c.tstAbstractPublic")
support.compare(i.tstAbstractProtected(), "test182c.tstAbstractProtected")
def fun2():
return %s
"""
def mk(v):
f = open("test125m.py", "w")
f.write(src % v)
f.close()
mk("1")
import test125m
from test125m import fun2
support.compare(fun2(), "1")
import time
time.sleep(2)
mk("2")
reload(test125m)
support.compare(fun2(), "1")
from test125m import fun2
support.compare(fun2(), "2")
support.compare(test125m.fun2(), "2")
"""
"""
import support
support.compileJava("classes/test206j1.java")
import java
#import test206j0
import test206j1
x = test206j1()
support.compare(x.getInt2(), "4")
support.compare(x.getInt(), "3")
package com;
public class Blob {
int value = %d;
}
"""
def makeBlob(value):
f = open("test273p/com/Blob.java", "w")
f.write(src % value);
f.close();
support.compileJava(r"test273p/com/Blob.java")
support.compileJava(r"test273p/com/BlobWriter.java", classpath="test273p")
makeBlob(1)
import jreload
XLS = jreload.makeLoadSet("XLS",['test273p'])
from XLS import com
v = com.BlobWriter.write(com.Blob())
support.compare(v, "1")
makeBlob(2)
jreload.reload(XLS)
v = com.BlobWriter.write(com.Blob())
support.compare(v, "2")
"""
Check serialization of PyJavaInstance subclasses. (from classpath).
#unitcheck
"""
import support
import java, org
pi = java.io.PipedInputStream()
po = java.io.PipedOutputStream(pi)
oo = java.io.ObjectOutputStream(po)
oi = org.python.util.PythonObjectInputStream(pi)
class C(java.util.Date):
c = 3
c = C()
# print c
oo.writeObject(c)
c = oi.readObject()
# print c
support.compare(c.c, "3")
"""
Check handling of badly formed beans.
Vector.size() function must override the Vector.size writeonly property.
"""
import support
from java import util
from types import *
v = util.Vector
support.compare(str(v.size), "<java function size")
if not callable(v.size):
raise support.TestError('v.size should be callable')
""" "%012d" % -4 displays '0000000000-4'. """ import support s = "%012d" % -4 support.compare(s, "-00000000004")
"""
Calling static methods in subclass.
"""
import support
support.compileJava("classes/test084j3.java")
import test084j3
r = test084j3.main(["xxx"])
support.compare(r, "test084j3")
r = test084j3.ohMy()
support.compare(r, "test084j3")
"""
"""
import support
class m:
__var = 0
try:
m.__var
except AttributeError, e:
support.compare(e, "class 'm' has no attribute '__var'")
else:
raise support.TestError("Should raise")
"""
"""
import support
support.compileJava("test157j.java")
import test157j
from jarray import *
f = zeros(2,'d');
support.compare(test157j.test(f), "double");
if f[0] == 0:
raise support.TestError("array not changed")
f = zeros(2,'f');
support.compare(test157j.test(f), "float");
if f[0] == 0:
raise support.TestError("array not changed")
"""
"""
import support
support.compare("%g" % 1, "1")
support.compare("%g .. %g" % (1,2), "1 .. 2")
#raise support.TestError("" + `x`)
""" Basic test of exec """ import support exec "a = 'spam'" in globals() support.compare(a, "spam")
class Test:
text = Data()
class Factory:
def createTest(x):
return Test()
factory = Factory()
foo = factory.createTest()
from java import io
import sys
filename = "test101.out"
fout = io.ObjectOutputStream(io.FileOutputStream(filename))
fout.writeObject(foo)
fout.close()
fin = io.ObjectInputStream(io.FileInputStream(filename))
foo = fin.readObject()
fin.close()
support.compare(foo, "<(__main__|test101).Test instance")
support.compare(foo.text, "<(__main__|test101).Data instance")
support.compare(foo.text.data, "Hello World")
"""
__file__ should not be defined when eval.
"""
import support
try:
eval('__file__')
except NameError, e:
support.compare(e, "__file__")
"""
Test multiple inheritance of 2 java classes
"""
import support
try:
import test087m
except TypeError, e:
support.compare(e, "multiple inheritance")
else:
raise support.TestError("multiple inheritance should fail")
""" "TypeError: can't instantiate abstract class" thrown for class with no public constructors """ import support import java try: java.lang.Math() except TypeError, e: support.compare(e, "no public constructors for")
"""
Check a manually created PyModule, with unwanted hack.
"""
import support
import org, sys
s = """
def foo():
return "foo bar zot"
"""
name = "test128m"
mod = org.python.core.PyModule("test128m", {})
#mod = org.python.core.PyInstance.__tojava__(mod, org.python.core.PyModule)
code = compile(s, "test128m.py", "exec" )
exec s in mod.__dict__, mod.__dict__
sys.modules["test128m"] = mod
import test128m
support.compare(test128m.foo(), "foo bar zot")
"""
Subclassing PyInteger
"""
import support
IntegerType = type(1)
class SpecialInt(IntegerType):
def __init__(self, n):
IntegerType.__init__(self, n)
def double(self):
return self * 2
si = SpecialInt(12)
#print str(si)
support.compare(si, '12')
support.compare(si + 1, '13')
support.compare(si + si, '24')
support.compare(3 + si, '15')
import support t = (1,2,3) list(t).reverse() support.compare(t, "1, 2, 3")
"""
Check creation of a abstract javaclass.
"""
import support
from java import awt
import sys
try:
a = awt.Component()
except TypeError:
support.compare(sys.exc_info()[1], "abstract")
import support import test173p support.compare(test173p, "sys")
"""
"""
import support
support.compileJava("classes/test205j2.java")
import test205j1
support.compare(test205j1.classID, "2051")
import test205j2
support.compare(test205j2.classID, "2052")
support.compare(test205j1.classID, "2051")
support.compare(test205j1().classID, "20510")
support.compare(test205j2().classID, "20520")
support.compare(test205j1().classID, "20510")
"""
"""
import support
import tokenize
f = open("test152.out", "w")
f.write("for i in range(1,10):")
f.close()
f = open("test152.out")
s = ""
def gettoken(type, token, (srow, scol), (erow, ecol), line): # for testing
global s
s = s + " " + token
r = tokenize.tokenize(f.readline, gettoken)
support.compare(s, "for")
#raise support.TestError("Should raise")
"""
"""
import support
support.compileJava("test157j.java")
import test157j
from jarray import *
f = zeros(2, 'd')
support.compare(test157j.test(f), "double")
if f[0] == 0:
raise support.TestError("array not changed")
f = zeros(2, 'f')
support.compare(test157j.test(f), "float")
if f[0] == 0:
raise support.TestError("array not changed")
"""
Coercion of Integer and Number.
"""
import support
support.compileJava("test091j.java")
import test091j
r = test091j.takeInt(12)
support.compare(r, "takeInt")
r = test091j.takeInteger(12)
support.compare(r, "takeInteger")
r = test091j.takeNumber(12)
support.compare(r, "takeNumber")
"""
"""
import support
import exceptions
class A(exceptions.Exception):
def __init__(self, args):
exceptions.Exception.__init__(self, args)
support.compare(A, "test141.A|__main__.A")
#print support.TestError
""" Check name of the pawt.swing package. """ import support from pawt import swing support.compare(swing, "java package") support.compare(swing.__name__, "javax.swing") support.compare(swing.__jpythonc_name__, "pawt.swing") # support.compare(swing.__file__, r"Lib\\pawt\\swing.py")
"""
Check strange indexes/slices.
"""
import support
import java
try:
java.util.Date("99-01-01", 1, 1)
except TypeError, e:
support.compare(e, "1st arg")
import support
support.compileJava("test172j.java")
import test172j
support.compare(test172j.foo(1,2,3,4), "foo called with 4 arguments")
support.compare(test172j().bar(1,2,3,4), "bar called with 4 arguments")
"""
"""
import support
import exceptions
class A(exceptions.Exception):
def __init__(self, args):
exceptions.Exception.__init__(self, args)
support.compare(A, "test141.A|__main__.A")
#print support.TestError
