def test_hash(self):
# verify a PyJNumber can be hashed by Python, this will call the Python hash() not the Java hashCode()
a = Integer(50)
self.assertEqual(50, hash(a))
b = Integer(-1)
# -1 in Python means error code so they weirdly have the hash of -1 be -2
self.assertEqual(-2, hash(b))
def test_int_compare(self):
x = Integer(5)
y = Integer(7)
self.assertTrue(x < y)
self.assertFalse(x > y)
self.assertTrue(x <= y)
self.assertFalse(x >= y)
self.assertTrue(x != y)
self.assertFalse(x == y)
self.assertTrue(y > x)
self.assertFalse(y < x)
self.assertTrue(y >= x)
self.assertFalse(y <= x)
self.assertTrue(y != x)
self.assertFalse(y == x)
z = Integer(7)
self.assertFalse(y < z)
self.assertFalse(y > z)
self.assertTrue(y >= z)
self.assertTrue(y <= z)
self.assertFalse(y != z)
self.assertTrue(y == z)
self.assertFalse(z < y)
self.assertFalse(z > y)
self.assertTrue(z >= y)
self.assertTrue(z <= y)
self.assertFalse(z != y)
self.assertTrue(z == y)
def __init__(self, imageWidth=None, imageHeight=None, expandLeft=25.0, expandRight=25.0, expandTop=25.0, expandBottom=25.0, mask=None, wholeDomain=0, bgColor=None):
# Create empty display and data manager for display
display = GFEMapRenderableDisplay()
self.dataMgr = DataManagerOffscreenFactory.getInstance(display)
self.refId = None
envelope = None
gloc = self.dataMgr.getParmManager().compositeGridLocation()
if mask is not None:
from com.raytheon.uf.common.dataplugin.gfe.reference import ReferenceData
CoordinateType = ReferenceData.CoordinateType
self.refId = ReferenceID(mask)
if wholeDomain == 0:
envelope = self.dataMgr.getRefManager().loadRefSet(self.refId).overallDomain(CoordinateType.GRID)
if imageWidth is not None:
imageWidth = Integer(int(imageWidth))
if imageHeight is not None:
imageHeight = Integer(int(imageHeight))
geom = GfeImageUtil.getLocationGeometry(gloc, envelope, imageWidth, imageHeight, expandLeft / 100.0, expandRight / 100.0, expandTop / 100.0, expandBottom / 100.0)
# Create descriptor for display
desc = MapDescriptor(geom)
display.setDescriptor(desc)
VizPainter.VizPainter.__init__(self, display, backgroundColor=bgColor)
gfeSystem = GFESystemResource(self.dataMgr)
self.addVizResource(gfeSystem)
desc.getResourceList().getProperties(gfeSystem).setSystemResource(True)
self.primaryRsc = None
def dictCheck(dictionary, value, subvalue, configName):
map = LinkedHashMap()
if type(dictionary) == dict:
for k in dictionary.keys():
if type(k) != str:
raise TypeError, configName + " key [" + ` k ` + "] not a str"
l = dictionary[k]
if type(l) != value:
raise TypeError, configName + " value [" + `l` + "] not a " \
+ `value`
if value == list or value == tuple:
n = ArrayList()
for m in l:
if type(m) != subvalue:
raise TypeError, configName + " value [" + `l` \
+ "] isn't a " + `subvalue` + ": " + `m`
elif subvalue == int:
n.add(Integer(m))
elif subvalue == float:
n.add(Float(m))
else:
n.add(m)
map.put(k, n)
else:
if value == int:
map.put(k, Integer(l))
elif value == float:
map.put(k, Float(l))
else:
map.put(k, l)
else:
raise TypeError, configName + " not a dict:" + ` dictionary `
return map
def test_setitem(self):
jlist = makeJavaList()
pylist = makePythonList()
jlist[5] = Integer(55)
pylist[5] = Integer(55)
jlist[-3] = Integer(99)
pylist[-3] = Integer(99)
self.assertSequenceEqual(jlist, pylist)
def deploy():
if connected == 'false':
connect(userName, passWord, adminServerURL)
if connected == 'false':
writeResultToFile(RESULT_FAILED + "\n Could not connecte the Server!" + adminServerURL)
edit()
startEdit()
#_targets
_targets =""
if (targetServers is not None) and (len(targetServers) > 0):
_targets = targetServers
if (targetClusters is not None) and (len(targetClusters) > 0):
if len(_targets) > 0:
_targets = _targets + "," + targetClusters
else:
_targets = targetClusters
#timeout
_timeout = 1200000
if (timeOut is not None) and (len(timeOut) > 0):
try:
_timeout = Integer(timeOut).intValue()
except:
print "timeOut not set."
print "appName:" + appName
print "earPath:" + earPath
print "targets:" + _targets
print "_timeout: " + Integer(_timeout).toString()
progressMonitor = None
##cluster must use stage model
if (targetClusters is not None) and (len(targetClusters) > 0):
if (_stageModel is not None) and (len(_stageModel) > 0):
progressMonitor = deploy(appName,earPath,_targets,stageMode=_stageModel,timeout=_timeout)
else:
progressMonitor = deploy(appName,earPath,_targets,stageMode="nostage",timeout=_timeout)
else:
progressMonitor = deploy(appName,earPath,_targets,timeout=_timeout)
## while(progressMonitor.isRunning()):
## print time.sleep(10)
#running, completed, failed, or released
result_state = progressMonitor.getState()
print "deploy's state:" + result_state
if result_state == 'failed':
try:
undo(defaultAnswer='y')
cancelEdit(defaultAnswer='y')
finally:
writeResultToFile(RESULT_FAILED)
else :
try:
save()
activate()
writeResultToFile(RESULT_SUCCEED)
except:
writeResultToFile(RESULT_EXCEPTION)
def __call__(self):
params = Vector()
params.addElement(Integer(6))
params.addElement(Integer(3))
result = client.execute("sample.sumAndDifference", params)
sum = result.get("sum")
grinder.logger.info("SUM %d" % sum)
def test_addequals(self):
jlist = makeJavaList()
pylist = makePythonList()
jlist += [Integer(COUNT + 1)]
pylist += [Integer(COUNT + 1)]
self.assertSequenceEqual(jlist, pylist)
toAdd = [Integer(1), Integer(2), Integer(3)]
jlist += toAdd
pylist += toAdd
self.assertSequenceEqual(jlist, pylist)
def test_setslice(self):
jlist = makeJavaList()
pylist = makePythonList()
jlist[2:4] = [Integer(7), Integer(1)]
pylist[2:4] = [Integer(7), Integer(1)]
self.assertEqual(len(jlist), len(pylist))
self.assertSequenceEqual(jlist, pylist)
jlist[9:-5] = [Integer(4), Integer(88), Integer(19)]
pylist[9:-5] = [Integer(4), Integer(88), Integer(19)]
self.assertEqual(len(jlist), len(pylist))
self.assertSequenceEqual(jlist, pylist)
def test_nonzero(self):
i, pi, j, pj, d, pd = self.get_values()
self.assertEqual(bool(i), bool(pi))
self.assertEqual(bool(j), bool(pj))
self.assertEqual(bool(d), bool(pd))
self.assertFalse(bool(Integer(0)))
self.assertFalse(bool(Long(0)))
self.assertFalse(bool(Double(0.0)))
self.assertTrue(bool(Integer(1)))
self.assertTrue(bool(Long(1)))
self.assertTrue(bool(Double(1.0)))
def getGlobals(mod):
mp = HashMap()
for attrName in mod.__dict__:
if not attrName.startswith('__'):
attr = mod.__getattribute__(attrName)
t = type(attr)
if t is not list:
if t is str:
mp.put(attrName, attr)
elif t is int:
mp.put(attrName, Integer(attr))
elif t is float:
mp.put(attrName, Float(attr))
elif t is bool:
mp.put(attrName, Boolean(attr))
else:
arr = None
if len(attr) > 0:
t = type(attr[0])
if t is int:
arr = __fillArray(attr, Integer)
elif t is float:
arr = __fillArray(attr, Float)
elif t is str:
arr = __fillArray(attr, String)
mp.put(attrName, arr)
return mp
def test_compare(self):
pfive = 5
jfive = Integer(5)
ptwosix = 2.6
jtwosix = Double(2.6)
# Need to check with same values on opposite sides of the operator due
# to Python's richcompare behavior.
# check the trues first
self.assertTrue(pfive > jtwosix)
self.assertTrue(jtwosix < pfive)
self.assertTrue(ptwosix < jfive)
self.assertTrue(jfive > ptwosix)
self.assertTrue(ptwosix == jtwosix)
self.assertTrue(jtwosix == ptwosix)
self.assertTrue(pfive == jfive)
self.assertTrue(jfive == pfive)
# check the falses next
self.assertFalse(pfive < jtwosix)
self.assertFalse(jtwosix > pfive)
self.assertFalse(ptwosix > jfive)
self.assertFalse(jfive < ptwosix)
self.assertFalse(pfive != jfive)
self.assertFalse(jfive != pfive)
self.assertFalse(ptwosix != jtwosix)
self.assertFalse(jtwosix != ptwosix)
def get_values(self):
i = Integer(-5)
pi = i.intValue()
j = Long(5001)
pj = j.longValue()
d = Double(10.001)
pd = d.doubleValue()
return i, pi, j, pj, d, pd
def __activate__(self, context):
response = context["response"]
self.indexer = context["Services"].getIndexer()
self.systemConfig = context["systemConfig"]
self.log = context["log"]
self.sessionState = context["sessionState"]
self.sessionState.set("username", "admin")
writer = response.getPrintWriter("text/plain; charset=UTF-8")
try:
writer.println("Transition workflow script has been started")
count = 0
transitions = self.systemConfig.getArray("transitionWorkflow",
"transitions").toArray()
for transition in transitions:
fromWorkflowId = transition.get("from-workflow-id")
fromWorkflowStage = transition.get("from-workflow-stage")
packages = self.findPackagesToTransition(
fromWorkflowId, fromWorkflowStage)
for package in packages:
writer.println("processing: " + package.get("storage_id"))
self.log.debug("processing: " + package.get("storage_id"))
transitionWorkflow = TransitionWorkflow()
transitionWorkflow.run(
context, package.get("storage_id"), fromWorkflowId,
fromWorkflowStage, transition.get("to-workflow-id"),
transition.get("to-workflow-stage"),
transition.get("to-workflow-page-title"),
transition.get("to-workflow-label"))
self.log.debug("Transition workflow script processed " +
Integer(packages.size()).toString() +
" records for transition " +
transition.toString())
count = count + packages.size()
self.log.info("Transition workflow script processed " +
Integer(count).toString())
writer.println("Transition workflow script processed " +
Integer(count).toString())
self.log.info("Transition workflow script has completed")
writer.println("Transition workflow script has completed")
except Exception, e:
writer.println(
"The transition workflow script had a problem - check logs")
self.log.error("Exception in alerts code: %s" % (e.message))
raise
def makePythonList():
pylist = []
for i in range(COUNT):
# At present have to make it a java.lang.Integer for
# assertSequenceEqual to work. If in the future a
# java.lang.Integer can compare equality to a python int,
# then this should be updated to use python ints.
pylist.append(Integer(i))
return pylist
def test_number_compare(self):
x = 5
from java.lang import Integer
y = Integer(9)
refcount1 = sys.gettotalrefcount()
result = x < y
del result
refcount2 = sys.gettotalrefcount()
self.assertEquals(refcount1, refcount2 - 1)
def test_class(self):
Parent = jclass("com.chaquo.python.TestOverload$Parent")
Child = jclass("com.chaquo.python.TestOverload$Child")
Object = jclass("java.lang.Object")
Float = jclass("java.lang.Float")
String = jclass("java.lang.String")
Integer = jclass("java.lang.Integer")
s = String()
i = Integer(42)
f = Float(1.23)
child = Child()
parent = Parent()
self.assertEqual(parent.resolve(s), 'Parent Object')
self.assertEqual(parent.resolve(i), 'Parent Integer')
self.assertEqual(parent.resolve(f), 'Parent Object')
self.assertEqual(parent.resolve(f, s), 'Parent Object, String')
self.assertEqual(child.resolve(s), 'Child String')
self.assertEqual(child.resolve(i), 'Child Integer')
self.assertEqual(child.resolve(f), 'Child Object')
self.assertEqual(child.resolve(cast(Object, s)), 'Child Object')
self.assertEqual(child.resolve(cast(String, cast(Object, s))),
'Child String')
# Casting of None
with self.ambiguous:
child.resolve(None)
self.assertEqual(child.resolve(cast(String, None)), 'Child String')
self.assertEqual(child.resolve(cast(Object, None)), 'Child Object')
self.assertEqual(child.resolve(cast(String, cast(Object, None))),
'Child String')
self.assertEqual(child.resolve(s, i), 'Child String, Object')
self.assertEqual(child.resolve(i, s), 'Parent Object, String')
with self.inapplicable:
child.resolve(i, i)
# Casting of method parameters
with self.ambiguous:
child.resolve(s, s)
self.assertEqual(child.resolve(cast(Object, s), s),
'Parent Object, String')
self.assertEqual(child.resolve(s, cast(Object, s)),
'Child String, Object')
# Casting of object on which method is called should limit visibility of overloads, but
# subclass overrides of visible overloads should still be called.
child_Parent = cast(Parent, child)
self.assertEqual(child_Parent.resolve(s), 'Child Object')
self.assertEqual(child_Parent.resolve(s, s), 'Parent Object, String')
with self.inapplicable:
child_Parent.resolve(s, i)
with self.assertRaisesRegexp(
TypeError, "int object does not specify a Java type"):
cast(42, child)
def test_type_error(self):
try:
from java.util import Collections, ArrayList
x = ArrayList()
c = Collections.checkedList(x, Integer)
c.add(Integer(5))
c.add(String("5"))
except TypeError as ex:
pass
def test_mixed_static_and_instance(self):
MSI = TO.MixedStaticInstance
m = MSI()
self.assertEqual(m.resolve11("test"), "String")
self.assertEqual(m.resolve11(42), "Object")
self.assertEqual(MSI.resolve11("test"), "Object")
self.assertEqual(MSI.resolve11(42), "Object")
self.assertEqual(MSI.resolve11(m, "test"), "String")
with self.inapplicable:
MSI.resolve11(m, 42)
# ---
self.assertEqual(m.resolve10(), "")
self.assertEqual(m.resolve10("test"), "String")
with self.inapplicable:
MSI.resolve10()
self.assertEqual(MSI.resolve10("test"), "String")
self.assertEqual(MSI.resolve10(m), "")
with self.inapplicable:
MSI.resolve10(m, "test")
# ---
self.assertEqual(m.resolve01(), "")
self.assertEqual(m.resolve01("test"), "String")
self.assertEqual(MSI.resolve01(), "")
with self.inapplicable:
MSI.resolve01("test")
with self.inapplicable:
MSI.resolve01(m)
self.assertEqual(MSI.resolve01(m, "test"), "String")
# ---
from java.lang import Integer
i = Integer(42)
ts = r"^com.chaquo.python.TestOverload\$MixedStaticInstance@"
self.assertRegexpMatches(m.toString(), ts)
self.assertEqual(m.toString(i), "Integer")
with self.inapplicable:
MSI.toString()
self.assertEqual(MSI.toString(i), "Integer")
self.assertRegexpMatches(MSI.toString(m), ts)
with self.inapplicable:
MSI.toString(m, i)
def writeResponseToStatusResponseCache(self, jobId, jobStatus):
curationStatusRespones = File(FascinatorHome.getPath() +
"/curation-status-responses")
if curationStatusRespones.exists():
FileUtils.forceMkdir(curationStatusRespones)
FileUtils.writeStringToFile(
File(curationStatusRespones.getPath() +
"/" + Integer(jobId).toString() + ".json"),
jobStatus.toString(True))
def __init__(self):
head = 'Byte,Double,Float,Integer,Long,Short'.split(',')
self.data = [[
Byte(Byte.MIN_VALUE),
Double(Double.MIN_VALUE),
Float(Float.MIN_VALUE),
Integer(Integer.MIN_VALUE),
Long(Long.MIN_VALUE),
Short(Short.MIN_VALUE)
],
[
Byte(Byte.MAX_VALUE),
Double(Double.MAX_VALUE),
Float(Float.MAX_VALUE),
Integer(Integer.MAX_VALUE),
Long(Long.MAX_VALUE),
Short(Short.MAX_VALUE)
]]
DefaultTableModel.__init__(self, self.data, head)
def test_foreign_repl():
from java.util.logging import LogRecord
from java.util.logging import Level
lr = LogRecord(Level.ALL, "message")
assert repr(LogRecord).startswith('<JavaClass[java.util.logging.LogRecord] at')
assert repr(lr).startswith('<JavaObject[java.util.logging.LogRecord] at')
from java.lang import Integer
i = Integer('22')
assert repr(Integer).startswith('<JavaClass[java.lang.Integer] at')
assert repr(i) == '22'
def __init__( self, data, headings ) :
info = []
df = DateFormat.getDateInstance( DateFormat.SHORT )
for date, size, path in data :
info.append(
[
df.parse( date ),
Integer( size.strip().replace( ',', '' ) ),
String( path )
]
)
DefaultTableModel.__init__( self, info, headings )
def __init__(self, data, headings):
info = []
df = DateFormat.getDateInstance(DateFormat.SHORT)
for tf, date, size, f, d in data:
info.append([
Boolean(tf == '1'),
df.parse(date),
Integer(size.strip().replace(',', '')),
Float(f),
Double(d)
])
DefaultTableModel.__init__(self, info, headings)
def startAdminServer():
if connected == 'false':
try:
print "connect to Admin Server" + adminServerURL
#URL="t3://"+adminServerListenAddress+":"+adminServerListenPort
connect(userName, passWord, adminServerURL)
print "connect succeed, It will not be start the Admin Server."
except WLSTException:
print 'No server is running at '+adminServerURL+', the script will start a new server'
if connected == 'false':
cd("/") #@UndefinedVariable
adminServer = get("AdminServerName") #@UndefinedVariable
_timeout = 180000
print "try to start Admin Server"
print "adminServer:" + adminServer
print "domainDir:" + domainDir
print "domainName:" + domainName
print "adminServerURL:" + adminServerURL
print "userName:"******"resultFile:" + resultFile
if (timeOut is not None) and (len(timeOut) > 0):
_timeout = Integer(timeOut).intValue()
if (_jvmArgs is not None) and (len(_jvmArgs) > 0):
print "_timeout:" + Integer(_timeout).toString()
print "_jvmArgs:" + _jvmArgs
startServer(adminServer,domainName,adminServerURL,userName,passWord,domainDir,timeout=_timeout,jvmArgs=_jvmArgs,serverLog=resultFile)
else:
print "_timeout" + Integer(_timeout).toString()
startServer(adminServer,domainName,adminServerURL,userName,passWord,domainDir,timeout=_timeout,serverLog=resultFile) #@UndefinedVariable
print "Started Server. Trying to connect to the server ... "
try:
connect(userName, passWord, adminServerURL)
finally:
if connected=='false':
writeResultToFile(RESULT_FAILED)
else:
writeResultToFile(RESULT_SUCCEED)
else:
writeResultToFile(RESULT_SUCCEED)
def test_pow(self):
i, pi, j, pj, d, pd = self.get_values()
self.assertEqual(pow(i, i), pow(pi, pi))
self.assertEqual(pow(i, 3), pow(pi, 3))
self.assertEqual(pow(j, j), pow(pj, pj))
self.assertEqual(pow(j, 301), pow(pj, 301))
self.assertEqual(pow(d, d), pow(pd, pd))
self.assertEqual(pow(d, 4.53), pow(pd, 4.53))
k = Integer(2)
pk = k.intValue()
self.assertEqual(pow(i, 3, k), pow(pi, 3, pk))
self.assertEqual(pow(j, 301, k), pow(pj, 301, pk))
def __queryForecastTimes(self):
from com.raytheon.uf.common.dataquery.requests import DbQueryRequest
from com.raytheon.uf.viz.core.requests import ThriftClient
from java.lang import Integer
request = DbQueryRequest()
request.setConstraints(self._buildConstraints(self.refTime))
request.addRequestField('dataTime.fcstTime')
request.setOrderByField('dataTime.fcstTime')
request.setDistinct(True)
iForecastTimesLimit = Integer(self.forecastTimesLimit)
if (self.forecastTimesLimit > 0):
request.setLimit(iForecastTimesLimit)
return ThriftClient.sendRequest(request).getFieldObjects(
'dataTime.fcstTime', iForecastTimesLimit.getClass())
def map_to_vertx(value):
"""Converts a Jython type to a Vert.x type."""
if value is None:
return value
if isinstance(value, (list, tuple)):
return org.vertx.java.core.json.JsonArray(map_seq_to_java(value))
elif isinstance(value, dict):
return org.vertx.java.core.json.JsonObject(map_dict_to_java(value))
elif isinstance(value, Buffer):
return value._to_java_buffer()
elif isinstance(value, long):
return Long(value)
elif isinstance(value, float):
return Double(value)
elif isinstance(value, int):
return Integer(value)
return map_to_java(value)
def test_remove(self):
# Verifies that overloaded java.util.List#remove(int) method can still be used, but with Python index semantics
# http://bugs.jython.org/issue2456
jl = self.type2test(xrange(10, -1, -1)) # 10 .. 0, inclusive
jl.remove(0) # removes jl[-1] (=0)
self.assertEqual(jl, range(10, 0, -1)) # 10 .. 1
self.assertRaises(ValueError, jl.remove, Integer(0)) # j.l.Integer does not support __index__ - maybe it should!
jl.remove(0) # removes jl[0] (=10)
self.assertEqual(jl, range(9, 0, -1)) # 9 .. 1
jl.remove(-1) # removes jl[-1] (=1) - support same index calculations as Python (= del jl[-1])
self.assertEqual(jl, range(9, 1, -1)) # 9 .. 2
jl.remove(3)
jl.remove(5)
self.assertEqual(jl, [9, 8, 7, 6, 4, 2])
a_to_z = list(chr(i) for i in xrange(ord('a'), ord('z') + 1))
b_to_z_by_2 = list(chr(i) for i in xrange(ord('b'), ord('z') + 1, 2))
jl = self.type2test(a_to_z)
for i in xrange(13):
jl.remove(i)
self.assertEqual(jl, b_to_z_by_2)
def getJavaValue(self, value, type):
try:
if type == AppilogTypes.LONG_DEF:
return Long(value)
if type == AppilogTypes.INTEGER_DEF:
return Integer(value)
if type == AppilogTypes.FLOAT_DEF:
return Float(value)
if type == AppilogTypes.DOUBLE_DEF:
return Double(value)
if type == AppilogTypes.BOOLEAN_DEF:
return Boolean(value)
return value
except JavaException, ex:
msg = ex.getMessage()
info = logger.prepareJavaStackTrace()
logger.debug(info)
raise CiImportException, self.makeConversionMessage(
'Error while converting to type %s ' % type, msg)
