continuum-core-it/it_utils.py - continuum - Git at Google

 #import continuum
 import os
 import shutil
 import sys
 import time
 import traceback

 #####################################################################
 # Configuration
 #####################################################################

 email = "trygvis@codehaus.org"
 basedir = os.getcwd() + "/target"

 #####################################################################
 #
 #####################################################################

 def progress( message ):
     print "[" + time.strftime( "%c" ) + "] * " + message

 def fail( message ):
     print "FAILURE: " + message
     sys.exit( -1 )

 def assertEquals( message, expected, actual ):
     if ( expected == None and actual != None ):
         assertionFailed( message, "None", actual )

     if ( expected != None and actual == None ):
         assertionFailed( message, expected, "None" )

     if( expected == actual ):
         return

     assertionFailed( message, expected, actual )

 def assertionFailed( message, expected, actual ):
     print
     print "##############################################"
     print "ASSERTION FAILURE!"
     print "##############################################"
     print "Message: " + message
     print "Expected: " + str( expected )
     print "Actual: " + str( actual )
     print "##############################################"
     print "Traceback"
     print "##############################################"
     traceback.print_stack()
     print "##############################################"
     print

     sys.exit( -1 )

 def assertTrue( message, condition ):
     assertEquals( message, True, condition )

 def assertFalse( message, condition ):
     assertEquals( message, False, condition )

 def assertNotNull( message, condition ):
     if ( condition != None ):
         return

     assertionFailed( message, "Not None", condition )

 def assertProject( projectId, name, nagEmailAddress, version, commandLineArguments, executorId, project ):
     assertNotNull( "project.id", projectId )
     assertEquals( "project.name", name, project.name )
 #    assertEquals( "project.state", state, project.state )
     assertEquals( "project.version", version, project.version )
     assertEquals( "project.commandLineArguments", commandLineArguments, project.commandLineArguments )
     assertEquals( "project.executorId", executorId, project.executorId )

     if ( nagEmailAddress == None ):
         assertEquals( "project.notifiers.size", 0, len( project.notifiers ) )
     else:
         assertEquals( "project.notifiers.size", 1, len( project.notifiers ) )
         assertEquals( "project.notifiers[0].type", "mail", project.notifiers[0].type )
         print str( project.notifiers[0].configuration )
         assertTrue( "project.notifiers[0].configuration.has_key('address')", project.notifiers[0].configuration.has_key('address') )
         assertEquals( "project.notifiers[0].configuration['address']", nagEmailAddress, project.notifiers[0].configuration['address'] )

 def assertCheckedOutFiles( project, expectedCheckedOutFiles ):
     actualCheckedOutFiles = project.checkOutScmResult.checkedOutFiles
     if ( len( expectedCheckedOutFiles ) != len( actualCheckedOutFiles ) ):
         print "Expected files: "
         for expectedFile in expectedCheckedOutFiles:
             print " " + expectedFile

         print "Actual files: "
         for actualFile in actualCheckedOutFiles:
             print " " + actualFile.path

     assertEquals( "The expected and actual lists of checked out files doesn't have the same length.",
                   len( expectedCheckedOutFiles ),
                   len( actualCheckedOutFiles ) )

     i = 0
     for expectedFile in expectedCheckedOutFiles:
         actualFile = actualCheckedOutFiles[ i ]
         i += 1

         assertEquals( "File #" + str( i ) + " doesn't match the expected path.", expectedFile, actualFile.path )

 def assertSuccessfulNoBuildPerformed( continuum, buildId ):
     build = waitForBuild( continuum, buildId )
     assertEquals( "The build wasn't successful.", continuum.STATE_OK, build.state )
     assertTrue( "The build wasn't successful", build.success )

 def assertSuccessfulMaven1Build( continuum, buildId ):
     build = waitForBuild( continuum, buildId )
     assertEquals( "The build wasn't successful.", continuum.STATE_OK, build.state )
     assertTrue( "The build wasn't successful", build.success )
     assertTrue( "Standard output didn't contain the 'BUILD SUCCESSFUL' message.", build.standardOutput.find( "BUILD SUCCESSFUL" ) != -1 )
     assertEquals( "Standard error wasn't empty.", 0, len( build.standardError ) )

 def assertSuccessfulMaven2Build( continuum, buildId ):
     build = waitForBuild( continuum, buildId )
     assertEquals( "The build wasn't successful.", continuum.STATE_OK, build.state )
     assertTrue( "The build wasn't successful", build.success )
     assertTrue( "Standard output didn't contain the 'BUILD SUCCESSFUL' message.", build.standardOutput.find( "BUILD SUCCESSFUL" ) != -1 )
     assertEquals( "Standard error wasn't empty.", 0, len( build.standardError ) )

     return build

 def assertSuccessfulAntBuild( continuum, buildId ):
     build = waitForBuild( continuum, buildId )
     assertEquals( "The build wasn't successful.", continuum.STATE_OK, build.state )
     assertTrue( "The build wasn't successful", build.success )
     assertTrue( "Standard output didn't contain the 'BUILD SUCCESSFUL' message.", build.standardOutput.find( "BUILD SUCCESSFUL" ) != -1 )
     assertEquals( "Standard error wasn't empty.", 0, len( build.standardError ) )

 def assertSuccessfulShellBuild( continuum, buildId, expectedStandardOutput ):
     build = waitForBuild( continuum, buildId )
     assertEquals( "The build wasn't successful.", continuum.STATE_OK, build.state )
     assertTrue( "The build wasn't successful", build.success )
     assertEquals( "Standard output didn't contain the expected output.", expectedStandardOutput, build.standardOutput )
     assertEquals( "Standard error wasn't empty.", 0, len( build.standardError ) )

 def buildProject( continuum, projectId, force=False ):
     count = 600;

     originalSize = len( continuum.getBuildsForProject( projectId ) )

     continuum.buildProject( projectId, force )

     while( True ):
         builds = continuum.getBuildsForProject( projectId )

         size = len( builds )

         count = count - 1
         if ( count == 0 ):
             fail( "Timeout while waiting for build result." )

         if ( size == originalSize ):
             time.sleep( 0.1 )
             continue

         return builds[ 0 ]

     # This will never happen, it is just to make pychecker shut up
     return None

 def removeProject( continuum, projectId ):
     time.sleep( 0.5 )
     continuum.removeProject( projectId )

     result = continuum.server.continuum.getProject( projectId )

     if ( result[ "result" ] != "failure" ):
         print result
         fail( "Expected a failure when removing project." )

 def execute( workingDirectory, command ):
     cwd = os.getcwd()
     os.chdir( workingDirectory )
     f = os.popen( command )
     os.chdir( cwd )

     output = f.read()

     ret = f.close()

     if ( ret != None ):
         print output
         print "ret: " + str( ret )
         fail( "The command didn't return 0." )

     return output

 def waitForBuild( continuum, buildId ):
     timeout = 120                # seconds
     sleepInterval = 0.1

     build = continuum.getBuild( buildId )

     while( build.state == continuum.STATE_UPDATING or
            build.state == continuum.STATE_BUILDING ):

         if ( timeout <= 0 ):
             fail( "Timeout while waiting for build (id=%(id)s) to complete" % { "id" : buildId } )

         time.sleep( sleepInterval )

         timeout -= sleepInterval

         build = continuum.getBuild( buildId )

     return build

 def waitForSuccessfulCheckOut( continuum, projectId ):
     project = waitForCheckOut( continuum, projectId )

 #    assertEquals( "The check out was not successful for project #" + project.id, continuum.STATE_NEW, project.state )
     assertEquals( "The check out was not successful for project #" + project.id, None, project.checkOutErrorMessage )
     assertEquals( "The check out was not successful for project #" + project.id, None, project.checkOutErrorException )
     assertTrue( "The check out was not successful for project #" + project.id, project.checkOutScmResult.success )

     return project

 def waitForCheckOut( continuum, projectId ):
     timeout = 60
     sleepInterval = 0.1

     project = continuum.getProject( projectId )

     while( project.checkOutScmResult == None and
            project.checkOutErrorMessage == None and
            project.checkOutErrorException == None ):
         project = continuum.getProject( projectId )
         time.sleep( sleepInterval )
         timeout -= sleepInterval

         if ( timeout <= 0 ):
             fail( "Timeout while waiting for checkout (project id=%(id)s) to complete" % { "id" : project.id } )

     return project

 def cleanDirectory( dir ):
     if ( os.path.isdir( dir ) ):
         shutil.rmtree( dir )

 def cvsCommit( basedir ):
     return execute( basedir, "cvs commit -m ''" );

 def cvsCheckout( cvsroot, module, coDir ):
     return execute( basedir, "cvs -d " + cvsroot + " checkout -d " + coDir + " " + module );

 def cvsImport( basedir, cvsroot, artifactId ):
     return execute( basedir, "cvs -d " + cvsroot + " import -m '' " + artifactId + " continuum_test start" )

 def svnImport( basedir, svnroot, artifactId ):
     return execute( basedir, "svn import -m '' . file://" + svnroot + "/" + artifactId )

 def makeScmUrl( scm, scmroot, artifactId ):
     if ( scm == "cvs" ):
         return "scm:cvs:local:%(scmroot)s:%(module)s" % { "scmroot" : scmroot , "module" : artifactId }
     elif ( scm == "svn" ):
         return "scm:svn:file:%(scmroot)s/%(artifactId)s" % { "scmroot" : scmroot , "module" : artifactId }

     raise Exception( "Unknown SCM type '" + scm + "'" )

 def getProjectId( projectIds ):
     if ( len( projectIds ) != 1 ):
         fail( "When adding a project only a single project was expected to be added, project ids: " + str( projectIds ) );

     return projectIds[ 0 ]

 def writeMavenOnePom( filename, artifactId, scmUrl, email ):
     pom = file( "/" + filename, "w+" )
     pom.write( """
 <project>
   <pomVersion>3</pomVersion>
   <groupId>continuum</groupId>
   <artifactId>%(artifactId)s</artifactId>
   <currentVersion>1.0</currentVersion>
   <name>Maven 1 Project</name>
   <repository>
     <connection>%(scmUrl)s</connection>
   </repository>
   <build>
     <nagEmailAddress>%(email)s</nagEmailAddress>
   </build>
 </project>
 """ % {
         "artifactId" : artifactId,
         "scmUrl" : scmUrl,
         "email" : email
       } )
     pom.close()

 def initMaven1Project( basedir, scm, cvsroot, artifactId ):
     cleanDirectory( basedir )
     os.makedirs( basedir )
     writeMavenOnePom( basedir + "/project.xml", artifactId, makeScmUrl( scm, cvsroot, artifactId ), email )

     os.makedirs( basedir + "/src/main/java" )
     foo = file( basedir + "/src/main/java/Foo.java", "w+" )
     foo.write( "class Foo { }" )
     foo.close()

     cvsImport( basedir, cvsroot, artifactId )

 def initMaven2Project( basedir, cvsroot, artifactId ):
     cleanDirectory( basedir )
     os.makedirs( basedir )
     pom = file( basedir + "/pom.xml", "w+" )
     pom.write( """
 <project>
   <modelVersion>4.0.0</modelVersion>
   <groupId>continuum</groupId>
   <artifactId>%(artifactId)s</artifactId>
   <version>2.0-SNAPSHOT</version>
   <name>Maven 2 Project</name>
   <ciManagement>
     <notifiers>
       <notifier>
         <type>mail</type>
         <configuration>
           <address>%(email)s</address>
         </configuration>
       </notifier>
     </notifiers>
   </ciManagement>
   <scm>
     <connection>scm:cvs:local:%(cvsroot)s:%(artifactId)s</connection>
   </scm>
 </project>
 """ % { "artifactId" : artifactId, "cvsroot" : cvsroot, "email" : email } )
     pom.close()

     os.makedirs( basedir + "/src/main/java" )
     foo = file( basedir + "/src/main/java/Foo.java", "w+" )
     foo.write( "class Foo { }" )
     foo.close()

     cvsImport( basedir, cvsroot, artifactId )

 def initAntProject( basedir ):
     cleanDirectory( basedir )
     os.makedirs( basedir )
     buildXml = file( basedir + "/build.xml", "w+" )
     buildXml.write( """
 <project>
   <target name="build">
     <property name="classes" value="target/classes"/>
     <mkdir dir="${classes}"/>
     <javac srcdir="src/main/java" destdir="${classes}"/>
   </target>
   <target name="clean">
     <delete dir="${classes}"/>
   </target>
 </project>""" )
     buildXml.close()

     os.makedirs( basedir + "/src/main/java" )
     foo = file( basedir + "/src/main/java/Foo.java", "w+" )
     foo.write( "class Foo { }" )
     foo.close()

 def initShellProject( basedir ):
     cleanDirectory( basedir )
     os.makedirs( basedir )
     script = file( basedir + "/script.sh", "w+" )
     script.write( """#!/bin/sh
 for arg in "$@"
 do
   echo $arg
   done
 """ )
     script.close()
     os.system( "chmod +x " + basedir + "/script.sh" )
	#import continuum
	import os
	import shutil
	import sys
	import time
	import traceback

	#####################################################################
	# Configuration
	#####################################################################

	email = "trygvis@codehaus.org"
	basedir = os.getcwd() + "/target"

	#####################################################################
	#
	#####################################################################

	def progress( message ):
	print "[" + time.strftime( "%c" ) + "] * " + message

	def fail( message ):
	print "FAILURE: " + message
	sys.exit( -1 )

	def assertEquals( message, expected, actual ):
	if ( expected == None and actual != None ):
	assertionFailed( message, "None", actual )

	if ( expected != None and actual == None ):
	assertionFailed( message, expected, "None" )

	if( expected == actual ):
	return

	assertionFailed( message, expected, actual )

	def assertionFailed( message, expected, actual ):
	print
	print "##############################################"
	print "ASSERTION FAILURE!"
	print "##############################################"
	print "Message: " + message
	print "Expected: " + str( expected )
	print "Actual: " + str( actual )
	print "##############################################"
	print "Traceback"
	print "##############################################"
	traceback.print_stack()
	print "##############################################"
	print

	sys.exit( -1 )

	def assertTrue( message, condition ):
	assertEquals( message, True, condition )

	def assertFalse( message, condition ):
	assertEquals( message, False, condition )

	def assertNotNull( message, condition ):
	if ( condition != None ):
	return

	assertionFailed( message, "Not None", condition )

	def assertProject( projectId, name, nagEmailAddress, version, commandLineArguments, executorId, project ):
	assertNotNull( "project.id", projectId )
	assertEquals( "project.name", name, project.name )
	# assertEquals( "project.state", state, project.state )
	assertEquals( "project.version", version, project.version )
	assertEquals( "project.commandLineArguments", commandLineArguments, project.commandLineArguments )
	assertEquals( "project.executorId", executorId, project.executorId )

	if ( nagEmailAddress == None ):
	assertEquals( "project.notifiers.size", 0, len( project.notifiers ) )
	else:
	assertEquals( "project.notifiers.size", 1, len( project.notifiers ) )
	assertEquals( "project.notifiers[0].type", "mail", project.notifiers[0].type )
	print str( project.notifiers[0].configuration )
	assertTrue( "project.notifiers[0].configuration.has_key('address')", project.notifiers[0].configuration.has_key('address') )
	assertEquals( "project.notifiers[0].configuration['address']", nagEmailAddress, project.notifiers[0].configuration['address'] )

	def assertCheckedOutFiles( project, expectedCheckedOutFiles ):
	actualCheckedOutFiles = project.checkOutScmResult.checkedOutFiles
	if ( len( expectedCheckedOutFiles ) != len( actualCheckedOutFiles ) ):
	print "Expected files: "
	for expectedFile in expectedCheckedOutFiles:
	print " " + expectedFile

	print "Actual files: "
	for actualFile in actualCheckedOutFiles:
	print " " + actualFile.path

	assertEquals( "The expected and actual lists of checked out files doesn't have the same length.",
	len( expectedCheckedOutFiles ),
	len( actualCheckedOutFiles ) )

	i = 0
	for expectedFile in expectedCheckedOutFiles:
	actualFile = actualCheckedOutFiles[ i ]
	i += 1

	assertEquals( "File #" + str( i ) + " doesn't match the expected path.", expectedFile, actualFile.path )

	def assertSuccessfulNoBuildPerformed( continuum, buildId ):
	build = waitForBuild( continuum, buildId )
	assertEquals( "The build wasn't successful.", continuum.STATE_OK, build.state )
	assertTrue( "The build wasn't successful", build.success )

	def assertSuccessfulMaven1Build( continuum, buildId ):
	build = waitForBuild( continuum, buildId )
	assertEquals( "The build wasn't successful.", continuum.STATE_OK, build.state )
	assertTrue( "The build wasn't successful", build.success )
	assertTrue( "Standard output didn't contain the 'BUILD SUCCESSFUL' message.", build.standardOutput.find( "BUILD SUCCESSFUL" ) != -1 )
	assertEquals( "Standard error wasn't empty.", 0, len( build.standardError ) )

	def assertSuccessfulMaven2Build( continuum, buildId ):
	build = waitForBuild( continuum, buildId )
	assertEquals( "The build wasn't successful.", continuum.STATE_OK, build.state )
	assertTrue( "The build wasn't successful", build.success )
	assertTrue( "Standard output didn't contain the 'BUILD SUCCESSFUL' message.", build.standardOutput.find( "BUILD SUCCESSFUL" ) != -1 )
	assertEquals( "Standard error wasn't empty.", 0, len( build.standardError ) )

	return build

	def assertSuccessfulAntBuild( continuum, buildId ):
	build = waitForBuild( continuum, buildId )
	assertEquals( "The build wasn't successful.", continuum.STATE_OK, build.state )
	assertTrue( "The build wasn't successful", build.success )
	assertTrue( "Standard output didn't contain the 'BUILD SUCCESSFUL' message.", build.standardOutput.find( "BUILD SUCCESSFUL" ) != -1 )
	assertEquals( "Standard error wasn't empty.", 0, len( build.standardError ) )

	def assertSuccessfulShellBuild( continuum, buildId, expectedStandardOutput ):
	build = waitForBuild( continuum, buildId )
	assertEquals( "The build wasn't successful.", continuum.STATE_OK, build.state )
	assertTrue( "The build wasn't successful", build.success )
	assertEquals( "Standard output didn't contain the expected output.", expectedStandardOutput, build.standardOutput )
	assertEquals( "Standard error wasn't empty.", 0, len( build.standardError ) )

	def buildProject( continuum, projectId, force=False ):
	count = 600;

	originalSize = len( continuum.getBuildsForProject( projectId ) )

	continuum.buildProject( projectId, force )

	while( True ):
	builds = continuum.getBuildsForProject( projectId )

	size = len( builds )

	count = count - 1
	if ( count == 0 ):
	fail( "Timeout while waiting for build result." )

	if ( size == originalSize ):
	time.sleep( 0.1 )
	continue

	return builds[ 0 ]

	# This will never happen, it is just to make pychecker shut up
	return None

	def removeProject( continuum, projectId ):
	time.sleep( 0.5 )
	continuum.removeProject( projectId )

	result = continuum.server.continuum.getProject( projectId )

	if ( result[ "result" ] != "failure" ):
	print result
	fail( "Expected a failure when removing project." )

	def execute( workingDirectory, command ):
	cwd = os.getcwd()
	os.chdir( workingDirectory )
	f = os.popen( command )
	os.chdir( cwd )

	output = f.read()

	ret = f.close()

	if ( ret != None ):
	print output
	print "ret: " + str( ret )
	fail( "The command didn't return 0." )

	return output

	def waitForBuild( continuum, buildId ):
	timeout = 120 # seconds
	sleepInterval = 0.1

	build = continuum.getBuild( buildId )

	while( build.state == continuum.STATE_UPDATING or
	build.state == continuum.STATE_BUILDING ):

	if ( timeout <= 0 ):
	fail( "Timeout while waiting for build (id=%(id)s) to complete" % { "id" : buildId } )

	time.sleep( sleepInterval )

	timeout -= sleepInterval

	build = continuum.getBuild( buildId )

	return build

	def waitForSuccessfulCheckOut( continuum, projectId ):
	project = waitForCheckOut( continuum, projectId )

	# assertEquals( "The check out was not successful for project #" + project.id, continuum.STATE_NEW, project.state )
	assertEquals( "The check out was not successful for project #" + project.id, None, project.checkOutErrorMessage )
	assertEquals( "The check out was not successful for project #" + project.id, None, project.checkOutErrorException )
	assertTrue( "The check out was not successful for project #" + project.id, project.checkOutScmResult.success )

	return project

	def waitForCheckOut( continuum, projectId ):
	timeout = 60
	sleepInterval = 0.1

	project = continuum.getProject( projectId )

	while( project.checkOutScmResult == None and
	project.checkOutErrorMessage == None and
	project.checkOutErrorException == None ):
	project = continuum.getProject( projectId )
	time.sleep( sleepInterval )
	timeout -= sleepInterval

	if ( timeout <= 0 ):
	fail( "Timeout while waiting for checkout (project id=%(id)s) to complete" % { "id" : project.id } )

	return project

	def cleanDirectory( dir ):
	if ( os.path.isdir( dir ) ):
	shutil.rmtree( dir )

	def cvsCommit( basedir ):
	return execute( basedir, "cvs commit -m ''" );

	def cvsCheckout( cvsroot, module, coDir ):
	return execute( basedir, "cvs -d " + cvsroot + " checkout -d " + coDir + " " + module );

	def cvsImport( basedir, cvsroot, artifactId ):
	return execute( basedir, "cvs -d " + cvsroot + " import -m '' " + artifactId + " continuum_test start" )

	def svnImport( basedir, svnroot, artifactId ):
	return execute( basedir, "svn import -m '' . file://" + svnroot + "/" + artifactId )

	def makeScmUrl( scm, scmroot, artifactId ):
	if ( scm == "cvs" ):
	return "scm:cvs:local:%(scmroot)s:%(module)s" % { "scmroot" : scmroot , "module" : artifactId }
	elif ( scm == "svn" ):
	return "scm:svn:file:%(scmroot)s/%(artifactId)s" % { "scmroot" : scmroot , "module" : artifactId }

	raise Exception( "Unknown SCM type '" + scm + "'" )

	def getProjectId( projectIds ):
	if ( len( projectIds ) != 1 ):
	fail( "When adding a project only a single project was expected to be added, project ids: " + str( projectIds ) );

	return projectIds[ 0 ]

	def writeMavenOnePom( filename, artifactId, scmUrl, email ):
	pom = file( "/" + filename, "w+" )
	pom.write( """
	<project>
	<pomVersion>3</pomVersion>
	<groupId>continuum</groupId>
	<artifactId>%(artifactId)s</artifactId>
	<currentVersion>1.0</currentVersion>
	<name>Maven 1 Project</name>
	<repository>
	<connection>%(scmUrl)s</connection>
	</repository>
	<build>
	<nagEmailAddress>%(email)s</nagEmailAddress>
	</build>
	</project>
	""" % {
	"artifactId" : artifactId,
	"scmUrl" : scmUrl,
	"email" : email
	} )
	pom.close()

	def initMaven1Project( basedir, scm, cvsroot, artifactId ):
	cleanDirectory( basedir )
	os.makedirs( basedir )
	writeMavenOnePom( basedir + "/project.xml", artifactId, makeScmUrl( scm, cvsroot, artifactId ), email )

	os.makedirs( basedir + "/src/main/java" )
	foo = file( basedir + "/src/main/java/Foo.java", "w+" )
	foo.write( "class Foo { }" )
	foo.close()

	cvsImport( basedir, cvsroot, artifactId )

	def initMaven2Project( basedir, cvsroot, artifactId ):
	cleanDirectory( basedir )
	os.makedirs( basedir )
	pom = file( basedir + "/pom.xml", "w+" )
	pom.write( """
	<project>
	<modelVersion>4.0.0</modelVersion>
	<groupId>continuum</groupId>
	<artifactId>%(artifactId)s</artifactId>
	<version>2.0-SNAPSHOT</version>
	<name>Maven 2 Project</name>
	<ciManagement>
	<notifiers>
	<notifier>
	<type>mail</type>
	<configuration>
	<address>%(email)s</address>
	</configuration>
	</notifier>
	</notifiers>
	</ciManagement>
	<scm>
	<connection>scm:cvs:local:%(cvsroot)s:%(artifactId)s</connection>
	</scm>
	</project>
	""" % { "artifactId" : artifactId, "cvsroot" : cvsroot, "email" : email } )
	pom.close()

	os.makedirs( basedir + "/src/main/java" )
	foo = file( basedir + "/src/main/java/Foo.java", "w+" )
	foo.write( "class Foo { }" )
	foo.close()

	cvsImport( basedir, cvsroot, artifactId )

	def initAntProject( basedir ):
	cleanDirectory( basedir )
	os.makedirs( basedir )
	buildXml = file( basedir + "/build.xml", "w+" )
	buildXml.write( """
	<project>
	<target name="build">
	<property name="classes" value="target/classes"/>
	<mkdir dir="${classes}"/>
	<javac srcdir="src/main/java" destdir="${classes}"/>
	</target>
	<target name="clean">
	<delete dir="${classes}"/>
	</target>
	</project>""" )
	buildXml.close()

	os.makedirs( basedir + "/src/main/java" )
	foo = file( basedir + "/src/main/java/Foo.java", "w+" )
	foo.write( "class Foo { }" )
	foo.close()

	def initShellProject( basedir ):
	cleanDirectory( basedir )
	os.makedirs( basedir )
	script = file( basedir + "/script.sh", "w+" )
	script.write( """#!/bin/sh
	for arg in "$@"
	do
	echo $arg
	done
	""" )
	script.close()
	os.system( "chmod +x " + basedir + "/script.sh" )