MainModule.ttcn3

module MainModule {
    import from TraceParserSystem all;

    function f_rsuBehaviour(inout integer p_tranDuration) runs on RsuType {
        var address v_ts := 0;
        var integer v_startTS := 0;
        var template (present) LinkId v_linkId := ?;
        var boolean v_receivedLinkId := false;
        var boolean v_actionAtOBU := false;
        var NrOfEmptyMsg v_nrOfEmptyMsg := 0;
        var PayloadStructure v_receivedMsg;
        

        transactionRSUTimer.start;
        alt {
            [v_startTS==0] rsuPort.receive(mw_rsuBroadCastMsg) -> sender v_ts value v_receivedMsg{ 
                // when the first broadcast message is received then take it's time stamp
                transactionRSUTimer.stop;
                //---
                commmunOBURSUPort.send(v_receivedMsg);
                //---
                v_startTS := v_ts;
                transactionRSUTimer.start;
                compPort.send(true);
                repeat; 
            }
            [] compPort.receive(v_linkId) -> value v_linkId{
                transactionRSUTimer.stop;
                v_receivedLinkId := true;
                transactionRSUTimer.start;
                repeat;
            }
            [] compPort.receive(true){
                v_actionAtOBU := true;
                repeat;
            }

            [v_startTS!=0 and v_receivedLinkId == true] rsuPort.receive(mw_releaseMsg(v_linkId)) -> sender v_ts value v_receivedMsg{ 
                // when the release message was received take it's time stamp and calculate the transaction time
                // inform the rsu component 
                transactionRSUTimer.stop;
                //---
                commmunOBURSUPort.send(v_receivedMsg);
                //---
                compPort.send(m_stop);
                
                alt{
                    [] compPort.receive(NrOfEmptyMsg :?) -> value v_nrOfEmptyMsg;
                    
                    [] compPort.receive {
                        transactionRSUTimer.stop;
                        setverdict(inconc, "Unexpected message received");
                        stop;
                    }
                    [] transactionRSUTimer.timeout {
                        setverdict (inconc, "No NrOfEmptyMsg was received from RSU");
                        stop;
                    }                    
                }
                
                
                p_tranDuration := v_ts - v_startTS;
                if (p_tranDuration <= 100000) {
                    setverdict (pass, "Transaction finished in " & int2str(p_tranDuration) & " micro s"  & " The Number of empty messages received is : " & int2str(v_nrOfEmptyMsg));
                }
                else {
                    setverdict (fail, "Transaction finished in more than 100ms (" & int2str(p_tranDuration) & " micro s "  &")");
                }
                stop;
            }
            [v_startTS!=0 and v_receivedLinkId == true] rsuPort.receive(mw_msg_withLinkId(v_linkId))-> value v_receivedMsg{
                transactionRSUTimer.stop;
                //---
                commmunOBURSUPort.send(v_receivedMsg);
                //---
                transactionRSUTimer.start;
                repeat;
            }
            [v_startTS!=0 and v_receivedLinkId == true] rsuPort.receive(mw_rsuBroadCastMsg) -> value v_receivedMsg{ 
                //If another broadcast is received than ignore
                transactionRSUTimer.stop;
                //---
                commmunOBURSUPort.send(v_receivedMsg);
                //---
                transactionRSUTimer.start;
                repeat;
            }
            [v_startTS!=0 and v_receivedLinkId == true] rsuPort.receive {
                transactionRSUTimer.stop;
                setverdict(inconc, "Unexpected message received");
                compPort.send(m_stop);
                stop;                
            }
            [] transactionRSUTimer.timeout {
                if(v_actionAtOBU)
                	{setverdict (fail, "Transaction incomplete!");}
                else
                	{if(v_startTS==0)
                		{setverdict (fail, "Transaction empty!");}
                	 else
                     	{setverdict (fail);}
                	}
                compPort.send(m_stop);
                stop;
            }
        }
    }
    
    function f_obuBehaviour() runs on ObuType {
        var boolean v_sentLinkId := false;
        var boolean v_actionAtRSU := false;
        var PayloadStructure v_msg;
        var NrOfEmptyMsg v_cntEmpty := 0;
        var template (present) LinkId v_linkId := ?;
        
        transactionOBUTimer.start;
        alt{
            []obuPort.receive(mw_msg_withLinkId(v_linkId)) -> value v_msg{
                transactionOBUTimer.stop;
                //---
                 commmunOBURSUPort.send(v_msg);
                //---
                if (v_sentLinkId == false) {
                       v_linkId := valueof(v_msg.linkMsg.linkId);
                       compPort.send(valueof(v_linkId));
                }
                v_sentLinkId := true;
                transactionOBUTimer.start;
                compPort.send(true);
                repeat;
            }
            []obuPort.receive(mw_msg_empty) ->value v_msg{
                transactionOBUTimer.stop;
                //---
                 commmunOBURSUPort.send(v_msg);
                //---
                v_cntEmpty := v_cntEmpty +1;
                transactionOBUTimer.start;
                repeat;
            }
            []obuPort.receive{
                transactionOBUTimer.stop;
                setverdict (inconc, "Unexpected message received.");
                stop;
            }
            [] compPort.receive(true){
                v_actionAtRSU := true;
                repeat;
            }

            []compPort.receive(m_stop) {
                compPort.send(v_cntEmpty);
                if (v_cntEmpty <= PX_MAX_NUM_EMPTY_UPLINK_FRAMES){
                    // do nothing so that the last verdict would be taken from the RSU component
                    // only in case of fail (to many received empty frames) is the verdict from OBU component used
                    //setverdict (pass, "Number of received empty frames : " & int2str(v_cntEmpty));      
                }
                else {
                    setverdict (fail, "Maximum number of received empty frames exceeded! (" 
                                      & int2str(v_cntEmpty) & " > " & int2str(PX_MAX_NUM_EMPTY_UPLINK_FRAMES) & ")");
                }
                stop;
            }
            []transactionOBUTimer.timeout{
				if(v_actionAtRSU)
					{setverdict(fail, "No OBU message received");}
				else
                	{setverdict(fail);}
                stop;
            }
        }
    }
    

