import support

t = (1, 2, 3)
list(t).reverse()
support.compare(t, "1, 2, 3")

import support


import test173p
support.compare(test173p, "sys")

"""

"""

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")

"""
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")

"""
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")

"""
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")

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")

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")

"""
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

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\[\]")

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")

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")

"""

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")

"""
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

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

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")

"""
__file__ should not be defined when eval.
"""

import support

try:
   eval('__file__')
except NameError, e:
   support.compare(e, "__file__")

"""

"""

import support

support.compare("%g" % 1, "1")
support.compare("%g .. %g" % (1,2), "1 .. 2")

#raise support.TestError("" + `x`)

"""
"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")