demo/ILog/EPTF_ILog_Transport_Functions.ttcn

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Copyright (c) 2000-2017 Ericsson Telecom AB                               //
//                                                                           //
// All rights reserved. This program and the accompanying materials          //
// are made available under the terms of the Eclipse Public License v1.0     //
// which accompanies this distribution, and is available at                  //
// http://www.eclipse.org/legal/epl-v10.html                                 //
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
// Module: EPTF_ILog_Transport_Functions
//
// Purpose:
//   This module contains function definitions for demo of EPTF ILog
//   Transport layer
//
// Module Parameters:
//    -
//
//  Module depends on:
//    <EPTF_CLL_ILog_Functions>
// 
// Current Owner:
//    Jozsef Gyurusi (ethjgi)
//
// Last Review Date:
//    -
//
//  Detailed Comments:
//    Public functions:
//      <f_EPTF_ILog_Transport_init_CT>
//      <f_EPTF_ILog_Transport_setResponseWeights>
//      <f_EPTF_ILog_Transport_connect>
//      <f_EPTF_ILog_Transport_disconnect>
//      <f_EPTF_ILog_Transport_sendReq>
//      <f_EPTF_ILog_Transport_addRespHandlerFn>
//
///////////////////////////////////////////////////////////

module EPTF_ILog_Transport_Functions {

import from EPTF_ILog_Transport_Definitions all;
import from EPTF_CLL_ILog_Functions all;
import from EPTF_CLL_Common_Definitions all;

///////////////////////////////////////////////////////////
//  Function: f_EPTF_ILog_Transport_init_CT
// 
//  Purpose:
//    Initializes the <EPTF_ILog_Transport_CT>
//
//  Parameters:
//    pl_selfName        - *in* *charstring* - the name of the component
//    pl_responseWeights - *in* <EPTF_ILog_Transport_ResponseWeights> - weight factors for generating response messages
//
//  Return Value:
//   -
///////////////////////////////////////////////////////////
public function f_EPTF_ILog_Transport_init_CT(
  in charstring pl_selfName,
  in EPTF_ILog_Transport_ResponseWeights pl_responseWeights := {1.0,1.0,1.0,1.0}
) runs on EPTF_ILog_Transport_CT {
  if (v_ILog_Transport_eventHandler!=null) {
    return; //already initialized
  }
  f_EPTF_ILog_init_CT(pl_selfName);
  v_ILog_Transport_dbId := f_EPTF_ILog_register_DB(refers(f_EPTF_ILog_Transport_logItem), {});
  v_ILog_Transport_ILogElementList := {};
  v_ILog_Transport_eventHandler:=activate(as_EPTF_ILog_Transport_eventHandler());
  v_ILog_Transport_connectionDB := {};
  v_respHandlerFns := {};
  v_ILog_Transport_responseWeights := pl_responseWeights
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_ILog_Transport_setResponseWeights
// 
//  Purpose:
//    Sets the weights for the different responses
//
//  Parameters:
//    pl_responseWeights - *in* <EPTF_ILog_Transport_ResponseWeights> - weight factors for generating response messages
//
//  Return Value:
//   -
///////////////////////////////////////////////////////////
public function f_EPTF_ILog_Transport_setResponseWeights(
  in EPTF_ILog_Transport_ResponseWeights pl_responseWeights
) runs on EPTF_ILog_Transport_CT {
  v_ILog_Transport_responseWeights := pl_responseWeights;
}


///////////////////////////////////////////////////////////
//  Function: f_EPTF_ILog_Transport_connect
// 
//  Purpose:
//    Connects the current component to a remote PTC, returns the connection id
//
//  Parameters:
//    pl_iLogChainIds - *in* <EPTF_IntegerList> - chainIdList to log events to
//    pl_remoteCompref - *in* <EPTF_ILog_Transport_CT> - the remote component reference to connect to ("SUT")
//
//  Return Value:
//   *integer* - connectionId
//
///////////////////////////////////////////////////////////
public function f_EPTF_ILog_Transport_connect(in EPTF_IntegerList pl_iLogChainIds, in EPTF_ILog_Transport_CT pl_remoteCompref)
runs on EPTF_ILog_Transport_CT return integer {
  connect(self:v_msgPort,pl_remoteCompref:v_msgPort);
  var integer vl_connId := sizeof(v_ILog_Transport_connectionDB);
  v_ILog_Transport_connectionDB[vl_connId] := c_ILog_Transport_connectionDB_new;
  v_ILog_Transport_connectionDB[vl_connId].remoteComp := pl_remoteCompref;
//  v_msgPort.send(EPTF_ILog_Transport_Mngmnt_Msg:{Connect:=vl_connId});

  var integer vl_iLogElementId := f_EPTF_ILog_addToChains(v_ILog_Transport_dbId,pl_iLogChainIds);
  if (vl_iLogElementId!=-1) {
    v_ILog_Transport_ILogElementList[vl_iLogElementId] := {connection:={vl_connId}};
  }
  v_ILog_Transport_connectionDB[vl_connId].connectionChainIds := pl_iLogChainIds;
  return vl_connId;
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_ILog_Transport_disconnect
// 
//  Purpose:
//    Disconnects the current component from a remote PTC
//
//  Parameters:
//    pl_iLogChainIds - *in* <EPTF_IntegerList> - chainIdList to log events to
//    pl_remoteCompref - *in* <EPTF_ILog_Transport_CT> - the remote component reference to connect to ("SUT")
//
//  Return Value:
//   -
///////////////////////////////////////////////////////////
public function f_EPTF_ILog_Transport_disconnect(in EPTF_IntegerList pl_iLogChainIds, in integer pl_connId)
runs on EPTF_ILog_Transport_CT {
  if (not isbound(v_ILog_Transport_connectionDB[pl_connId])
    or v_ILog_Transport_connectionDB[pl_connId].remoteComp == null) {
    return; // no connection
  }
//  v_msgPort.send(EPTF_ILog_Transport_Mngmnt_Msg:{Disco:=0}) to v_ILog_Transport_connectionDB[pl_connId].remoteComp;
  disconnect(self:v_msgPort,v_ILog_Transport_connectionDB[pl_connId].remoteComp:v_msgPort);
  v_ILog_Transport_connectionDB[pl_connId] := c_ILog_Transport_connectionDB_new;

  var integer vl_iLogElementId := f_EPTF_ILog_addToChains(v_ILog_Transport_dbId,pl_iLogChainIds);
  if (vl_iLogElementId!=-1) {
    v_ILog_Transport_ILogElementList[vl_iLogElementId] := {disconnection:={pl_connId}};
  }
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_ILog_Transport_sendReq
// 
//  Purpose:
//    Sends a message through a connection, returns the transaction ID
//
//  Parameters:
//    pl_iLogChainIds - *in* <EPTF_IntegerList> - chainIdList to log events to
//    pl_connId - *in* *integer* - connection id to send the message over
//    pl_reqMsg - *in* <EPTF_ILog_Transport_RequestMsg> - the message to be sent
//
//  Return Value:
//   *integer* - transactionId: to identify the response that corresponds to this request
//
///////////////////////////////////////////////////////////
public function f_EPTF_ILog_Transport_sendReq(
  in EPTF_IntegerList pl_iLogChainIds,
  in integer pl_connId,
  in EPTF_ILog_Transport_RequestMsg pl_reqMsg
) runs on EPTF_ILog_Transport_CT return integer {
  if (not isbound(v_ILog_Transport_connectionDB[pl_connId])
    or v_ILog_Transport_connectionDB[pl_connId].remoteComp == null) {
    return -1; // operation unsuccessful
  }
  
  v_ILog_Transport_connectionDB[pl_connId].transactionId := v_ILog_Transport_connectionDB[pl_connId].transactionId + 1;
  v_ILog_Transport_connectionDB[pl_connId].transactions[v_ILog_Transport_connectionDB[pl_connId].transactionId].chainIds := pl_iLogChainIds;
  v_msgPort.send({pl_connId, v_ILog_Transport_connectionDB[pl_connId].transactionId,{req:=pl_reqMsg}}) to v_ILog_Transport_connectionDB[pl_connId].remoteComp;

  var integer vl_iLogElementId := f_EPTF_ILog_addToChains(v_ILog_Transport_dbId,pl_iLogChainIds);
  if (vl_iLogElementId!=-1) {
    v_ILog_Transport_ILogElementList[vl_iLogElementId] := {request:={pl_connId, v_ILog_Transport_connectionDB[pl_connId].transactionId, pl_reqMsg}};
  }

  return v_ILog_Transport_connectionDB[pl_connId].transactionId;
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_ILog_Transport_addRespHandlerFn
// 
//  Purpose:
//    Adds a handler for responses. They are called when response arrives
//
//  Parameters:
//    pl_respHandler - *in* <EPTF_ILog_Transport_RespHandler_FT> - the handler function reference
//
//  Return Value:
//   -
//
///////////////////////////////////////////////////////////
public function f_EPTF_ILog_Transport_addRespHandlerFn(in EPTF_ILog_Transport_RespHandler_FT pl_respHandler) runs on EPTF_ILog_Transport_CT {
  v_respHandlerFns := v_respHandlerFns & {pl_respHandler};
}

// returns error code (0: OK, >0: error, <0: nor resp)
private function f_EPTF_ILog_Transport_callRespHandlerFns(
  in EPTF_IntegerList pl_iLogChainIds,
  in integer pl_connId,
  in integer pl_transactionId,
  in EPTF_ILog_Transport_ResponseMsg pl_msg)
runs on EPTF_ILog_Transport_CT {
  var integer vl_errorCode := 0;
  for(var integer i:=0; i<sizeof(v_respHandlerFns); i:=i+1) {
    v_respHandlerFns[i].apply(
      pl_iLogChainIds,
      pl_connId,
      pl_transactionId,
      pl_msg
    );
  }
}

private function f_EPTF_ILog_Transport_logItem(in integer pl_elementIdx, in integer pl_dbId, in integer pl_chainId, in EPTF_IntegerList pl_param)
runs on EPTF_ILog_Transport_CT {
  action("EPTF_ILog_Transport: " ,v_ILog_Transport_ILogElementList[pl_elementIdx]);
}

// main event handler
private altstep as_EPTF_ILog_Transport_eventHandler() runs on EPTF_ILog_Transport_CT {
  var EPTF_ILog_Transport_Msg vl_msg;
  var EPTF_ILog_Transport_CT vl_sender;
  [] v_msgPort.receive({?,?,{req:=?}}) -> value vl_msg sender vl_sender {
    // request
    
    var float vl_weightSum := 
      v_ILog_Transport_responseWeights.OK+
      v_ILog_Transport_responseWeights.NOK+
      v_ILog_Transport_responseWeights.ErroneousResp+
      v_ILog_Transport_responseWeights.NoResp;
      
    var float vl_rnd := rnd()*vl_weightSum;
    // send OK if vl_errorCode 0, >0 NOK, <0 no resp
    if (vl_rnd<v_ILog_Transport_responseWeights.OK) {
      // send OK
      v_msgPort.send({vl_msg.connId, vl_msg.transactionId,{resp:={OK:={}}}}) to vl_sender;
    } else if (vl_rnd<v_ILog_Transport_responseWeights.OK+v_ILog_Transport_responseWeights.NOK) {
      // send NOK
      v_msgPort.send({vl_msg.connId, vl_msg.transactionId,{resp:={NOK:={}}}}) to vl_sender;
    } else if (vl_rnd<v_ILog_Transport_responseWeights.OK+v_ILog_Transport_responseWeights.NOK+v_ILog_Transport_responseWeights.ErroneousResp) {
      // erroneous resp (= OK with wring transactionId)
      v_msgPort.send({vl_msg.connId, -vl_msg.transactionId,{resp:={OK:={}}}}) to vl_sender;
    } else {
      // no resp
    }
    repeat;
  }
  [] v_msgPort.receive({?,?,{resp:=?}}) -> value vl_msg sender vl_sender {
    var EPTF_IntegerList vl_chains := {};
    if (isbound(v_ILog_Transport_connectionDB[vl_msg.connId])
      and isbound(v_ILog_Transport_connectionDB[vl_msg.connId].transactions)
      and isbound(v_ILog_Transport_connectionDB[vl_msg.connId].transactions[vl_msg.transactionId])
    ) {
      var integer vl_iLogElementId := f_EPTF_ILog_addToChains(v_ILog_Transport_dbId,v_ILog_Transport_connectionDB[vl_msg.connId].transactions[vl_msg.transactionId].chainIds);
      if (vl_iLogElementId!=-1) {
        v_ILog_Transport_ILogElementList[vl_iLogElementId] := {response:={vl_msg.connId, vl_msg.transactionId, vl_msg.msg.resp}};
      }
//      vl_chains := v_ILog_Transport_connectionDB[vl_msg.connId].transactions[vl_msg.transactionId].chainIds;
//     } else if (isbound(v_ILog_Transport_connectionDB[vl_msg.connId])) {
//       // transaction not found => add event to chains belonging to the connection
//       var integer vl_iLogElementId := f_EPTF_ILog_addToChains(v_ILog_Transport_dbId,v_ILog_Transport_connectionDB[vl_msg.connId].connectionChainIds);
//       if (vl_iLogElementId!=-1) {
//         v_ILog_Transport_ILogElementList[vl_iLogElementId] := {response:={vl_msg.connId, vl_msg.transactionId, vl_msg.msg.resp}};
//       }
//       //vl_chains := v_ILog_Transport_connectionDB[vl_msg.connId].connectionChainIds;
    } else {
      // add to all chains
      var integer vl_iLogElementId := f_EPTF_ILog_addToChains(v_ILog_Transport_dbId,{});
      if (vl_iLogElementId!=-1) {
        v_ILog_Transport_ILogElementList[vl_iLogElementId] := {response:={vl_msg.connId, vl_msg.transactionId, vl_msg.msg.resp}};
      }
    }

    f_EPTF_ILog_Transport_callRespHandlerFns(
      vl_chains,
      vl_msg.connId,
      vl_msg.transactionId,
      vl_msg.msg.resp
    );

    repeat;
  }
}





















//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//                   TEST
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

import from EPTF_CLL_ILog_Definitions all;

private type record EPTF_ILog_Transport_Test_Transaction {
  integer connId,
  integer trId,
  EPTF_IntegerList chainIds
}

private type record of EPTF_ILog_Transport_Test_Transaction EPTF_ILog_Transport_Test_Transactions;


private type record EPTF_ILog_Transport_Test_Session {
  integer nofResps,
  integer nofOKs
}

private type record of EPTF_ILog_Transport_Test_Session EPTF_ILog_Transport_Test_SessionList;

type record EPTF_ILog_Transport_Test_Timeout {
  integer connId,
  integer transactionId
}

type union EPTF_ILog_Transport_Test_ILogElement {
  EPTF_ILog_Transport_Connection connection,
  EPTF_ILog_Transport_Disconnection disconnection,
  EPTF_ILog_Transport_Request request,
  EPTF_ILog_Transport_Response response,
  EPTF_ILog_Transport_Test_Timeout timedout
}

type record of EPTF_ILog_Transport_Test_ILogElement EPTF_ILog_Transport_Test_ILogElementList;

private type component EPTF_ILog_Transport_Test_CT extends EPTF_ILog_Transport_CT, EPTF_ILog_CT {
  timer t_sendMsg := 0.1;
  timer t_execTime := 10.0;
  var integer v_connId[2];
  var EPTF_ILog_Transport_ResponseWeights v_nofResponses;
  var EPTF_ILog_Transport_Test_Transactions v_transactions;
  var EPTF_IntegerList v_ILogChainId;
  var EPTF_ILog_Transport_Test_SessionList v_EPTF_ILog_Transport_Test_sessions;
  var integer v_ILog_Transport_Test_dbId;
  var EPTF_ILog_Transport_Test_ILogElementList v_ILog_Transport_Test_ILogElementList;
}

private altstep as_EPTF_ILog_Transport_test_eventHandler() runs on EPTF_ILog_Transport_Test_CT {
  [] t_sendMsg.timeout {
    t_sendMsg.start;
    var integer vl_connId := float2int(rnd()*int2float(sizeof(v_connId)));
    var integer vl_iLogChainId := f_EPTF_ILog_newChain("Transport_test_conn#" & int2str(vl_connId));
    
    v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId] := {0, 0}
    
    var EPTF_IntegerList vl_chainIds := {vl_iLogChainId, v_ILogChainId[vl_connId]};
    f_EPTF_ILog_Transport_test_addTransaction(vl_connId,f_EPTF_ILog_Transport_sendReq(vl_chainIds, vl_connId,{Begin:={}}),vl_chainIds);
    f_EPTF_ILog_Transport_test_addTransaction(vl_connId,f_EPTF_ILog_Transport_sendReq(vl_chainIds, vl_connId,{Invoke:={}}),vl_chainIds);
    f_EPTF_ILog_Transport_test_addTransaction(vl_connId,f_EPTF_ILog_Transport_sendReq(vl_chainIds, vl_connId,{Invoke:={}}),vl_chainIds);
    f_EPTF_ILog_Transport_test_addTransaction(vl_connId,f_EPTF_ILog_Transport_sendReq(vl_chainIds, vl_connId,{Invoke:={}}),vl_chainIds);
    f_EPTF_ILog_Transport_test_addTransaction(vl_connId,f_EPTF_ILog_Transport_sendReq(vl_chainIds, vl_connId,{End:={}}),vl_chainIds);

    repeat;
  }
}

private function f_EPTF_ILog_Transport_test_respHandler(
  in EPTF_IntegerList pl_iLogChainIds,
  in integer pl_connId,
  in integer pl_transactionId,
  in EPTF_ILog_Transport_ResponseMsg pl_msg
) runs on EPTF_ILog_Transport_Test_CT {
  //action(%definitionId&": pl_connId: ", pl_connId, " pl_transactionId: ", pl_transactionId, " pl_msg: ", pl_msg);
  if (pl_transactionId<0) {
    v_nofResponses.ErroneousResp := v_nofResponses.ErroneousResp + 1.0;
  } else if (ischosen(pl_msg.OK)) {
    v_nofResponses.OK := v_nofResponses.OK + 1.0;
  } else if (ischosen(pl_msg.NOK)) {
    v_nofResponses.NOK := v_nofResponses.NOK + 1.0;
  }


  if (sizeof(pl_iLogChainIds)>0) {
    var integer vl_iLogChainId := pl_iLogChainIds[0];
    if (ischosen(pl_msg.OK)) {
      v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId].nofOKs := v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId].nofOKs + 1;
    }
    v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId].nofResps := v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId].nofResps + 1;

    // log chains that are not ok
    if ( v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId].nofResps == 5
      and v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId].nofOKs != v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId].nofResps) {
      // error occured
      f_EPTF_ILog_logChain(vl_iLogChainId);
    } else if (v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId].nofResps == 5) {
      f_EPTF_ILog_deleteChain(vl_iLogChainId);
    }
  }
  
  f_EPTF_ILog_Transport_test_deleteTransaction(pl_connId,pl_transactionId);
}