    /**
     * @desc This test case is seting the trace file and counts the number of transaction 
     */
    testcase TC_Initialization(inout integer p_nrOfTransactions) runs on MtcType system SystemType {
        
        map(mtc:controlPort, system:controlPort);
        
        parseFileName(PX_TRACE_PATH, v_PowerLevel, v_OBUName, v_DutyCycle, v_RepNo);
        
        controlPort.call(setTraceFile:{PX_TRACE_PATH}, 5.0) {
            [] controlPort.getreply(setTraceFile:{-} value true) {
                setverdict (pass, "  PowerLevel = " & v_PowerLevel&
                                  "  OBUName = " & v_OBUName & 
                                  "  DutyCycle = " & v_DutyCycle &
                                  "  RepNo = " &  v_RepNo );
            }
            [] controlPort.getreply {
                setverdict (fail, "Could not set trace file");
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while setting trace file");
                stop;
            }
        };

        controlPort.call(getTransactionCnt:{}, 5.0) {
            [] controlPort.getreply(getTransactionCnt:{} value ?) -> value p_nrOfTransactions {
                setverdict (pass, "Number of Transaction = " & int2str(p_nrOfTransactions));
            }
            [] controlPort.getreply {
                setverdict (fail, "Unexpected reply");
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while caling getTransacationCnt");
                stop;
            }
        };
    }
    
    /**
     * @desc This test case analizes a transaction, it's duration and the number of empty messages received from RSU 
     */
    testcase TC_AnalyzesTrace(inout integer p_traceIndex, inout integer p_tranDuration) runs on MtcType system SystemType {
        var RsuType rsuComponent := RsuType.create("RSU"); //DL
        var ObuType obuComponent := ObuType.create("OBU"); //UL
        
        map(mtc:controlPort, system:controlPort);
        map(rsuComponent:rsuPort, system:msgPort);
        map(obuComponent:obuPort, system:msgPort);
        connect(rsuComponent:compPort, obuComponent:compPort);
        connect(rsuComponent:commmunOBURSUPort, obuComponent:commmunOBURSUPort);
        
        rsuComponent.start(f_rsuBehaviour(p_tranDuration));
        obuComponent.start(f_obuBehaviour());
        
        log ("Starting analysis of trace: " & int2str(p_traceIndex));
        
        controlPort.call(startAnalyzeTrace:{p_traceIndex}, 5.0) {
            [] controlPort.getreply(startAnalyzeTrace:{-} value true) {
                setverdict (pass);
            }
            [] controlPort.getreply {
                setverdict (fail, "Could not start analyzing trace");
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while start analyzing trace");
                stop;
            }
        };
            
        all component.done;
    }
    
    testcase TC_LogAnalyzesTrace(inout integer p_averageTranDuration,
                                 inout integer p_shortestTransDuration,
                                 inout integer p_shortestTransIndex,
                                 inout integer p_longestTransDuration,
                                 inout integer p_longestTransIndex) runs on MtcType system SystemType {
                                     
        setverdict(pass, "The average transaction duration is: " & int2str(p_averageTranDuration) & " micro s" & 
                         " The shortest transaction was transaction: " & int2str(p_shortestTransIndex) & 
                         " and took " & int2str(p_shortestTransDuration) & " micro s"  & 
                         " The longest transaction was transaction: " & int2str(p_longestTransIndex) & 
                         " and took " & int2str(p_longestTransDuration)& " micro s") ;
    } 
    
    control {
        var integer v_nrOfTransactions := 0;
        var integer v_nrOfRelevantTransactions := 0;
        var integer v_longestTransDuration := 0;
        var integer v_longestTransIndex := -1;
        var integer v_shortestTransDuration := 0;
        var integer v_shortestTransIndex := -1;
        var integer v_tranDuration := 0;
        var integer v_cumulativeTranDuration := 0;
        var integer v_averageTranDuration;
        
        execute(TC_Initialization(v_nrOfTransactions));
        v_nrOfRelevantTransactions := v_nrOfTransactions;
        
        for(var integer i:=0; i<v_nrOfTransactions; i:=i + 1) {
            execute(TC_AnalyzesTrace(i, v_tranDuration));
            v_cumulativeTranDuration := v_cumulativeTranDuration + v_tranDuration;
            if (v_tranDuration == 0) {
                v_nrOfRelevantTransactions := v_nrOfRelevantTransactions - 1;
            }
            if (v_shortestTransDuration==0) {
                v_shortestTransDuration := v_tranDuration;
            }
            if(v_shortestTransDuration > v_tranDuration){
                log("Short v_tranDuration " & int2str(v_tranDuration));
                v_shortestTransDuration := v_tranDuration;
                v_shortestTransIndex := i;
            }
            else if(v_longestTransDuration < v_tranDuration){
                log("Long v_tranDuration " & int2str(v_tranDuration));
                v_longestTransDuration := v_tranDuration;
                v_longestTransIndex := i;
            }
        };
        
        v_averageTranDuration := float2int(int2float(v_cumulativeTranDuration) / int2float(v_nrOfRelevantTransactions));
        
        execute(TC_LogAnalyzesTrace(v_averageTranDuration,
                                    v_shortestTransDuration,
                                    v_shortestTransIndex,
                                    v_longestTransDuration,
                                    v_longestTransIndex));
        }
    
}