TestON/core/openspeak.py

#/usr/bin/env python
'''
Created on 20-Dec-2012
       
@author: Raghav Kashyap(raghavkashyap@paxterrasolutions.com)


    TestON is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.

    TestON is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with TestON.  If not, see <http://www.gnu.org/licenses/>.		


'''
import re
import inspect


class OpenSpeak:

    def __init__(self):
        self.default = ''
        self.flag = 0 
        self.CurrentStep = 0
        self.grtrOrLssr = 0

    def compiler(self,**compileParameters):
        '''
         This method will parse the openspeak file and will write to a python module with the equivalent translations. 
         It can accept OpenSpeak syntax in string or an OpenSpeak file as an input parameter. 
         Translated form can be written into python module if attribute "WRITETOFILE" is set to 1.
        '''
      
        args = self.parse_args(["OPENSPEAKFILE","TEXT","WRITETOFILE","FILEHANDLE"],**compileParameters)
        resultString = ''
        Test = "Mininet"
        args["WRITETOFILE"] = args["WRITETOFILE"] if args["WRITETOFILE"] != None else 1
        self.CurrentStep = 0
        self.CurrentCase = ''
 
        ## here Open Speak file will be parsed by each line and translated.
        if args["OPENSPEAKFILE"] !=None and args["TEXT"] ==None and args["FILEHANDLE"] == None:
            self.openspeakfile = args["OPENSPEAKFILE"]
            openSpeakFile = open(args["OPENSPEAKFILE"],"r").readlines()
 
        elif args["OPENSPEAKFILE"] ==None and args["TEXT"] and args["FILEHANDLE"] == None: 
            openSpeakFile =  args["TEXT"].split("\n")     
        elif args["FILEHANDLE"] and args["OPENSPEAKFILE"] ==None and args["TEXT"] ==None:
            openSpeakFile = args["FILEHANDLE"].readlines()
            
        index = 0
        outputFile = []
        testName = re.search("\/(.*)\.ospk$",self.openspeakfile,0)
        testName = testName.group(1)
        testName = testName.split("/")
        testName = testName[len(testName)-1]
        outputFile.append("\nclass " + testName + " :" + "\n")
        outputFile.append("\n" + " " * 4 + "def __init__(self) :")
        outputFile.append("\n" + " " * 8 + "self.default = \'\'" + "\n")    
        
        while index < len(openSpeakFile):
            ifelseMatch = re.match("\s+IF|\s+ELSE|\s+ELIF",openSpeakFile[index],flags=0)
            line = openSpeakFile[index]
            repeatMatch = re.match("\s*REPEAT", openSpeakFile[index], flags=0)
            if ifelseMatch :
                result =  self.verify_and_translate(line) 
                initialSpaces = len(line) -len(line.lstrip())
                self.outLoopSpace = initialSpaces  
                nextLine = openSpeakFile[index+1]
                nextinitialSpaces = len(nextLine) -len(nextLine.lstrip())
                
                    
                while nextinitialSpaces > initialSpaces :
                    try :
                        elseMatch = re.match("\s*ELSE|\s*ELIF",nextLine,flags=0)
                        if elseMatch :
                            self.flag = self.flag -1    
                        result = result + self.verify_and_translate(nextLine)  
                        nextLine = openSpeakFile[index + 1]
                        nextinitialSpaces = len(nextLine) -len(nextLine.lstrip())
                    except IndexError:
                        pass 
                    index = index + 1
                self.flag = 0 
            elif repeatMatch:
                self.flag = 0
                result =  self.verify_and_translate(line)
                index = index + 1
                endMatch = re.match("\s*END",openSpeakFile[index],flags=0)
                while not endMatch :
                    try :
                        
                        self.flag = self.flag + 1
                        result =  result + self.verify_and_translate(openSpeakFile[index])
                        index = index + 1
                        
                    except IndexError :
                        pass
                   
                                 
            else :
                self.flag = 0
                result = self.verify_and_translate(line)
                index = index + 1
            outputFile.append(result)

        if args["WRITETOFILE"] == 1 :
            testscript = re.sub("ospk","py",self.openspeakfile,0)
            testScript = open(testscript,"w")
            for lines in outputFile :
                testScript.write(lines)
            testScript.close()
        return resultString
  
    def verify_and_translate(self,line):
        '''
          It will accept the each line and calls the suitable API to conver into pyton equivalent syntax .
          It will return the translated python syntax .  
        ''' 
        lineSpace = re.match("^\s+",line,flags=0)
        initialSpaces = len(line) -len(line.lstrip())    
        line = re.sub("^\s+","",line) if lineSpace else line      
 
        
        resultString = None
        resultString = "\n" + " " * 4 if str(inspect.stack()[1][3]) == "compiler" else "\n"
        indent = " " *(4 + 4 * self.flag) if self.flag > 0 else " " * 4         
        caseMatch = re.search("^CASE\s+(\d+)",line,flags=0)
        nameMatch = re.match("^NAME\s+\"(.*)\"",line,flags=0)
        commentMatch = re.match("^COMMENT\s+\"(.*)\"",line,flags=0)
        stepMatch = re.match("^STEP\s+\"(.*)\"",line,flags=0)
        connectMatch = re.match("^CONNECT\s+(\w+)\s+USING\s+(.*)",line,flags=0)
        disconnectMatch = re.match("^DISCONNECT\s+(.*)",line,flags=0)   
        ondoMatch = re.match("^ON\s+(.*)\s+DO\s+(.*)",line,flags=0)
        
        storeMatch = re.match("^STORE\s+(.*)\s+IN\s+(.*)",line,flags=0)
        variableMatch = re.match("^(.*)\s+=\s+(.*)",line,flags=0) 
        assertMatch = re.match("^ASSERT\s+(\w+)\s+(.*)\s+(.*)\s+ONPASS\s+(.*)\s+ONFAIL\s+(.*)",line,flags=0)
        logMatch = re.match("^(ERROR|INFO|DEBUG|CRITICAL|REPORT|EXACT|WARN)\s+(.*)",line,flags=0)
        ifloop = re.match("IF\s+(\w+)\s*(..|\w+)\s*(.*)",line,flags=0)
        elseloopMatch = re.match("ELSE\s*$",line,flags=0)   
        elifloop = re.match("ELSE\sIF\s+(\w+)\s*(..|\w+)\s*(.*)",line,flags=0)
        forloopMatch = re.match("\s*REPEAT\s+(/d+)\s+TIMES",line,flags=0)
        experimentalMatch = re.match("EXPERIMENTAL\s+MODE\s+(\w+)",line,flags=0)
        repeatMatch = re.match("\s*REPEAT\s+(\d+)\s+TIMES", line, flags=0)
        
        response_pasrse = re.match("\s*PARSE\s+(\w+)\s+AS\s+(\w+)\s+INTO\s+(\w+)", line, flags=0)
       
        if caseMatch :
            self.CurrentStep = 0
            self.CurrentCase = "CASE" + caseMatch.group(1)
            resultString = resultString + self.translate_case_block(casenumber=caseMatch.group(1))
        elif repeatMatch:
            resultString = resultString + indent + self.translate_repeat(repeat=repeatMatch.group(1))
        elif nameMatch : 
            resultString = resultString +  indent + self.translate_testcase_name(testname=nameMatch.group(1))
        elif commentMatch : 
            resultString = resultString + indent + self.translate_comment(comment=commentMatch.group(1))
        elif stepMatch :
            self.CurrentStep = self.CurrentStep + 1
            resultString = resultString + indent + self.translate_step(step=stepMatch.group(1))
        elif connectMatch : 
            resultString = resultString + indent + self.translate_connect(component=connectMatch.group(1),
                                                                           arguments=connectMatch.group(2) )
        elif disconnectMatch :
            resultString = resultString + indent + self.translate_disconnect(component=disconnectMatch.group(1))
        elif ondoMatch :
            resultString = resultString + indent + self.translate_onDOAs(component=ondoMatch.group(1),action=ondoMatch.group(2))  
        elif storeMatch :
            resultString = resultString + indent + self.translate_store(variable=storeMatch.group(2),
                                                                         value=storeMatch.group(1)) 
        elif variableMatch :
            resultString = resultString + indent + self.translate_store(variable=variableMatch.group(1),
                                                                         value=variableMatch.group(2))
        elif assertMatch :
            resultString = resultString + indent + self.translate_assertion(leftvalue=assertMatch.group(1),
                                                                        operator=assertMatch.group(2),
                                                                            rightvalue=assertMatch.group(3),
                                                                            onpass=assertMatch.group(4),
                                                                            onfail=assertMatch.group(5)) 
        elif logMatch :
            resultString = resultString + indent + self.translate_logs(loglevel=logMatch.group(1),
                                                                        message=logMatch.group(2))
        elif ifloop :
            
            self.initSpace = initialSpaces 
            operand = ifloop.group(1)
            operator = ifloop.group(2)
            value = ifloop.group(3)  
            resultString = resultString + indent + "if " + operand + self.translate_if_else_operator(conditionoperator=operator) + value + ":" 
            self.flag = self.flag + 1 
        elif experimentalMatch :
            resultString = resultString + indent + self.translate_experimental_mode(mode=experimentalMatch.group(1))
             
        elif elseloopMatch :
            if initialSpaces == self.initSpace or initialSpaces == self.outLoopSpace:
                resultString = resultString + indent + "else :"
                self.flag = self.flag + 1
            else :
                indent = " " *(4 + 4 * (self.flag-1)) 
                resultString = resultString + indent + "else :"
                self.flag = self.flag + 1
                   
        elif elifloop :
            
            operand = elifloop.group(1)
            operator = elifloop.group(2)
            value = elifloop.group(3)  
            if initialSpaces == self.initSpace or initialSpaces == self.outLoopSpace:
                resultString = resultString + indent + "elif " + operand + self.translate_if_else_operator(conditionoperator=operator) + value + ":" 
                self.flag = self.flag + 1 
            else :
                indent = " " *(4 + 4 * (self.flag-1)) 
                resultString = resultString + indent + "elif " + operand + self.translate_if_else_operator(conditionoperator=operator) + value + ":" 
                self.flag = self.flag + 1
        elif response_pasrse :
            output_string = response_pasrse.group(1)
            req_format = response_pasrse.group(2)
            store_in = response_pasrse.group(3)
            resultString = resultString + indent + store_in +'= main.response_parser('+output_string+",\""+req_format+"\")" 
            self.flag = self.flag + 1 

        return resultString

    def translate_repeat(self,**repeatStatement):
        '''
        this will transalte the repeat statement into a python equivalen while loop
        '''
        
        args = self.parse_args(["REPEAT"],**repeatStatement)
        resultString = ''
        
        resultString = "i = 0"
        resultString = resultString + "\n" + " " * 8 +"while i<" + args["REPEAT"] + " :"
        return resultString
     
    def translate_if_else_operator(self,**loopBlock):
        '''
          This method will translate if-else loop block into its equivalent python code.
          Whole loop block will be passed into loopBlock List. 
          It returns the transalted reuslt as a string.
        '''
        args = self.parse_args(["CONDITIONOPERATOR"],**loopBlock)
        resultString = ''
        # process the loopBlock List translate all statements underlying the given loop block
        equalsMatch = re.match("EQUALS$|==\s*$",args["CONDITIONOPERATOR"],flags=0)
        greaterMatch = re.match("GREATER\s+THAN$|>\s*$",args["CONDITIONOPERATOR"],flags=0)
        lesserMatch = re.match("LESSER\s+THAN$|<\s*$",args["CONDITIONOPERATOR"],flags=0)
        greaterEqualMatch =  re.match("GREATER\s+THAN\s+OR\s+EQUALS$|>=\s*$",args["CONDITIONOPERATOR"],flags=0)
        lesserEqualMatch = re.match("LESSER\s+THAN\s+OR\s+EQUALS$|<=\s*$",args["CONDITIONOPERATOR"],flags=0)
        if equalsMatch :
            resultString = resultString + " == "
        elif greaterMatch : 
            resultString = resultString + " > "
        elif lesserMatch : 
            resultString = resultString + " < " 
        elif greaterEqualMatch:
            resultString = resultString + " >= "
        elif lesserEqualMatch :
            resultString = resultString + " <= "
        else :
            print "\n Error: Given Operator is not listed "  
        
        return resultString      
  
    def translate_experimental_mode(self,**modeType):
        '''
         This API will translate statment EXPERIMENTAL MODE ON/OFF into python equivalent.
         It will return the transalted value.
         '''
        args = self.parse_args(["MODE"],**modeType)
        resultString = ''
        ONmatch = re.match("\s*ON",args["MODE"],flags=0)
        OFFmatch = re.match("\sOFF",args["MODE"],flags=0)

        if ONmatch :
            resultString = "main.EXPERIMENTAL_MODE = main.TRUE"
        elif OFFmatch :
            resultString = "main.EXPERIMENTAL_MODE = main.FALSE" 

        return resultString

    def interpret(self,**interpetParameters):
        '''
         This method will accept the OpenSpeak syntax into a string and will return 
         a python equivalent translations statement
        '''
      
        args = self.parse_args(["TEXT","WRITETOFILE"],**interpetParameters)
        resultString = ''
        ## here Open Speak syntax will be translated into python equivalent.
        resultString = self.verify_and_translate(args["TEXT"])
        lineSpace = re.match("^\s+",resultString,flags=0)
           
        resultString = re.sub("^\s+","",resultString) if lineSpace else resultString 
        return resultString

    def translate_logs(self,**logStatement):
        '''
         This will translate the OpenSpeak log message statements into python equivalent 
         to resultString and returns resultString
        '''
        args = self.parse_args(["LOGLEVEL","MESSAGE"],**logStatement)
        resultString = ''
        # convert the statement here     
        message = self.translate_log_message(message=args["MESSAGE"])
        if args["LOGLEVEL"] == "INFO" :
            resultString = resultString + "main.log.info(" + message + ")"
        elif args["LOGLEVEL"] == "ERROR" :
            resultString = resultString + "main.log.error(" + message  + ")"
        elif args["LOGLEVEL"] == "DEBUG" :
            resultString = resultString + "main.log.debug(" + message + ")"
        elif args["LOGLEVEL"] == "REPORT" :
            resultString = resultString + "main.log.report(" + message + ")" 
        elif args["LOGLEVEL"] == "CRITICAL" :
            resultString = resultString + "main.log.critical(" + message + ")"
        elif args["LOGLEVEL"] == "WARN" :
            resultString = resultString + "main.log.warn(" + args["MESSAGE"] + ")"
        elif args["LOGLEVEL"] == "EXACT" :
            resultString = resultString + "main.log.exact(" + args["MESSAGE"] + ")"      

        
        return resultString

    def translate_log_message(self,**messageStatement) :
        '''
         This API will translate log messages if it is a string or Variable or combination
         of string and variable. 
         It will return the analysed and translate message.
        '''
        args = self.parse_args(["MESSAGE"],**messageStatement)
        resultString = ''

        paramsMatch = re.match("PARAMS\[(.*)\]|STEP\[(.*)\]|TOPO\[(.*)\]|CASE\[(.*)\]|LAST_RESULT|LAST_RESPONSE",args["MESSAGE"],flags=0)
        stringMatch = re.match("\s*\"(.*)\"\s*$",args["MESSAGE"],flags=0)
        stringWidVariableMatch = re.match("\"(.*)\"\s+\+\s+(.*)",args["MESSAGE"],flags=0)
        varRefMatch = re.search("\<(\w+)\>",args["MESSAGE"],flags=0)
        if paramsMatch :
            resultString = resultString + self.translate_parameters(parameters=args["MESSAGE"])
        elif stringMatch :
            resultString = resultString + args["MESSAGE"]
        elif stringWidVariableMatch:
            quoteWord = stringWidVariableMatch.group(1)
            variableRef = stringWidVariableMatch.group(2)
            varMatch = re.search("PARAMS\[(.*)\]|STEP\[(.*)\]|TOPO\[(.*)\]|CASE\[(.*)\]",variableRef,flags=0)
            varRefMatch = re.search("\<(\w+)\>",variableRef,flags=0)  
            if varMatch :
                resultString = resultString + "\"" + quoteWord + "\"" + " + " + self.translate_parameters(parameters=variableRef)
            elif varRefMatch :
                resultString = resultString + "\"" + quoteWord + "\"" +  " + " + varRefMatch.group(1)
        elif varRefMatch:
            resultString = resultString + varRefMatch.group(1)
        else : 
            print "\nError : Syntax error , Not defined way to give log message" + args["MESSAGE"] 

        return resultString          
   
    def translate_assertion(self,**assertStatement):
        '''
         This will translate the ASSERT <value1> <COMPARISON OPERATOR> <value2> into python 
         equivalent to resultString and returns resultString
        '''
        args = self.parse_args(["LEFTVALUE","OPERATOR","RIGHTVALUE","ONPASS","ONFAIL"],**assertStatement)
        resultString = ''
        # convert the statement here   
        notOperatorMatch = re.search("NOT\s+(.*)",args["OPERATOR"],flags=0)
        notOperatorSymbMatch = re.search("\!(.*)",args["OPERATOR"],flags=0) 
        operator = ''
        lastresultMatch = re.match("LAST_RESULT",args["RIGHTVALUE"],flags=0)
        lastresponseMatch = re.match("LAST_RESPONSE",args["RIGHTVALUE"],flags=0)
        if lastresultMatch :
            operator = "main.last_result"
        elif lastresponseMatch :
            operator = "main.last_response"
        else :
            operator = args["RIGHTVALUE"]
                 
        if args["OPERATOR"] == None or args["OPERATOR"] == "" :
            print "\n Error : Operator has not been specified !!!"
        elif notOperatorMatch or notOperatorSymbMatch:
            
            operators = notOperatorMatch.group(1) if notOperatorMatch else notOperatorSymbMatch.group(1)
            operators = self.translate_operator(operator=operators)
            if self.grtrOrLssr == 0 :
                resultString = resultString + "utilities.assert_not_" + operators + "(expect=" +\
                               self.translate_response_result(operator=args["RIGHTVALUE"]) + ",actual=" + self.translate_response_result(operator=args["LEFTVALUE"]) +\
                               ",onpass=" + self.translate_assertMessage(message=args["ONPASS"]) +\
                               ",onfail=" + self.translate_assertMessage(message=args["ONFAIL"]) + ")"
            else :
                resultString = resultString + "utilities.assert_not_" + operators + "(expect=" +\
                               self.translate_response_result(operator=args["LEFTVALUE"]) + ",actual=" + self.translate_response_result(operator=args["RIGHTVALUE"]) +\
                               ",onpass=" + self.translate_assertMessage(message=args["ONPASS"]) +\
                               ",onfail=" + self.translate_assertMessage(message=args["ONFAIL"]) + ")"

        else :           
            operators = self.translate_operator(operator=args["OPERATOR"])
            if self.grtrOrLssr == 0 :
                resultString = resultString + "utilities.assert_" + operators + "(expect=" +\
                               self.translate_response_result(operator=args["RIGHTVALUE"]) +\
                               ",actual=" + self.translate_response_result(operator=args["LEFTVALUE"]) +\
                               ",onpass=" + self.translate_assertMessage(message=args["ONPASS"]) +\
                               ",onfail=" + self.translate_assertMessage(message=args["ONFAIL"]) + ")"
            else :
                resultString = resultString + "utilities.assert_" + operators + "(expect=" +\
                               self.translate_response_result(operator=args["LEFTVALUE"]) +\
                               ",actual=" + self.translate_response_result(operator=args["RIGHTVALUE"]) +\
                               ",onpass=" + self.translate_assertMessage(message=args["ONPASS"]) +\
                               ",onfail=" + self.translate_assertMessage(message=args["ONFAIL"]) + ")"
 
            
        return resultString

    def translate_response_result(self,**operatorStatement):
        '''
         It will translate the LAST_RESPONSE or LAST_RESULT statement into its equivalent.
         It returns the translate form in resulString.
        '''
        args = self.parse_args(["OPERATOR"],**operatorStatement)
        resultString = ''
        lastResultMatch = re.match("LAST_RESULT",args["OPERATOR"],flags=0)
        lastResponseMatch = re.match("LAST_RESPONSE",args["OPERATOR"],flags=0)     
        if lastResultMatch :
            resultString = resultString + "main.last_result"
        elif lastResponseMatch:
            resultString = resultString + "main.last_response"
        else :
            resultString = resultString + args["OPERATOR"]
        return resultString

    
    def translate_assertMessage(self,**messageStatement) :
        '''
         This API will facilitate the translation of assert ONPASS or ONFAIL messages . The message can be
         a string or calling another API in OpenSpeak syntax.
         It will return the translated message
        '''
        args = self.parse_args(["MESSAGE"],**messageStatement)
        
        connectMatch = re.search("CONNECT\s+(\w+)\s+USING\s+(.*)",args["MESSAGE"],flags=0)
        disconnectMatch = re.search("DISCONNECT\s+(.*)",args["MESSAGE"],flags=0)   
        ondoMatch = re.search("ON\s+(.*)\s+DO\s+(.*)",args["MESSAGE"],flags=0)
        paramsMatch = re.search("PARAMS\[(.*)\]|STEP\[(.*)\]|TOPO\[(.*)\]|CASE\[(.*)\]",args["MESSAGE"],flags=0)
        stringMatch = re.search("\"(.*)\"|\'(.*)\'",args["MESSAGE"],flags=0)
        variableMatch = re.search("\<(.*)\>",args["MESSAGE"],flags=0)

        resultString = ''
        if connectMatch : 
            resultString = resultString + self.translate_connect(component=connectMatch.group(1),
                                                                 arguments=connectMatch.group(2) )
        elif disconnectMatch :
            resultString = resultString + self.translate_disconnect(component=disconnectMatch.group(1))
        elif ondoMatch :
            resultString = resultString + self.translate_onDOAs(component=ondoMatch.group(1),
                                                                action=ondoMatch.group(2))
        elif paramsMatch :
            resultString = resultString + self.translate_parameters(parameters=args["MESSAGE"])
        elif stringMatch : 
            resultString = resultString + "\"" + stringMatch.group(1) + "\""
        elif variableMatch :
            resultString = resultString + variableMatch.group(1) 
        elif args["MESSAGE"]  == None :
            print "\n Error : Please pass a message or action for assertion "  
  
        return resultString 
 
    def translate_operator(self,**operatorStatement) :
        '''
          It will translate the operator for assertion , by ensuring against given arguments.
          It will return the translated assertion operator.
        '''
        args = self.parse_args(["OPERATOR"],**operatorStatement)
        
        resultString = ''
        equalsMatch = re.match("EQUALS$|==$",args["OPERATOR"],flags=0)
        greaterMatch = re.match("GREATER\s+THAN$|>$",args["OPERATOR"],flags=0)
        lesserMatch = re.match("LESSER\s+THAN$|<$",args["OPERATOR"],flags=0)
        stringMatch = re.match("MATCHES|~$",args["OPERATOR"],flags=0)
        greaterEqualMatch =  re.match("GREATER\s+THAN\s+OR\s+EQUALS$|>=$",args["OPERATOR"],flags=0)
        lesserEqualMatch = re.match("LESSER\s+THAN\s+OR\s+EQUALS$|<=$",args["OPERATOR"],flags=0)
        if equalsMatch :
            
            resultString = resultString + "equals"
        elif greaterMatch : 
            self.grtrOrLssr = self.grtrOrLssr + 1
            resultString = resultString + "greater"
        elif lesserMatch : 
            self.grtrOrLssr = self.grtrOrLssr + 1
            resultString = resultString + "lesser"
        elif stringMatch :
            
            resultString = resultString + "matches"
        elif greaterEqualMatch:
            
            resultString = resultString + "greater_equals"
        elif lesserEqualMatch :
            
            resultString = resultString + "lesser_equals"
        else :
            print "\n Error: Given Operator is not listed for assertion"  
        return resultString  

    def translate_store(self,**storeStatement):
        '''
         This will translate the STORE <variable> IN <value> or <variable> = <value>
         into python equivalent to resultString and returns resultString
        '''
        args = self.parse_args(["VARIABLE","VALUE"],**storeStatement)
        resultString = ''
        # convert the statement here
        ondoMatch = re.match("^\s*ON\s+(.*)\s+DO\s+(.*)",args["VALUE"],flags=0)
        paramsMatch = re.match("^\s*PARAMS\[(.*)\]|STEP\[(.*)\]|TOPO\[(.*)\]|CASE\[(.*)\]|LAST_RESULT|LAST_RESPONSE",args["VALUE"],flags=0)
        if paramsMatch :
            argString = self.translate_parameters(parameters=args["VALUE"])
            resultString = args["VARIABLE"] + " = " + argString
        elif ondoMatch :
            resultString = args["VARIABLE"] + " = "  + self.translate_onDOAs(component=ondoMatch.group(1),action=ondoMatch.group(2))
        else :
            resultString = args["VARIABLE"] + " = " + args["VALUE"]


        return resultString
   
    def translate_disconnect(self,**disconnectStatement):
        '''
         This will translate the DISCONNECT <component_name> into python 
         equivalent to resultString and returns resultString
        '''
        args = self.parse_args(["COMPONENT"],**disconnectStatement)
        resultString = ''
        # convert the statement here
        resultString = "main." + args["COMPONENT"] + ".disconnect()"     
        return resultString
  
    def translate_onDOAs(self,**onDoStatement):
        '''
         This will translate the ON <component> DO <action> USING <arg1> AS <value1>,<arg2> AS <value2>
         into python equivalent to resultString and returns resultString
        '''
        args = self.parse_args(["COMPONENT","ACTION","ARGUMENTS"],**onDoStatement)
        subString = ''
        
        usingMatch = re.match("\s*(.*)\s+USING\s+(.*)",args["ACTION"],flags=0)
        action = ''
        if usingMatch :
            action = usingMatch.group(1)
            arguments = usingMatch.group(2)
            subString = self.translate_usingas(arguments=arguments)
            
        else :
            andCheck = re.search ("(.*)\s+AND\s+(.*)",args["ACTION"],flags=0)
            
            action = action + "()"
            if andCheck:
                action = andCheck.group(1) + "()"
                subString = subString + self.handle_conjuction(statement=andCheck.group(2))
            else :
                action = args["ACTION"]
                action = action + "()"
        # convert the statement here    
        resultString = "main." + args["COMPONENT"] + "." + action + subString 
        return resultString

    
    def handle_conjuction(self,**conjuctStatement):
        '''
        This will handle the conjuctions
        '''
        
        args = self.parse_args(["STATEMENT"],**conjuctStatement)
        subSentence = ''
        
        storeMatch = re.match("\s*STORE\s+(.*)\s+IN\s+(.*)",args["STATEMENT"],flags=0)
        assertMatch = re.match("\s*ASSERT\s+(\w+)\s+(.*)\s+(.*)\s+ONPASS\s+(.*)\s+ONFAIL\s+(.*)",args["STATEMENT"],flags=0)
        if storeMatch :
            subSentence =  "\n" + " " * 8 + self.translate_store(variable=storeMatch.group(2),
                                                                         value=storeMatch.group(1))
        elif assertMatch :
            subSentence = "\n" + " " * 8 + self.translate_assertion(leftvalue=assertMatch.group(1),
                                                                    operator=assertMatch.group(2),
                                                                    rightvalue=assertMatch.group(3),
                                                                    onpass=assertMatch.group(4),
                                                                    onfail=assertMatch.group(5))
        return subSentence

    def translate_usingas(self,**argumentAS) :
        '''
         This will tranlate USING argument AS value Statement into equivalent argument passing.
         It will return translated form into resultString
        '''
        args = self.parse_args(["ARGUMENTS"],**argumentAS)
        resultString = ''
        argsList = []
        subString = ''
        subSentence = ''
        line = ''
        andCheck = re.search ("(.*)\s+AND\s+(.*)",args["ARGUMENTS"],flags=0)
        if andCheck:
            line = andCheck.group(1)
            subSentence = self.handle_conjuction(statement=andCheck.group(2))
        else :
            line = args["ARGUMENTS"]
            
            
        
        argsMatch = re.search("(.*),(.*)",line,flags=0)


        if args["ARGUMENTS"] == None or args["ARGUMENTS"] == '' :
            subString = ''
        elif argsMatch :
            
            argsList = line.split(",")
            for index, arguments in enumerate(argsList):
                argMatch = re.search("(.*)\s+AS\s+(.*)",arguments,flags=0)
                if argMatch:
                    argsKey =  argMatch.group(1)
                    argsValue = argMatch.group(2)
                    paramsMatch = re.search("PARAMS\[(.*)\]|STEP\[(.*)\]|TOPO\[(.*)\]|CASE\[(.*)\]|LAST_RESPONSE|LAST_RESULT",argsValue,flags=0)
                    if not paramsMatch :
                        if index == len(argsList) - 1 :
                            subString = subString +  argsKey + "=" + argsValue
                        else :
                            subString = subString +  argsKey + "=" + argsValue + ","
                    else :
                        argString = self.translate_parameters(parameters=argsValue)
                        if index == len(argsList) - 1 :
                            subString = subString +  argsKey + "=" + argString
                        else :
                            subString = subString +  argsKey + "=" + argString + ","
                else :
                    if index == len(argsList) - 1 :
                        subString = subString +  arguments
                    else :
                        subString = subString + arguments + ","  
        else :
            argMatch = re.search("(.*)\s+AS\s+(.*)",args["ARGUMENTS"],flags=0)
            if argMatch:
                argsKey =  argMatch.group(1)
                argsValue = argMatch.group(2)
                paramsMatch = re.search("PARAMS\[(.*)\]|STEP\[(.*)\]|TOPO\[(.*)\]|CASE\[(.*)\]|LAST_RESPONSE|LAST_RESULT",argsValue,flags=0)
                if not paramsMatch :
                    subString = subString +  argsKey + "=" + argsValue
                else :
                    argString = self.translate_parameters(parameters=argsValue)
                    subString = subString +  argsKey + "=" + argString
            else :
                paramsMatch = re.match("PARAMS\[(.*)\]|STEP\[(.*)\]|TOPO\[(.*)\]|CASE\[(.*)\]|LAST_RESPONSE|LAST_RESULT",line,flags=0)
                if paramsMatch :
                    subString = subString + self.translate_parameters(parameters=line)
                else :
                    subString = subString +  line
        resultString = "(" + subString + ")"+ subSentence
        return resultString


    def translate_connect(self,**connectStatement):
        '''
         This will translate the CONNECT <component_name> USING1 <arg1> AS <value1>, <arg2> AS <value2> 
         into python equivalent to resultString and returns resultString
        '''
        args = self.parse_args(["COMPONENT","ARGUMENTS"],**connectStatement)
        resultString = ''
        subString = self.translate_usingas(arguments=args["ARGUMENTS"])
        # convert the statement here    
        resultString = "main." + args["COMPONENT"] + ".connect(" + subString + ")" 
        return resultString


    def translate_parameters(self,**parameterStatement):
        '''
         This will translate the OpenSpeak Case and Params parameters into python equivalent 
         to resultString and returns resultString
        '''
        args = self.parse_args(["PARAMETERS"],**parameterStatement)
        argument = args["PARAMETERS"]
        resultString = ''
        ### match arguments 
        paramsMatch = re.search("PARAMS((\[(.*)\])*)",argument,flags=0)
        stepsMatch = re.search("STEP((\[(.*)\])*)",argument,flags=0)
        casesMatch = re.search("CASE((\[(.*)\])*)",argument,flags=0)
        topoMatch = re.search("TOPO((\[(.*)\])*)",argument,flags=0)
        lastResultMatch = re.match("LAST_RESULT",argument,flags=0)
        lastResponseMatch = re.match("LAST_RESPONSE",argument,flags=0)     
        # convert the statement here
        if paramsMatch :
            params = paramsMatch.group(1)
            resultString = resultString + "main.params" + self._argsCheck(checkvar=params) 
        elif stepsMatch :
            resultString = resultString +"main.params[\'" + self.CurrentCase +\
                           "\'][\'STEP" + str(self.CurrentStep) + "\']" +\
                           self._argsCheck(checkvar=stepsMatch.group(1))
        elif casesMatch :
            resultString = resultString + "main.params[\'" + self.CurrentCase + "\']" +\
                           self._argsCheck(checkvar=casesMatch.group(1))
        elif topoMatch :
            resultString = resultString + "main.componentDictionary" +\
                           self._argsCheck(checkvar=topoMatch.group(1))
        elif lastResultMatch :
            resultString = resultString + "main.last_result"
        elif lastResponseMatch : 
            resultString = resultString + "main.last_response"  
        return resultString

    def _argsCheck(self,**args):
        ''' This API will check if given argument is varibale reference or String and will translate accordingly.
            It will return the tanslate form in resultString.
         '''    
        args = self.parse_args(["CHECKVAR"],**args)
        params = args["CHECKVAR"]
        argsList = params.split("]")
        resultString = ''
        del argsList[len(argsList) - 1] 
        for index,paramArgs in enumerate(argsList) :
            argsWidVariable = re.search("(\"|\')\s*(\w+)\s*(\'|\")",paramArgs,flags=0)
            if argsWidVariable :
                resultString = resultString + "[\'" + argsWidVariable.group(2) + "\']"
            else :
                resultString = resultString + paramArgs + "]"
        return resultString

    def translate_step(self,**stepStatement):
        '''
         This will translate the STEP "DO SOMETHING HERE" into python equivalent 
         to resultString and returns resultString
        '''
        args = self.parse_args(["STEP"],**stepStatement)
        resultString = ''
        resultString = "main.step(\"" + args["STEP"] + "\")"
        # convert the statement here     
        return resultString

 
    def translate_comment(self,**commentStatement):
        '''
         This will translate the COMMENT "DO SOMETHING HERE" into python equivalent 
         to resultString and returns resultString
        '''
        args = self.parse_args(["COMMENT"],**commentStatement)
        resultString = ''
        resultString = "#" + args["COMMENT"]
        # convert the statement here     
        return resultString      
   
    def translate_testcase_name(self,**nameStatement):
        '''
         This method will convert NAME "<Testcase_name>" into python equivalent statement 
         to resultString and returns resultString 
        ''' 
        args = self.parse_args(["TESTNAME"],**nameStatement)
       
        resultString = ''
        resultString = "main.case(\"" + args["TESTNAME"]  + "\")" 
        # convert the statement here     
        return resultString      
      
         
    def translate_case_block(self,**caseBlock):
        '''
         This method will translate the case block in test script . 
         It returns the translated equivalent python code for test script
        '''
        args = self.parse_args(["CASENUMBER"],**caseBlock)
        resultString = ""
        resultString = "def CASE" + str(args["CASENUMBER"]) + "(self,main) :\n"
        # process the caseBlock List translate all statements underlying the given case     
        return resultString

          
  
    def translate_loop_block(self,*loopBlock):
        '''
         This method will translate for loop block into its equivalent python code.
         Whole loop block will be passed into loopBlock List. 
         It returns the transalted reuslt as a string.
        '''
        resultString = ''
        # process the loopBlock List translate all statements underlying the given loop block     
        return resultString 
     
  
    def translate_conjuction(self,conjuctionStatement):
        '''
         This will translate the AND conjuction statements into python equivalent 
         to resultString and returns resultString
        '''
        resultString = ''
        # convert the statement here     
        return resultString


    def parse_args(self,args, **kwargs):
        '''
        It will accept the (key,value) pair and will return the (key,value) pairs with keys in uppercase.
        '''
        newArgs = {}
        for key,value in kwargs.iteritems():
            #currentKey =  str.upper(key)
            if isinstance(args,list) and str.upper(key) in args:
                for each in args:                    
                    if each==str.upper(key):
                        newArgs [str(each)] = value
                    elif each != str.upper(key) and (newArgs.has_key(str(each)) == False ):
                        newArgs[str(each)] = None
                    
                   
            
        return newArgs