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.

With both of these programs I want to try a distributed version control system. I've used CVS, Subversion, and Perforce for years, but this talk by Linus Torvalds convinced me to try something different.

Since SourceForge natively supports CVS and Subversion it is necessary to install a distributed version control system, such as Mercurial. This article explains the steps necessary to perform the installation of Mercurial on SourceForge.

Keep an eye on my projects and good luck setting up your own distributed source control system.

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

cat file | tr '\n' ','

Basically, this will turn a file like this:

Line1
Line2
Line3
Line4

Into this:

Line1,Line2,Line3,Line4

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.