blob: d93caddef63d0b24c6547be1866cbbd5dccc718a [file] [log] [blame]
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000-2018 Ericsson Telecom AB
//
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
///////////////////////////////////////////////////////////////////////////////
//
// File: XTDP_OldTestPortDemoAndTest_Common.ttcn
// Rev: <RnXnn>
// Prodnr: CNL 11
// Updated: 2010-03-09
// Contact: http://ttcn.ericsson.se
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
// Module: XTDP_OldTestPortDemoAndTest_Common
//
// Purpose:
// This module provides
//
// Module depends on:
// -
//
// Current Owner:
//
//
// Last Review Date:
// -
//
///////////////////////////////////////////////////////////////
module XTDP_OldTestPortDemoAndTest_Common
{
import from XTDP_EncDecFunctions all
//import from www_mozilla_org_keymaster_gatekeeper_there_is_only_xul all;
//import from ttcn_ericsson_se_xtdp_xtdp_1_0 all
//import from ttcn_ericsson_se_xtdp_xul_1_0 all
import from NoTargetNamespace all;
import from IPL4asp_PortType all;
import from IPL4asp_Types all;
//import from IPL4asp_Functions all;
import from XTDP_Templates all;
//import from TCCDateTime_Functions all;
modulepar boolean tsp_debug_GuiTest :=false; //from XTDP_TP:RunTimeGuiTest.ttcn
modulepar boolean tsp_debugVerbose_GuiTest :=false;//from XTDP_TP:RunTimeGuiTest.ttcn
modulepar integer tsp_callGrpsNo := 80;//from XTDP_TP:RunTimeGuiTest.ttcn
modulepar integer tsp_sigLinksNo := 80//from XTDP_TP:RunTimeGuiTest.ttcn
modulepar float tsp_guard_timer := 30.0
type record of integer IntegerList;
type record of default DefaultList;
type component MTC {
port IPL4asp_PT IPL4;
var integer v_reqId := 1;
var integer v_plainRequest:= 0;
var IntegerList xtdp_connection_list := {};
var DefaultList xtdp_connection_defaultlist := {}
var XTDP_Message xtdp_message;
var ASP_Event ipl4_event;
var template integer newConnId := ?
}
function f_getNextReqId() runs on MTC return integer {
var integer vl_retVal := v_reqId;
v_reqId := v_reqId+1;
return vl_retVal;
}
modulepar charstring tsp_xtdp_connectTo_addr := "172.31.21.49";
modulepar integer tsp_xtdp_connectTo_port := 11420;
modulepar charstring tsp_xtdp_listenAt_addr := "159.107.148.181";
modulepar integer tsp_xtdp_listenAt_port := 11420;
template ASP_RecvFrom t_recvfrom(template integer pl_connId) := {
connId := pl_connId,
remName := ?,
remPort := ?,
locName := ?,
locPort := ?,
proto := ?,
userData := ?,
msg := ?
}
template ASP_Event t_res(template integer pl_connId) := {
result := {
errorCode := *,
connId := pl_connId,
os_error_code := *,
os_error_text := *}
}
template ASP_Event t_open(template integer pl_connId) := {
connOpened := {
connId := pl_connId,
remName := ?,
remPort := ?,
locName := ?,
locPort := ?,
proto :=?,
userData :=?
}
}
template ASP_Event t_sctpEvent := {
sctpEvent := ?
}
template ASP_Event t_close(template integer pl_connId) := {
connClosed := {
connId := pl_connId,
remName := ?,
remPort := ?,
locName := ?,
locPort := ?,
proto :=?,
userData :=?
}
}
function f_connectToServerGui(in charstring pl_addr, in integer pl_port)
runs on MTC return integer //connId
{
var integer vl_connId;
//map
map(self:IPL4, system:IPL4);
//connect to GUI
var Result result:= IPL4asp_PortType.f_IPL4_connect(
IPL4,
pl_addr, pl_port,
c_ipv4AnyAddr, c_anyPort,
vl_connId, {tcp := {}})
if (ispresent(result.errorCode)) {
log("Connection failed: ",result.errorCode);
setverdict(fail);
stop;
}
log("Connection open: ",result);
setverdict(pass);
vl_connId:= result.connId
//register message dissector for receiving
var f_IPL4_getMsgLen fcb_msglen := refers(f_XTDP_getMsgLen);
f_IPL4_setGetMsgLen(IPL4, vl_connId, fcb_msglen, {})
return vl_connId;
}
function f_listenForClientGui(in charstring pl_addr, in integer pl_port)
runs on MTC return integer //server connId
{
var integer vl_connId;
//map
map(self:IPL4, system:IPL4);
//connect to GUI
var Result result:= IPL4asp_PortType.f_IPL4_listen(
portRef:= IPL4,
locName:= pl_addr,
locPort:= pl_port,
proto:= {tcp := {}},
options:= {
// {reuseAddress := {enable:=true}},
// {tcpKeepAlive := {
// /*boolean*/ enable := true /*optional*/,
// /*integer*/ count := omit /*optional*/,
// /*integer*/ idle :=omit /*optional*/,
// /*integer*/ interval := omit /*optional*/
// }}
}
) //open listen port
if (ispresent(result.errorCode)) {
log("Listening failed: ",result);
setverdict(fail);
stop;
}
log("Listening started, result: ",result);
setverdict(pass);
vl_connId:= result.connId
//register message dissector for receiving
var f_IPL4_getMsgLen fcb_msglen := refers(f_XTDP_getMsgLen);
f_IPL4_setGetMsgLen(IPL4, vl_connId, fcb_msglen, {})
return vl_connId;
}
function f_sayBye(in integer pl_connId)
runs on MTC //connId
{
//say Bye
var octetstring vl_msgOct := enc_XTDP_Message(XTDP_Message:{
noNamespaceSchemaLocation := "XTDP-Message.xsd",
choice := {
xTDP_Bye := "Normal end."
}
})
var ASP_Send asp := {
connId := pl_connId,
proto := omit,
msg := int2oct(lengthof(vl_msgOct)+4,4) & vl_msgOct
};
IPL4.send(asp);
timer t := 5.0; t.start; t.timeout;
var ASP_Event vl_ipl4Event;
var XTDP_Message xtdpMsg;
var integer vl_result := -1;
var template integer vl_conn := pl_connId
t.start
alt {
[]as_result(vl_conn, t, vl_ipl4Event) {
if(vl_ipl4Event.result.os_error_code == 104) {
log("The GUI reset the connection");
}
if (ispresent(vl_ipl4Event.result.errorCode)) {
log(%definitionId, ": Port error, giving up: ", vl_ipl4Event.result);
t.stop;
} else {
repeat;
}
}
[]as_connClose(t, vl_conn) {
log("The GUI closed the connection. I also exit.");
t.stop;
}
[]as_recvFrom4Test(vl_conn, t, vl_result, xtdpMsg) {
// as_recvFrom4Test will log the message
t.stop; t.start; repeat;
}
[] t.timeout {
log(%definitionId, ": Timeout waiting for answer");
}
}
}
function f_close(in integer pl_connId)
runs on MTC //connId
{
var Result result:= IPL4asp_PortType.f_IPL4_close(IPL4, pl_connId, {tcp := {}})
if (ispresent(result.errorCode)) {
log("Closing failed: ",result.errorCode);
setverdict(fail);
stop;
}
log("Connection closed: ",result);
setverdict(pass);
}
function f_sayByeAndCloseWithStop(in integer pl_connId)
runs on MTC //connId
{
//say Bye
f_sayBye(pl_connId);
//close
f_close(pl_connId)
//unmap
unmap(self:IPL4, system:IPL4);
stop;
}
function f_send(
in integer pl_connId,
in template XTDP_Message pl_msg
) runs on MTC {
if (ischosen(pl_msg.choice.xTDP_Requests)) {v_plainRequest := v_plainRequest+1}
var octetstring vl_msgOct := enc_XTDP_Message(valueof(pl_msg))
var ASP_Send asp := {
connId := pl_connId,
proto := omit,
msg := int2oct(lengthof(vl_msgOct)+4,4) & vl_msgOct
};
IPL4.send(asp);
}
altstep get_xtdp_message(template integer pl_connId) runs on MTC {
//var ASP_XTDP xtdp_asp;
//var integer vl_length := 0, vl_row, vl_column;
var charstring vl_cell, vl_rowstr, vl_columnstr, widgetRoot;
var ASP_RecvFrom vl_recv;
var ASP_Event vl_event;
var XTDP_Message vl_msg;
[] IPL4.receive(t_recvfrom(pl_connId)) -> value vl_recv {
log("Communication ASP received: ",vl_recv)
setverdict(pass);
var integer vl_result:= dec_XTDP_Message(f_XTDP_getRawMsg(vl_recv.msg), vl_msg);
if (vl_result ==0 ) {
log("Decoded msg:", vl_msg, " result:", vl_result)
setverdict(pass);
} else {
log("Unsuccesful decode:", vl_msg, " result:", vl_result)
setverdict(fail);
}
select( vl_msg )
{
case ( t_singleSuccessResp(?) )
{
if (tsp_debug_GuiTest) {
log("GUI reported success for request #", vl_msg.choice.xTDP_Responses.xTDP_Response_list[0].requestId);
}
repeat;
}
case ( t_singleErrorResp(pl_rqId:=?, pl_argument:=*, pl_errorSource:=?, pl_errorCode:=?, pl_errorMessage:=?) )
{
if (tsp_debug_GuiTest) {
log("GUI reported error for request #", vl_msg.choice.xTDP_Responses.xTDP_Response_list[0].requestId);
}
repeat;
}
case ( t_snapshotButtonPressed(pl_rqId:=?, pl_wtype:=string, pl_argument:=?, pl_timeout:=*) )
{
//f_sendSnapshot();
if (tsp_debug_GuiTest) {action("Snapshot button pressed...")};
repeat;
}
case else
{
log("GUI reported:", vl_msg);
if (tsp_debug_GuiTest) {action("GUI message is not handled here :-(");};
}
}
repeat;
}
}
altstep as_recvFrom(inout template integer pl_listenConnId, timer pl_Tguard, out integer pl_result) runs on MTC{
var ASP_RecvFrom vl_recv;
var XTDP_Message vl_msg;
[] IPL4.receive(t_recvfrom(pl_listenConnId)) -> value vl_recv {
pl_listenConnId := vl_recv.connId;
pl_Tguard.stop;
log("Communication ASP received: ",vl_recv)
pl_result:= dec_XTDP_Message(f_XTDP_getRawMsg(vl_recv.msg), vl_msg);
if (pl_result ==0 ) {
log("Decoded msg:", vl_msg, " result:", pl_result)
//var Window vl_window;
//vl_result := dec_XTDL_Window(char2oct(unichar2char(vl_msg.choice.xTDP_LayoutResponse.elem)), vl_window)
} else {
log("Unsuccesful decode:", vl_msg, " result:", pl_result)
}
if(pl_result == 0 and ischosen(vl_msg.choice.xTDP_Responses)) {
for(var integer i := 0; i < sizeof(vl_msg.choice.xTDP_Responses); i := i + 1) {
if(vl_msg.choice.xTDP_Responses.xTDP_Response_list[i].responseCode != success) {
log("Response #", i, " is not success!");
setverdict(fail);
} else {
log("Response #", i, " is success!");
setverdict(pass);
}
}
}
}
}
altstep as_grokAck(inout template integer pl_listenConnId, timer pl_Tguard) runs on MTC{
var ASP_RecvFrom vl_recv;
var XTDP_Message vl_msg;
var integer vl_result := -1;
[] IPL4.receive(t_recvfrom(pl_listenConnId)) -> value vl_recv {
pl_listenConnId := vl_recv.connId;
pl_Tguard.stop;
log("Communication ASP received: ",vl_recv)
vl_result:= dec_XTDP_Message(f_XTDP_getRawMsg(vl_recv.msg), vl_msg);
if (vl_result ==0 ) {
log("Decoded msg:", vl_msg, " result:", vl_result)
//var Window vl_window;
//vl_result := dec_XTDL_Window(char2oct(unichar2char(vl_msg.choice.xTDP_LayoutResponse.elem)), vl_window)
} else {
log("Unsuccesful decode:", vl_msg, " result:", vl_result)
setverdict(fail)
}
if(vl_result == 0) {
if (ischosen(vl_msg.choice.xTDP_Responses)) {
for(var integer i := 0; i < sizeof(vl_msg.choice.xTDP_Responses); i := i + 1) {
if(vl_msg.choice.xTDP_Responses.xTDP_Response_list[i].responseCode != success) {
log("Response #", i, " is not success!");
setverdict(fail);
} else {
log("Response #", i, " is success!");
setverdict(pass);
}
}
} else {
log(%definitionId, ": unhandled msg", vl_msg)
setverdict(inconc);
}
}
}
}
altstep as_recvFrom4Test(inout template integer pl_listenConnId, timer pl_Tguard, out integer pl_result, out XTDP_Message pl_msg) runs on MTC{
var ASP_RecvFrom vl_recv;
[] IPL4.receive(t_recvfrom(pl_listenConnId)) -> value vl_recv {
pl_listenConnId := vl_recv.connId;
pl_Tguard.stop;
log("Communication ASP received: ",vl_recv)
pl_result:= dec_XTDP_Message(f_XTDP_getRawMsg(vl_recv.msg), pl_msg);
if (pl_result ==0 ) {
log("Decoded msg:", pl_msg, " result:", pl_result)
//var Window vl_window;
//vl_result := dec_XTDL_Window(char2oct(unichar2char(vl_msg.choice.xTDP_LayoutResponse.elem)), vl_window)
} else {
log("Unsuccesful decode:", pl_msg, " result:", pl_result)
}
if(pl_result == 0 and ischosen(pl_msg.choice.xTDP_Responses)) {
for(var integer i := 0; i < sizeof(pl_msg.choice.xTDP_Responses); i := i + 1) {
if(pl_msg.choice.xTDP_Responses.xTDP_Response_list[i].responseCode != success) {
log("Response #", i, " is not success!");
setverdict(fail);
} else {
log("Response #", i, " is success!");
setverdict(pass);
}
}
}
}
}
altstep as_connOpen(timer pl_Tguard, inout template integer pl_clientConnId) runs on MTC{
var ASP_Event vl_event;
[] IPL4.receive(t_open(pl_clientConnId)) -> value vl_event{
log("Event: Result ASP received:", vl_event);
pl_Tguard.stop;
pl_clientConnId := vl_event.connOpened.connId;
}
}
altstep as_connClose(timer pl_Tguard, inout template integer pl_connId) runs on MTC{
var ASP_Event vl_event;
[] IPL4.receive(t_close(pl_connId)) -> value vl_event{
log("Event: Connection closed: ",vl_event);
pl_connId := vl_event.connClosed.connId;
pl_Tguard.stop
}
}
altstep as_result(inout template integer pl_listenConnId, timer pl_Tguard, out ASP_Event pl_event) runs on MTC{
var ASP_Event vl_event;
[] IPL4.receive(t_res(pl_listenConnId)) -> value vl_event{
pl_listenConnId := vl_event.result.connId
pl_event := vl_event;
log("Event: ", vl_event)
pl_Tguard.stop;
}
}
altstep as_defaultSctpAndTimer(template integer pl_listenConnId, timer pl_Tguard) runs on MTC{
var ASP_Event vl_event;
[] IPL4.receive(t_sctpEvent) -> value vl_event {
log("Event: SCTP event arrived: ",vl_event)
repeat;
}
[] pl_Tguard.timeout {
log("timeout:", pl_Tguard);
setverdict(fail,"timeout:", pl_Tguard);
stop
}
}
altstep as_any(inout template integer pl_listenConnId) runs on MTC{
var ASP_Event vl_event
var template integer vl_conn := pl_listenConnId;
var integer vl_result;
timer dummy;
[] as_result(vl_conn, dummy, vl_event) {}
[] as_recvFrom(vl_conn, dummy, vl_result) {}
[] IPL4.receive {
log("Unhandled IPL4 ASP has arrived, discarded!")
}
}
function f_wait4RecvFrom(in integer pl_connId) runs on MTC {
timer T
T.start(30.0);
var integer vl_result := -1;
var template integer vl_clientConnId := pl_connId
alt {
[] as_recvFrom(vl_clientConnId, T, vl_result) {
if (vl_result==0){
setverdict(pass)
} else {
setverdict(fail, "Unsuccesful XTDP decode");
}
}
}
}
altstep f_wait4ConnOpened(
inout template integer pl_serverConnId,
inout template integer pl_clientConnId,
timer T
) runs on MTC {
var ASP_Event vl_event;
var integer vl_result;
[] as_recvFrom(pl_serverConnId, T, vl_result){
setverdict(fail);
}
[] as_result(pl_serverConnId, T, vl_event) {
log("Event: Result ASP received:", vl_event);
setverdict(fail);
stop
}
[]as_connOpen(T, pl_clientConnId) {
setverdict(pass);
T.stop;
}
[] as_connClose(T, pl_clientConnId) {
setverdict(fail,"Event: Connection closed");
stop
}
[]as_defaultSctpAndTimer(pl_serverConnId, T){
}
}
} // end of module