import time
from datetime import datetime, timedelta
 
def longsleep(minutes):
    """
    The normal time.sleep() method is not very accurate from inside
    VMware when sleeping for long periods of time.  This method is
    accurate to within +/- 5 seconds of the desired sleep time period.
    For long periods on the order of hours or days this small inaccuracy
    is acceptable.
    """
    sleepTimeSec = 60 * minutes
    now = datetime.utcnow()
    td = timedelta(seconds=sleepTimeSec)
    endTime = now + td
    while now <= endTime:
        time.sleep(5)
        now = datetime.utcnow()

The method is accurate to around +/- 5 seconds, but for really long sleep durations 5 seconds is no big deal.

Just today I found a really great package for Python called Scapy.  With Scapy I can create arbitrary packets with arbitrary values and fire away.  It also supports packet capturing and has all kinds of features.  As I get more comfortable with Scapy I'll post some examples.  In the mean time, those of you who need to inject custom packets for testing into equipment go check it out.

 
>>> listA = ['A', 'B', 'C', 'D']
>>> listB = listA
>>> listA
['A', 'B', 'C', 'D']
>>> listB
['A', 'B', 'C', 'D']
>>> listA.remove('C')
>>> listA
['A', 'B', 'D']
>>> listB
['A', 'B', 'D']
 

As you can see, B was assigned to reference the same list as A and removing something from A also removed it from B.

At times that is fine, however, sometimes you need a clone of the list so that changes in A do not reflect in B. A very simple way to accomplish that is by using slicing. Our example now becomes:

 
>>> listA = ['A', 'B', 'C', 'D']
>>> listB = listA[:]
>>> listA
['A', 'B', 'C', 'D']
>>> listB
['A', 'B', 'C', 'D']
>>> listA.remove('C')
>>> listA
['A', 'B', 'D']
>>> listB
['A', 'B', 'C', 'D']
 

There we go, problem solved.

I love Python and my personal experience has shown that testers are about 4x more productive when using Python than when using Java. However, at work I am a tester on a Java application. I've been looking for a way to bridge that gap and allow me to write my tests in Python but test a Java application.

I've looked into Jython and while it had many advantages it has one major drawback that I can't live with: Jython only implements Python 2.2. Most of the time this is fine, but there are times where I use Python 2.4 or 2.5 features and don't want to create a workaround just so I can use an older Python standard. If I had the money I would pay someone to bring Jython up to date. But, that's not a possibility.

I did find another alternative that so far seems to work great. It is still in development, but JPype seems to be working fairly well. JPype differs in philosophy from Jython in a fundamental way: Jython is a complete reimplementation of Python in Java, whereas JPype is a bridge between CPython and native Java.

Kicking The Tires

This article is a "how to," so let's get down to business. I'm going to create a Java class that I would like to access from Python. Here is Java class:

 
package org.wg3i.test;
 
class Test {
    private String msg;
 
    public Test() {
    }
 
    public void speak(String msg) {
	System.out.println(msg);
    }
 
    public void setString(String s) {
	msg = s;
    }
 
    public String getString() {
	return msg;
    }
}

The class is simple enough, but it will illustrate the basic JPype usage. For my testing I compiled this and placed it into a jar file. Feel free to leave it as a class file if you wish. I'll show you how to deal with both situations below.

For reference, here is my ant build file:

<?xml version="1.0"?>
<project name="TestProject"
 basedir="."
 default="jar">

  <property name="src.dir" value="src"/>
  <property name="build.dir" value="build"/>
  <property name="classes.dir" value="${build.dir}/classes"/>
  <property name="jar.dir" value="${build.dir}/jar"/>
 
  <target name="clean">
    <delete dir="build"/>
  </target>
 
  <target name="compile">
    <mkdir dir="${classes.dir}"/>
    <javac srcdir="${src.dir}" destdir="${classes.dir}"/>
  </target>
 
  <target name="jar" depends="compile">
    <mkdir dir="${jar.dir}"/>
    <jar destfile="${jar.dir}/${ant.project.name}.jar"
 basedir="${classes.dir}"/>
  </target>
 
  <target name="clean-build" depends="clean,jar">
  </target>
</project>
After creating a jar file you are ready to go. Here is the Python code to utilize a jar file and create an instance of the Java class.

 
# Simple little JPype test.  Note: This test assumes
# that the jar file is in the build/jar directory
# relative to the current directory
import jpype
import os.path
 
jarpath = os.path.join(os.path.abspath('.'), 'build/jar')
jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.ext.dirs=%s" % jarpath)
Test = jpype.JClass('org.wg3i.test.Test')  # get the class
t = Test()  # create an instance of the class
t.speak("This is a test message")  # try to call one of the class methods
t.setString("Hello, World")  # set a string
s = t.getString()  # get the string back
print s
jpype.shutdownJVM()

In a nutshell that's it. I promised to show you how to initialize JPype when you have class files and not jar files. Here's a Python example that shows that This example also shows the use of the JPackage method, which gets a package, not a class.

 
import jpype
import os.path
 
classpath = os.path.join(os.path.abspath('.'), 'build/classes')
jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.class.path=%s" % classpath)
testPkg = jpype.JPackage('org').wg3i.test  # get the package
Test = testPkg.Test # get the class
t = Test()  # create an instance of the class
t.speak("This is a test message")  # try to call one of the class methods
t.setString("Hello, World")  # set a string
s = t.getString()  # get the string back
print s
jpype.shutdownJVM()

Conclusion

There are many things I have not covered, such as passing arrays back and forth, types other than strings, exceptions, etc. However, this should be enough to get you started using JPype. I'd be interested in hearing your own experiences or suggestions.

In doing my searches I came across an interesting Python package that allows you to do basic dataflow programming.  This article by the author of zflow covers the basic usage and concepts of the package and dataflow programming in general.  I am interested to see if this package keeps evolving.  Now, I just need to figure out a good application in software testing for dataflow programming.  Any ideas?

Poking around on the web I found Report Lab, an excellent package for creating PDF's with a Python API.

|TestClass|
|InputString    |OutputNum    |
|Hello World    |>10       |
|Python is cool!|1 < _ < 100|

The value returned by the OutputNum method of TestClass should result in a comparison and the cell being highlighted green or red depending on a pass or fail. What the documents don't seem to point out is that doing the comparison on a field declared as an Integer in the _typeDict results in strange looking errors. After much frustration, checking and rechecking my syntax, I tried changing that number to a Float and it worked. So, Floats can be compared and have ranges and Integers can't.