private function f_EPTF_ILog_Transport_test_logChains(in EPTF_IntegerList pl_iLogChainIds) runs on EPTF_ILog_Transport_Test_CT {
  for(var integer i:=0; i<sizeof(pl_iLogChainIds); i:=i+1) {
    f_EPTF_ILog_logChain(pl_iLogChainIds[i]);
  }
}

private function f_EPTF_ILog_Transport_test_deleteChains(in EPTF_IntegerList pl_iLogChainIds) runs on EPTF_ILog_Transport_Test_CT {
  for(var integer i:=0; i<sizeof(pl_iLogChainIds); i:=i+1) {
    f_EPTF_ILog_deleteChain(pl_iLogChainIds[i]);
  }
}

private function f_EPTF_ILog_Transport_Test_logItem(in integer pl_elementIdx, in integer pl_dbId, in integer pl_chainId, in EPTF_IntegerList pl_param)
runs on EPTF_ILog_Transport_Test_CT {
  action(%definitionId&": Event in chain#",pl_chainId,": ", f_EPTF_ILog_getName(pl_chainId), ": " ,v_ILog_Transport_Test_ILogElementList[pl_elementIdx]);
}

private function f_EPTF_ILog_Transport_test_addTransaction(
  in integer pl_connId,
  in integer pl_trId,
  in EPTF_IntegerList chainIds
) runs on EPTF_ILog_Transport_Test_CT {
  // search for unused slot:
  var integer vl_unusedSlotIdx:=sizeof(v_transactions);
  for(var integer i:=0; i<sizeof(v_transactions); i:=i+1) {
    if(v_transactions[i].connId == -1) {
      // found
      vl_unusedSlotIdx := i;
      break;
    }
  }
  //store the new transaction to this slot:
  v_transactions[vl_unusedSlotIdx] := {pl_connId,pl_trId,chainIds};
}

