struct.pack

            str(len(testcaseNumber)) + 'sB' + \
            str(len(target)) + 'sB' + \
            str(len(description)) + 'sB' + 'IBBB'
    return struct.pack(format, initialBinary, bigEndian[0], protocolVersion,\
                       len(project), project,\
                       len(version), version,\
                       len(testcaseNumber), testcaseNumber,\

def formatInputData(inputNumber,dataType,data,time,timeResolution):
    if dataType == 8 or dataType == 9:
        format = bigEndian[1] + 'BHBH' + str(len(data)) + 's' + timeTypes[timeResolution]
        #print "Number: " + str(inputNumber) + " Format: " + str(format)
        return struct.pack(format, input1, inputNumber,\
                           dataType, len(data), data, time)
    else:
        if dataType == 4:
            format = bigEndian[1] + 'BHB' + dataTypes[dataType] + timeTypes[timeResolution]
            #print "Number: " + str(inputNumber) + " Format: " + str(format)
            return struct.pack(format, input1, inputNumber,\

        else:
            format = bigEndian[1] + 'BHB' + dataTypes[dataType] + timeTypes[timeResolution]
            #print "Number: " + str(inputNumber) + " Format: " + str(format)
            return struct.pack(format, input1, inputNumber,\
                               dataType, data, time)        
 
# formatInput2Data

def formatOutputType(outputTypeNumber,outputTypeName,dataType):
    format = bigEndian[1] + 'BBB' + str(len(outputTypeName)) + 'sB'
    return struct.pack(format,outputType,outputTypeNumber,len(outputTypeName),outputTypeName,dataType)
 
# formatOutputData
# <0x11><output number><output type><L*><data><time>
def formatOutput1Data(outputNumber,outputType,dataType,data,time):
    if dataType == 9 or dataType == 8:
        format = bigEndian[1] + 'BHBH' + str(len(data)) + 'sI'
        return struct.pack(format,output1,outputNumber,\

    else:
        if dataType == 4:
            format = bigEndian[1] + 'BHB' + dataTypes[dataType] + 'I'
            return struct.pack(format,output1,outputNumber,\
                               outputType,data[0],data[1],data[2],time)
        else:
            format = bigEndian[1] + 'BHB' + dataTypes[dataType] + 'I'
            return struct.pack(format,output1,outputNumber,\

    #else:
    if dataType == 4:
        format = bigEndian[1] + 'BHBH'
        output2Data = struct.pack(format,output2,outputNumber,\
                               outputType,len(dataTimes))
        format = bigEndian[1] + dataTypes[dataType] + 'I'
        for data,time in dataTimes:
            output2Data += struct.pack(format,data[0],data[1],data[2],time).rstrip('\n')
    else:
        format = bigEndian[1] + 'BHBH'
        output2Data = struct.pack(format,output2,outputNumber,\

    #else:
    if dataType == 4:
        format = bigEndian[1] + 'BHBH'
        output3Data = struct.pack(format,output3,outputNumber,\
                               outputType,len(datas))
        format = bigEndian[1] + dataTypes[dataType]
        for data in datas:
            output3Data += struct.pack(format,data[0],data[1],data[2]).rstrip('\n')
    else:
        format = bigEndian[1] + 'BHBH'
        output3Data = struct.pack(format,output3,outputNumber,\

def intToBytes(intValue):
    bytes = struct.pack('>I',intValue)
    bytes = struct.unpack('>BBBB',bytes)
    return bytes
 
def formatProjectChange(id):
    format = bigEndian[1] + 'BBBB'
    return struct.pack(format,projectChange,id[0],id[1],id[2])

def play_msf(startmin, startsec, startfrm, endmin, endsec, endfrm):
#	cd_open()
	cd.last=(endmin,endsec,endfrm)
	region = struct.pack(region_fmt,startmin,startsec,startfrm,endmin,endsec,endfrm)
	ioctl(cd.cd, CDROMPLAYMSF, region)
#	cd_close()
 

def get_volume():
#	cd_open()
	try:
		return struct.unpack("BBBB",ioctl(cd.cd, CDROMVOLREAD, struct.pack("BBBB",0,0,0,0)))
 
	except:
		return (0,0,0,0)
#	cd_close()
 
def set_volume(frontleft,frontright=None,backleft=0,backright=0):
#	cd_open()
	if frontright == None: frontright = frontleft
	try:
		return struct.unpack("BBBB",ioctl(cd.cd, CDROMVOLCTRL, struct.pack("BBBB",frontleft,frontright,backleft,backright)))

def get_status(time=0, all=0):
#	cd_open()
	result = 0
	i = 1
	while result == 0 and i < 5:
		try:	# If this fails then it's because it's happening too fast, just retry
			info = ioctl(cd.cd, CDROMSUBCHNL, struct.pack(subchnl_fmt, CDROM_MSF,0,0,0,0,0,0,0))
			drvstatus = get_drive_status()
			result = 1
		except:
			i = i +1
#	cd_close()
	format, status, track, something, absaddr, relmin, relsec, relfrm = struct.unpack(subchnl_fmt, info)
	absmin, abssec, absfrm = struct.unpack(addr_fmt, struct.pack("i", absaddr))

def get_header():
#	cd_open()
	tochdr = struct.pack(tochdr_fmt, 0, 0)
	tochdr = ioctl(cd.cd, CDROMREADTOCHDR, tochdr)
	cd.start, cd.end = struct.unpack(tochdr_fmt, tochdr)
#	cd_close()
 
def get_track_time(trk):
	if cd.start == None:
		get_header()
	if   trk < 1: trk = 1
	elif trk > cd.end: trk = CDROM_LEADOUT
#	cd_open()
	toc = struct.pack(tocentry_fmt, trk, 0, CDROM_MSF, 0)

	toc = ioctl(cd.cd, CDROMREADTOCENTRY, toc)
 
	track, adrctrl, format, addr = struct.unpack(tocentry_fmt, toc)
	m, s, f = struct.unpack(addr_fmt, struct.pack("i", addr))
 
	adr = adrctrl & 0xf
	ctrl = (adrctrl & 0xf0) >> 4

 
	#print 'client_location', x, y, z, heading, bin(flags)
 
	data = struct.pack('=3fBB', x, y, z, heading, flags)+data[14:]
 
	if flags&64:
		if flags&4:

def preprocess_client_harvest(client, opcode, data):
	(mode,) = struct.unpack('I', data)
	print 'client_harvest', mode
 
	data = struct.pack('I', mode)
 
	return (opcode, data)	

 
	print 'client_attack', hex(objid), counter, bin(unknown), delay, animation
 
	data = struct.pack('=IBBBB', objid, counter, unknown, delay, animation)
 
	return (opcode, data)
 

	if unknown1 != 1 or unknown3 != 0:
		print '******* HEY, IOOK AT ME! *********'
 
	data = struct.pack('=IHHHHH', objid, action, unknown1, unknown2, quest_id, unknown3)
 
	return (opcode, data)
 
def preprocess_client_loot(client, opcode, data):
	objid, mode = struct.unpack('=IB', data)
 
	print 'client_loot', hex(objid), mode
 
	data = struct.pack('=IB', objid, mode)

	#amount |= 0xFF000000
	#unknown = 0x10000000
 
	data = struct.pack('=3IBIBH', item_id, amount, unknown, from_type, to_item_id, to_type, slot)
 
	return (opcode, data)
 

 
	#height = 50
 
	data = struct.pack('=I66s9I44Bf', account_id, strings, gender, race, class_id, unknown1, 
	unknown2, voice, skin_color, hair_color, lip_color,
	face, hair, decoration, tattoo, unknown3, face_shape, forehead,
	eye_height, eye_space, eye_width, eye_size, eye_shape, eye_angle,

def preprocess_server_flight_time(server, opcode, data):
	time_left, max_time = struct.unpack('=II', data)
 
	#print 'server_flight_time', time_left, max_time
 
	data = struct.pack('=II', time_left, max_time)
 

def preprocess_client_teleport(client, opcode, data):
	objid, destination, unknown = struct.unpack('=IIH', data)
 
	print 'client_teleport', hex(objid), destination, unknown
 
	data = struct.pack('=IIH', objid, destination, unknown)
 

 
	print 'client_craft', flags, craft_id, recipe_id, hex(objid), ingredients
 
	data = struct.pack('=BIIIH', flags, craft_id, recipe_id, objid, len(ingredients))
 
	for ingredient in ingredients:
		data += struct.pack('=III', ingredient[0], ingredient[1], ingredient[2])

def preprocess_server_itemdestroyed(server, opcode, data):
	(item_id, unknown) = struct.unpack('=IB', data)
 
	print 'server_itemdestroyed', item_id, bin(unknown)
 
	data = struct.pack('=IB', item_id, unknown)
 

 
	print 'client_npcshop', hex(objid), action, items
 
	data = struct.pack('=IHH', objid, action, len(items))
 
	for item in items:
		data += struct.pack('=III', item[0], item[1], item[2])

 
	print 'server_inventorystatus', unknown1, item_count, unknown2, unknown3, unknown4
 
	data = struct.pack('=HIBBB', unknown1, item_count, unknown2, unknown3, unknown4)
 
	return (opcode, data)
 

def preprocess_server_npcreply(server, opcode, data):
	objid, unknown1, unknown2 = struct.unpack('=3I', data)
 
	print 'server_npcreply', hex(objid), unknown1, unknown2
 
	data = struct.pack('=3I', objid, unknown1, unknown2)
 

def preprocess_server_shopsell(server, opcode, data):
	objid, unknown = struct.unpack('=2I', data)
 
	print 'server_shopsell', hex(objid), unknown
 
	data = struct.pack('=2I', objid, unknown)
 

def preprocess_server_target_info(server, opcode, data):
	(objid, level, hp, max_hp) = struct.unpack('=IH2I', data)
 
	print 'server_target_info', hex(objid), level, hp, max_hp
 
	data = struct.pack('=IH2I', objid, level, hp, max_hp)
 

def preprocess_server_spawn_object(server, opcode, data):
	(x, y, z, objid, unknown1, type_id, unknown2, unknown3, name_id, unknown4, unknown5, unknown6) = struct.unpack('=3f3IBH2IHB', data)
 
	print 'server_spawn_object', x, y, z, hex(objid), unknown1, type_id, unknown2, unknown3, name_id, unknown4, unknown5, unknown6
 
	data = struct.pack('=3f3IBH2IHB', x, y, z, objid, unknown1, type_id, unknown2, unknown3, name_id, unknown4, unknown5, unknown6)
 

		name_id = 305095
	"""
 
	data = struct.pack('=3f3I4B2I', x, y, z, objid, type_id1, type_id2, animation, flags, unknown1, heading, name_id, title_id)+data[36:]
 
	return (opcode, data)
 

def preprocess_server_harvest_window(server, opcode, data):
	(item_id, objid, unknown, mode) = struct.unpack('=2IHB', data)
 
	print 'server_harvest_window', item_id, hex(objid), unknown, mode
 
	data = struct.pack('=2IHB', item_id, objid, unknown, mode)
 

 
 
 
	data = struct.pack('=BIH3fB', unknown1, unknown2, unknown3, x, y, z, heading)
 
	return (opcode, data)
 

 
	#unknown = 1
 
	data = struct.pack('=HB', effect_id, unknown)
 
	return (opcode, data)
 

 
	print 'server_system_message', unknown1, hex(objid), strings.get_string_by_id(string_id).body, arguments, unknown2
 
	data = struct.pack('=H2IB', unknown1, objid, string_id, argument_count)+data[11:]
 
	return (opcode, data)
 

        TIOCGWINSZ = termios.TIOCGWINSZ
    else:
        TIOCGWINSZ = 1074295912 # assume
    s = struct.pack ("HHHH", 0, 0, 0, 0)
    a = struct.unpack ('HHHH', fcntl.ioctl(sys.stdout.fileno(), TIOCGWINSZ , s))
    global global_pexpect_instance
    global_pexpect_instance.setwinsize(a[0],a[1])

        TIOCGWINSZ = termios.TIOCGWINSZ
    else:
        TIOCGWINSZ = 1074295912 # assume
    s = struct.pack ("HHHH", 0, 0, 0, 0)
    a = struct.unpack ('HHHH', fcntl.ioctl(sys.stdout.fileno(), TIOCGWINSZ , s))
    global global_pexpect_instance
    global_pexpect_instance.setwinsize(a[0],a[1])

import copy
import time
from cStringIO import StringIO
from struct import unpack, pack
from math import sqrt
 
##

    def write_file_header(self):
        # First four bytes are MIDI header
        packdata = pack(">LHHH", 6,    
                            self.midistream.format, 
                            self.midistream.trackcount, 
                            self.midistream.resolution)
        self.output.write('MThd%s' % packdata)
 
    def write_track_header(self, trklen):
        self.output.write('MTrk%s' % pack(">L", trklen))

import copy
import time
from cStringIO import StringIO
from struct import unpack, pack
from math import sqrt
 
##

    def write_file_header(self):
        # First four bytes are MIDI header
        packdata = pack(">LHHH", 6,    
                            self.midistream.format, 
                            self.midistream.trackcount, 
                            self.midistream.resolution)
        self.output.write('MThd%s' % packdata)
 
    def write_track_header(self, trklen):
        self.output.write('MTrk%s' % pack(">L", trklen))

import copy
import time
from cStringIO import StringIO
from struct import unpack, pack
from math import sqrt
 
##

    def write_file_header(self):
        # First four bytes are MIDI header
        packdata = pack(">LHHH", 6,    
                            self.midistream.format, 
                            self.midistream.trackcount, 
                            self.midistream.resolution)
        self.output.write('MThd%s' % packdata)
 
    def write_track_header(self, trklen):
        self.output.write('MTrk%s' % pack(">L", trklen))

import copy
import time
from cStringIO import StringIO
from struct import unpack, pack
from math import sqrt
 
##

    def write_file_header(self):
        # First four bytes are MIDI header
        packdata = pack(">LHHH", 6,    
                            self.midistream.format, 
                            self.midistream.trackcount, 
                            self.midistream.resolution)
        self.output.write('MThd%s' % packdata)
 
    def write_track_header(self, trklen):
        self.output.write('MTrk%s' % pack(">L", trklen))

        TIOCGWINSZ = termios.TIOCGWINSZ
    else:
        TIOCGWINSZ = 1074295912 # assume
    s = struct.pack ("HHHH", 0, 0, 0, 0)
    a = struct.unpack ('HHHH', fcntl.ioctl(sys.stdout.fileno(), TIOCGWINSZ , s))
    global global_pexpect_instance
    global_pexpect_instance.setwinsize(a[0],a[1])