// searches the transactionIdx. if not found returns -1
private function f_EPTF_ILog_Transport_test_findTransaction(
  in integer pl_connId,
  in integer pl_trId
) runs on EPTF_ILog_Transport_Test_CT return integer {
  // search for the slot:
  var integer vl_slotIdx:=-1;
  for(var integer i:=0; i<sizeof(v_transactions); i:=i+1) {
    if(v_transactions[i].connId == pl_connId and v_transactions[i].trId == pl_trId) {
      // found
      vl_slotIdx := i;
      break;
    }
  }
  return vl_slotIdx;
}


// deletes the transaction
private function f_EPTF_ILog_Transport_test_deleteTransaction(
  in integer pl_connId,
  in integer pl_trId
) runs on EPTF_ILog_Transport_Test_CT{
  // search for the slot:
  var integer vl_slotIdx:=f_EPTF_ILog_Transport_test_findTransaction(pl_connId,pl_trId);
  if (vl_slotIdx==-1) {
    return;
  }
  v_transactions[vl_slotIdx] := {-1,-1};
}

private function f_EPTF_ILog_Transport_test_printStatistics() runs on EPTF_ILog_Transport_Test_CT {
  for(var integer i:=0; i<sizeof(v_transactions); i:=i+1) {
    if(v_transactions[i].connId != -1 and v_transactions[i].trId != -1) {
      // timeout
      v_nofResponses.NoResp := v_nofResponses.NoResp + 1.0;
      // place timeout into the chain:
      var integer vl_iLogElementId := f_EPTF_ILog_addToChains(v_ILog_Transport_Test_dbId,v_transactions[i].chainIds);
      if (vl_iLogElementId!=-1) {
        v_ILog_Transport_Test_ILogElementList[vl_iLogElementId] := {timedout:={v_transactions[i].connId, v_transactions[i].trId}};
      }
    }
  }
  
  action("Connection chain log for timed out sessions:");
  for(var integer i:=0; i<sizeof(v_EPTF_ILog_Transport_Test_sessions); i:=i+1) { 
    // log chains that timed out (remaining ones)
    var integer vl_iLogChainId := i;
    if ( isbound(v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId])
      and v_EPTF_ILog_Transport_Test_sessions[vl_iLogChainId].nofResps < 5 ) {
      // error occured
      f_EPTF_ILog_logChain(vl_iLogChainId);
    }
    // chains of the others have already deleted
  }

  
  action("Connection chain log for connection 1:");
  f_EPTF_ILog_logChain(v_ILogChainId[0]);
  action("Connection chain log for connection 2:");
  f_EPTF_ILog_logChain(v_ILogChainId[1]);

  
  action("Message statistics: ", v_nofResponses);

  // in percentage:
  var EPTF_ILog_Transport_ResponseWeights vl_nofResponses := v_nofResponses;
  var float vl_trSum := 
    v_nofResponses.OK+
    v_nofResponses.NOK+
    v_nofResponses.ErroneousResp+
    v_nofResponses.NoResp;
  vl_trSum := vl_trSum *0.01;
  vl_nofResponses.OK := vl_nofResponses.OK/vl_trSum;
  vl_nofResponses.NOK := vl_nofResponses.NOK/vl_trSum;
  vl_nofResponses.ErroneousResp := vl_nofResponses.ErroneousResp/vl_trSum;
  vl_nofResponses.NoResp := vl_nofResponses.NoResp/vl_trSum;
  action("Message statistics [%]: ", vl_nofResponses);
}


private testcase tc_EPTF_ILog_Transport_test() runs on EPTF_ILog_Transport_Test_CT {
  f_EPTF_ILog_Transport_init_CT("Transport_test"
//,{1.0,2.0,3.0,4.0}
);
  f_EPTF_ILog_init_CT("Transport_test");
  v_ILogChainId := {f_EPTF_ILog_newChain("Transport_test_Conn1")};
  v_ILogChainId := v_ILogChainId & {f_EPTF_ILog_newChain("Transport_test_Conn2")};
  v_nofResponses := {0.0,0.0,0.0,0.0};
  v_transactions := {};
  v_EPTF_ILog_Transport_Test_sessions := {}
  v_ILog_Transport_Test_dbId := f_EPTF_ILog_register_DB(refers(f_EPTF_ILog_Transport_Test_logItem), {});
  v_ILog_Transport_Test_ILogElementList := {}
  f_EPTF_ILog_Transport_addRespHandlerFn(refers(f_EPTF_ILog_Transport_test_respHandler));
  v_connId[0] := f_EPTF_ILog_Transport_connect({v_ILogChainId[0]},self);
  v_connId[1] := f_EPTF_ILog_Transport_connect({v_ILogChainId[1]},self);
  t_sendMsg.start; t_execTime.start;
  activate(as_EPTF_ILog_Transport_test_eventHandler());
  t_execTime.timeout;
  f_EPTF_ILog_Transport_test_printStatistics();
}




} //module EPTF_ILog_Transport_Functions