Skip to content
Snippets Groups Projects
Commit 0547a2a9 authored by balaskoa's avatar balaskoa
Browse files

Only naming convention and indentation cahnged in a test 


Signed-off-by: default avatarbalaskoa <jeno.balasko@ericsson.com>
parent ab19ef93
No related branches found
No related tags found
1 merge request!78Only naming convention and indentation cahnged in a test
Hide whitespace changes
Inline Side-by-side
regression_test/commProcedure/ProcPort.ttcn
+ 632
− 632
View file @ 0547a2a9
/****************************************************************************** /******************************************************************************
* Copyright (c) 2000-2016 Ericsson Telecom AB * Copyright (c) 2000-2016 Ericsson Telecom AB
* All rights reserved. This program and the accompanying materials * All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0 * are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at * which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html * http://www.eclipse.org/legal/epl-v10.html
* *
* Contributors: * Contributors:
* Balasko, Jeno * Balasko, Jeno
* Baranyi, Botond * Baranyi, Botond
* Forstner, Matyas * Forstner, Matyas
* Raduly, Csaba * Raduly, Csaba
* Szabados, Kristof * Szabados, Kristof
* Szabo, Janos Zoltan – initial implementation * Szabo, Janos Zoltan – initial implementation
* Tatarka, Gabor * Tatarka, Gabor
* *
******************************************************************************/ ******************************************************************************/
module ProcPort { module ProcPort {
type record MyRecord { } type record MyRecord { }
signature MyProc(in integer Par1,inout charstring Par2,out float Par3)
return boolean
exception(integer);
signature MyProc2();
type MyProc2 MyProc2Alias; // testing type alias
signature MyProc3(in integer I) return float exception(integer);
signature MyProc4(in float F) noblock;
signature MyProc5(in integer A, in integer B)
return float exception(charstring, MyRecord);
signature s_StopPTC();
signature MyProc6(inout integer I);
template s_StopPTC StopPTC := { }
template MyProc5 MyProc5Template_any := {
A:=?,
B:=?
}
signature MyProc(in integer Par1,inout charstring Par2,out float Par3) template MyProc5 MyProc5TemplateP(integer pA,integer pB) := {
return boolean A:=pA,
exception(integer); B:=pB
signature MyProc2(); }
type MyProc2 MyProc2Alias; // testing type alias
signature MyProc3(in integer I) return float exception(integer);
signature MyProc4(in float F) noblock;
signature MyProc5(in integer A, in integer B)
return float exception(charstring, MyRecord);
signature s_StopPTC();
signature MyProc6(inout integer I);
template s_StopPTC StopPTC := { } template MyProc3 MyProc3Template:={
I:=2003
}
template MyProc5 MyProc5Template_any := { template MyProc3 MyProc3Template_any:={I:=?}
A:=?,
B:=? template MyProc3 MyProc3TemplateP (integer P) := {
} I:=P
}
template MyProc MyProcTemplateP (integer i,charstring c,float f) := {
Par1:=i,
Par2:=c,
Par3:=f
}
template MyProc MyProcTemplate:= {
Par1:=44,
Par2:="Q",
Par3:=324.664
}
template MyProc MyProcTemplate2:= {
Par1:=4200,
Par2:="T",
Par3:=170.01
}
template MyProc MyProcTemplate_any:= {
Par1:=?,
Par2:=?,
Par3:=?
}
template MyProc2 MyProc2Template := { }
template MyProc5 MyProc5TemplateP(integer pA,integer pB) := { type record address {
A:=pA, integer a1,
B:=pB integer a2
}
template address MyAddress(integer p1,integer p2) := {
a1:=p1,
a2:=p2
}
type port PortAddress procedure {
inout MyProc,s_StopPTC;
in MyProc2;
} with { extension "address" }
type port ProcPort1 procedure
{
inout MyProc,s_StopPTC;
in MyProc2;
out MyProc3;
} with {extension "internal"}
type port ProcPort2 procedure
{
inout MyProc,s_StopPTC;
out MyProc2;
in MyProc3;
} with {extension "internal"}
type port ExtProcPort procedure
{
inout MyProc5;
}
type port CompileOnlyPort procedure
{
in MyProc;
inout MyProc2;
out MyProc3;
in MyProc4;
inout MyProc5;
}
type port CompileOnlyPortAddress procedure {
out MyProc;
in MyProc2;
inout MyProc3;
out MyProc4;
in MyProc5;
} with { extension "address" }
type port ProcPort3 procedure {
inout MyProc6;
} with { extension "internal" }
type component ProcComponent
{
port ProcPort1 Port0;
}
type component ProcComponent2
{
port ProcPort2 Port1;
}
type component ProcComponentMultiPort
{
port ProcPort1 Port0;
port ProcPort2 Port1[4];
port ExtProcPort Port2;
port CompileOnlyPort Port3;
port PortAddress Port4;
}
type component eComponent
{
port ExtProcPort ePort;
}
type component addressComponent
{
port PortAddress P;
}
type component ProcComponent3 {
port ProcPort3 pt;
}
function GetCall_behav1() runs on ProcComponent2 {
while(true) {
alt {
[]Port1.getcall(MyProcTemplate_any) {
Port1.reply(MyProcTemplate2 value true);
}
[]Port1.getcall(MyProc3Template_any) {
Port1.reply(MyProc3Template value 3.1415);
}
[]Port1.getcall(StopPTC) {
Port1.reply(StopPTC);
stop;
}
} }
}
}
template MyProc3 MyProc3Template:={ function GetCall_behav2() runs on ProcComponent {
I:=2003 while(true) {
alt {
[]Port0.getcall(MyProcTemplate2) {
Port0.raise(MyProc,integer:555);
}
[]Port0.getcall(MyProcTemplate_any) {
Port0.reply(MyProcTemplate value false);
}
[]Port0.getcall(MyProc2Template) {
Port0.reply(MyProc2Template);
}
[]Port0.getcall(StopPTC) {
Port0.reply(StopPTC);
stop;
}
} }
}
}
template MyProc3 MyProc3Template_any:={I:=?} function GetCall_behav3() runs on ProcComponent2 {
while(true) {
alt {
[]Port1.getcall(MyProcTemplate2) {
Port1.raise(MyProc,integer:272869);
}
[]Port1.getcall(MyProcTemplate_any) {
Port1.reply(MyProcTemplateP(22,"G",199.99) value false);
}
[]Port1.getcall(MyProc3Template_any) {
Port1.reply(MyProc3Template value 2.78);
}
[]Port1.getcall(StopPTC) {
Port1.reply(StopPTC);
stop;
}
}
}
}
template MyProc3 MyProc3TemplateP (integer P) := { function Check_getcall_behav() runs on ProcComponent2 {
I:=P while(true) {
alt {
[]Port1.check(getcall(MyProcTemplate2)) {
Port1.getcall;
Port1.reply(MyProcTemplate value true);
}
[]Port1.getcall(StopPTC) {
Port1.reply(StopPTC);
stop;
}
[]Port1.check(getcall) {
Port1.getcall;
Port1.reply(MyProcTemplate2 value false);
}
} }
}
}
template MyProc MyProcTemplateP (integer i,charstring c,float f) := { // parameters values
Par1:=i, const integer c_CallParam := 10;
Par2:=c, const integer c_ReplyParam := 19;
Par3:=f
// error codes
template integer t_getCall_invalidValue := -1;
template integer t_getCall_timeout := -2;
function GetCallParameters_behav() runs on ProcComponent3 {
var integer x := 0;
timer t := 1.0;
t.start;
alt {
[] pt.getcall(MyProc6:{?}) -> param (x) {
if (c_CallParam == x) { pt.reply(MyProc6:{c_ReplyParam}); }
else { pt.reply(MyProc6:{t_getCall_invalidValue}); }
}
[] t.timeout { pt.reply(MyProc6:{t_getCall_timeout}); }
}
}
testcase tc1_Call() runs on ProcComponent {
/* Non-blocking calls */
var ProcComponent2 PC2;
var integer i:=0;
var boolean b:=false;
var float f:=0.0;
timer T:=1.0;
PC2:=ProcComponent2.create;
PC2.start(GetCall_behav1());
connect(self:Port0,PC2:Port1);
T.start;
Port0.call(MyProcTemplate,nowait);
Port0.call(MyProc3Template,nowait);
while(i<2) {
alt {
[]Port0.getreply(MyProcTemplate2) -> value b {
if(i==0) {
if(b==true) {i:=1;}
else {setverdict(fail);stop;}
} else {
setverdict(inconc);stop;
}
}
[]Port0.getreply(MyProc3Template) -> value f {
if((i==1)and(f==3.1415)) {i:=2;}
else {log(f);setverdict(inconc);stop;}
}
[]T.timeout {
setverdict(fail);
stop;
}
} }
}
if(i==2) {setverdict(pass);}
Port0.call(StopPTC,0.5) {
[]Port0.getreply(StopPTC) { }
[]Port0.catch(timeout) { }
}
disconnect(self:Port0,PC2:Port1);
}
template MyProc MyProcTemplate:= { testcase tc2_Call() runs on ProcComponent2 {
Par1:=44, /* Blocking calls */
Par2:="Q", var ProcComponent PC;
Par3:=324.664 var boolean b:=true;
PC:=ProcComponent.create;
PC.start(GetCall_behav2());
connect(self:Port1,PC:Port0);
Port1.call(MyProcTemplate,1.0) {
[]Port1.getreply(MyProcTemplate value ?) -> value b{
Port1.call(MyProc2Template,0.7) {
[]Port1.getreply(MyProc2Template) {
Port1.call(MyProcTemplate2,0.4) {
[]Port1.catch(MyProc,integer:555) {
if(b==false) {setverdict(pass);}
else {setverdict(inconc);}
}
[]Port1.catch(timeout) {
setverdict(fail);
stop;
}
}
}
[]Port1.catch(timeout) {
setverdict(fail);
stop;
}
}
}
[]Port1.catch(timeout) {
setverdict(fail);
stop;
} }
}
Port1.call(StopPTC,0.5) {
[]Port1.getreply(StopPTC) { }
[]Port1.catch(timeout) { }
}
}
template MyProc MyProcTemplate2:= { testcase tc_extCall() runs on eComponent system eComponent {
Par1:=4200, map(self:ePort,system:ePort);
Par2:="T", ePort.call(MyProc5TemplateP(128,32),0.5) {
Par3:=170.01 []ePort.getreply(MyProc5Template_any value 4.0) {
setverdict(pass);
}
[]ePort.catch(timeout) {
setverdict(fail);stop;
} }
}
unmap(self:ePort,system:ePort);
}
template MyProc MyProcTemplate_any:= { testcase tc_extCall_2() runs on eComponent system eComponent {
Par1:=?, map(self:ePort,system:ePort);
Par2:=?, ePort.call(MyProc5TemplateP(32,128),0.5) {
Par3:=? []ePort.getreply(MyProc5Template_any value 0.25) {
setverdict(pass);
}
[]ePort.catch(timeout) {
setverdict(fail);stop;
} }
}
unmap(self:ePort,system:ePort);
}
template MyProc2 MyProc2Template := { } testcase tc_extCall_3() runs on eComponent system eComponent {
map(self:ePort,system:ePort);
ePort.call(MyProc5TemplateP(128,0),0.5) {
[]ePort.catch(MyProc5,charstring:"Divide by 0.") {
setverdict(pass);
}
[]ePort.catch(timeout) {
setverdict(fail);stop;
}
}
unmap(self:ePort,system:ePort);
}
type record address { testcase tc_Call_MultiPTC() runs on ProcComponent {
integer a1, /* procedure based communication with multiple PTCs */
integer a2 var ProcComponent2 PC1,PC2;
var integer i:=0;
timer T:=1.0;
PC1:=ProcComponent2.create;
PC1.start(GetCall_behav1());
connect(self:Port0,PC1:Port1);
PC2:=ProcComponent2.create;
PC2.start(GetCall_behav3());
connect(self:Port0,PC2:Port1);
T.start;
Port0.call(MyProcTemplate,nowait) to PC1;
Port0.call(MyProc3Template,nowait) to PC2;
while(i<2) {
alt {
[]Port0.getreply(MyProcTemplate2 value true) from PC1 {
i:=i+1;
}
[]Port0.getreply(MyProc3Template value 2.78) from PC2 {
i:=i+1;
}
[]T.timeout {
setverdict(fail);stop;
}
} }
}
setverdict(pass);
Port0.call(StopPTC,0.5) to PC1 {
[]Port0.getreply(StopPTC) from PC1 { }
[]Port0.catch(timeout) { setverdict(fail);stop; }
}
Port0.call(StopPTC,0.5) to PC2 {
[]Port0.getreply(StopPTC) from PC2 { }
[]Port0.catch(timeout) { setverdict(fail);stop; }
}
disconnect(self:Port0,PC1:Port1);
disconnect(self:Port0,PC2:Port1);
}
template address MyAddress(integer p1,integer p2) := { testcase tc_Call_MultiPTC_anyport() runs on ProcComponentMultiPort {
a1:=p1, /* testing any-port operations with multiple PTCs */
a2:=p2 var ProcComponent2 PC1,PC2;
var ProcComponent2 sndr;
var integer i:=0;
var boolean chk1:=true,chk2:=true;
timer T:=1.5;
PC1:=ProcComponent2.create;
PC1.start(GetCall_behav1());
connect(self:Port0,PC1:Port1);
PC2:=ProcComponent2.create;
PC2.start(GetCall_behav3());
connect(self:Port0,PC2:Port1);
T.start;
Port0.call(MyProcTemplate,nowait) to PC1;
Port0.call(MyProc3Template,nowait) to PC2;
while(i<4) {
alt {
[chk1]any port.check {
i:=i+1;
chk1:=false;
log("any port.check OK");
}
[chk2]any port.check(getreply -> sender sndr) {
i:=i+1;
chk2:=false;
log("any port.check(getreply) OK, sender: ",sndr);
}
[]any port.check(catch) {
log("any port.check(catch) matched --> fail");
setverdict(fail);stop;
}
[]any port.getcall {
log("any port.getcall matched --> fail");
setverdict(fail);stop;
}
[]any port.getreply from PC1 {
log("any port.getreply from PC1 OK");
i:=i+1;
}
[]any port.getreply from PC2 {
log("any port.getreply from PC2 OK");
i:=i+1;
}
[]T.timeout {
setverdict(fail);stop;
}
} }
}
setverdict(pass);
Port0.call(StopPTC,0.5) to PC1 {
[]Port0.getreply(StopPTC) from PC1 { }
[]Port0.catch(timeout) { setverdict(fail);stop; }
}
Port0.call(StopPTC,0.5) to PC2 {
[]Port0.getreply(StopPTC) from PC2 { }
[]Port0.catch(timeout) { setverdict(fail);stop; }
}
disconnect(self:Port0,PC1:Port1);
disconnect(self:Port0,PC2:Port1);
}
type port PortAddress procedure { testcase tc_Check_1() runs on ProcComponent {
inout MyProc,s_StopPTC; var ProcComponent2 PC2;
in MyProc2; timer T:=1.5;
} with { extension "address" } PC2:=ProcComponent2.create;
PC2.start(GetCall_behav3());
connect(self:Port0,PC2:Port1);
Port0.call(MyProcTemplate2,nowait);
T.start;
alt {
[]Port0.check(catch) { }
[]T.timeout {
setverdict(fail);
stop;
}
}
alt {
[]any port.check(catch) {
log("any port.check(catch) OK");
}
[]T.timeout {
setverdict(fail);
stop;
}
}
alt {
[]Port0.check(catch(MyProc,integer:272869)) {
Port0.catch;
}
[]T.timeout {
setverdict(fail);
stop;
}
}
Port0.call(MyProcTemplate,nowait);
alt {
[]Port0.check(getreply) { }
[]T.timeout {
setverdict(fail);
stop;
}
}
alt {
[]Port0.check(getreply(MyProcTemplateP(22,"G",199.99) value false)){
Port0.getreply;
setverdict(pass);
}
[]T.timeout {
setverdict(fail);
stop;
}
}
Port0.call(StopPTC,0.5) {
[]Port0.getreply(StopPTC) { }
[]Port0.catch(timeout) { }
}
}
type port ProcPort1 procedure testcase tc_Check_2() runs on ProcComponent {
{ var ProcComponent2 PC2;
inout MyProc,s_StopPTC; PC2:=ProcComponent2.create;
in MyProc2; PC2.start(Check_getcall_behav());
out MyProc3; connect(self:Port0,PC2:Port1);
} with {extension "internal"} Port0.call(MyProcTemplate2,1.0) {
[]Port0.getreply(MyProcTemplate value true) { }
[]Port0.catch(timeout) {
setverdict(fail);
stop;
}
}
Port0.call(MyProcTemplate,1.0) {
[]Port0.getreply(MyProcTemplate2 value false) {
setverdict(pass);
}
[]Port0.catch(timeout) {
setverdict(fail);
stop;
}
}
Port0.call(StopPTC,0.5) {
[]Port0.getreply(StopPTC) { }
[]Port0.catch(timeout) { }
}
}
type port ProcPort2 procedure testcase tc_PortAddress_internal_usage() runs on ProcComponentMultiPort {
{ /* procedure based internal communication with address-supporting port */
inout MyProc,s_StopPTC; var ProcComponent2 PC2;
out MyProc2; var integer i:=0;
in MyProc3; PC2:=ProcComponent2.create;
} with {extension "internal"} PC2.start(GetCall_behav3());
connect(self:Port4,PC2:Port1);
Port4.call(MyProcTemplateP(11,"T",99.012),1.0) {
[]Port4.getreply(MyProcTemplateP(22,"G",199.99) value false) {
i:=i+1;
}
[]Port4.catch(timeout) {
setverdict(fail);stop;
}
}
Port4.call(MyProcTemplate2,1.0) {
[]Port4.catch(MyProc,integer:272869) {
i:=i+1;
}
[]Port4.catch(timeout) {
setverdict(fail);stop;
}
}
if(i==2){setverdict(pass);}
Port4.call(StopPTC,1.0) {
[]Port4.getreply(StopPTC) { }
[]Port4.catch(timeout) {
setverdict(fail);
}
}
}
type port ExtProcPort procedure testcase tc_PortAddress_external_usage1() runs on addressComponent
{ system addressComponent {
inout MyProc5; map(self:P,system:P);
P.call(MyProcTemplate,1.0) to valueof(MyAddress(321,67)) {
[]P.getreply(MyProcTemplate_any value true) from MyAddress(67,321) {
setverdict(pass);
} }
[]P.catch(timeout) {
type port CompileOnlyPort procedure setverdict(fail);
{
in MyProc;
inout MyProc2;
out MyProc3;
in MyProc4;
inout MyProc5;
}
type port CompileOnlyPortAddress procedure {
out MyProc;
in MyProc2;
inout MyProc3;
out MyProc4;
in MyProc5;
} with { extension "address" }
type port ProcPort3 procedure {
inout MyProc6;
} with { extension "internal" }
type component ProcComponent
{
port ProcPort1 Port0;
}
type component ProcComponent2
{
port ProcPort2 Port1;
}
type component ProcComponentMultiPort
{
port ProcPort1 Port0;
port ProcPort2 Port1[4];
port ExtProcPort Port2;
port CompileOnlyPort Port3;
port PortAddress Port4;
}
type component eComponent
{
port ExtProcPort ePort;
}
type component addressComponent
{
port PortAddress P;
}
type component ProcComponent3 {
port ProcPort3 pt;
}
function GetCall_behav1() runs on ProcComponent2 {
while(true) {
alt {
[]Port1.getcall(MyProcTemplate_any) {
Port1.reply(MyProcTemplate2 value true);
}
[]Port1.getcall(MyProc3Template_any) {
Port1.reply(MyProc3Template value 3.1415);
}
[]Port1.getcall(StopPTC) {
Port1.reply(StopPTC);
stop;
}
}
}
}
function GetCall_behav2() runs on ProcComponent {
while(true) {
alt {
[]Port0.getcall(MyProcTemplate2) {
Port0.raise(MyProc,integer:555);
}
[]Port0.getcall(MyProcTemplate_any) {
Port0.reply(MyProcTemplate value false);
}
[]Port0.getcall(MyProc2Template) {
Port0.reply(MyProc2Template);
}
[]Port0.getcall(StopPTC) {
Port0.reply(StopPTC);
stop;
}
}
}
}
function GetCall_behav3() runs on ProcComponent2 {
while(true) {
alt {
[]Port1.getcall(MyProcTemplate2) {
Port1.raise(MyProc,integer:272869);
}
[]Port1.getcall(MyProcTemplate_any) {
Port1.reply(MyProcTemplateP(22,"G",199.99) value false);
}
[]Port1.getcall(MyProc3Template_any) {
Port1.reply(MyProc3Template value 2.78);
}
[]Port1.getcall(StopPTC) {
Port1.reply(StopPTC);
stop;
}
}
}
}
function Check_getcall_behav() runs on ProcComponent2 {
while(true) {
alt {
[]Port1.check(getcall(MyProcTemplate2)) {
Port1.getcall;
Port1.reply(MyProcTemplate value true);
}
[]Port1.getcall(StopPTC) {
Port1.reply(StopPTC);
stop;
}
[]Port1.check(getcall) {
Port1.getcall;
Port1.reply(MyProcTemplate2 value false);
}
}
}
}
// parameters values
const integer c_CallParam := 10;
const integer c_ReplyParam := 19;
// error codes
template integer t_getCall_invalidValue := -1;
template integer t_getCall_timeout := -2;
function GetCallParameters_behav() runs on ProcComponent3 {
var integer x := 0;
timer t := 1.0;
t.start;
alt {
[] pt.getcall(MyProc6:{?}) -> param (x) {
if (c_CallParam == x) { pt.reply(MyProc6:{c_ReplyParam}); }
else { pt.reply(MyProc6:{t_getCall_invalidValue}); }
}
[] t.timeout { pt.reply(MyProc6:{t_getCall_timeout}); }
}
} }
}
unmap(self:P,system:P);
}
testcase Call_tc1() runs on ProcComponent { testcase tc_PortAddress_external_usage2() runs on addressComponent
/* Non-blocking calls */ system addressComponent {
var ProcComponent2 PC2; map(self:P,system:P);
var integer i:=0; P.call(MyProcTemplate,1.0) to valueof(MyAddress(321,68)) {
var boolean b:=false; []P.catch(MyProc,integer:389) from MyAddress(68,321) {
var float f:=0.0; setverdict(pass);
timer T:=1.0; }
PC2:=ProcComponent2.create; []P.catch(timeout) {
PC2.start(GetCall_behav1()); setverdict(fail);
connect(self:Port0,PC2:Port1);
T.start;
Port0.call(MyProcTemplate,nowait);
Port0.call(MyProc3Template,nowait);
while(i<2) {
alt {
[]Port0.getreply(MyProcTemplate2) -> value b {
if(i==0) {
if(b==true) {i:=1;}
else {setverdict(fail);stop;}
} else {
setverdict(inconc);stop;
}
}
[]Port0.getreply(MyProc3Template) -> value f {
if((i==1)and(f==3.1415)) {i:=2;}
else {log(f);setverdict(inconc);stop;}
}
[]T.timeout {
setverdict(fail);
stop;
}
}
}
if(i==2) {setverdict(pass);}
Port0.call(StopPTC,0.5) {
[]Port0.getreply(StopPTC) { }
[]Port0.catch(timeout) { }
}
disconnect(self:Port0,PC2:Port1);
}
testcase Call_tc2() runs on ProcComponent2 {
/* Blocking calls */
var ProcComponent PC;
var boolean b:=true;
PC:=ProcComponent.create;
PC.start(GetCall_behav2());
connect(self:Port1,PC:Port0);
Port1.call(MyProcTemplate,1.0) {
[]Port1.getreply(MyProcTemplate value ?) -> value b{
Port1.call(MyProc2Template,0.7) {
[]Port1.getreply(MyProc2Template) {
Port1.call(MyProcTemplate2,0.4) {
[]Port1.catch(MyProc,integer:555) {
if(b==false) {setverdict(pass);}
else {setverdict(inconc);}
}
[]Port1.catch(timeout) {
setverdict(fail);
stop;
}
}
}
[]Port1.catch(timeout) {
setverdict(fail);
stop;
}
}
}
[]Port1.catch(timeout) {
setverdict(fail);
stop;
}
}
Port1.call(StopPTC,0.5) {
[]Port1.getreply(StopPTC) { }
[]Port1.catch(timeout) { }
}
}
testcase extCall_tc1() runs on eComponent system eComponent {
map(self:ePort,system:ePort);
ePort.call(MyProc5TemplateP(128,32),0.5) {
[]ePort.getreply(MyProc5Template_any value 4.0) {
setverdict(pass);
}
[]ePort.catch(timeout) {
setverdict(fail);stop;
}
}
unmap(self:ePort,system:ePort);
}
testcase extCall_tc2() runs on eComponent system eComponent {
map(self:ePort,system:ePort);
ePort.call(MyProc5TemplateP(32,128),0.5) {
[]ePort.getreply(MyProc5Template_any value 0.25) {
setverdict(pass);
}
[]ePort.catch(timeout) {
setverdict(fail);stop;
}
}
unmap(self:ePort,system:ePort);
}
testcase extCall_tc3() runs on eComponent system eComponent {
map(self:ePort,system:ePort);
ePort.call(MyProc5TemplateP(128,0),0.5) {
[]ePort.catch(MyProc5,charstring:"Divide by 0.") {
setverdict(pass);
}
[]ePort.catch(timeout) {
setverdict(fail);stop;
}
}
unmap(self:ePort,system:ePort);
}
testcase Call_MultiPTC_tc() runs on ProcComponent {
/* procedure based communication with multiple PTCs */
var ProcComponent2 PC1,PC2;
var integer i:=0;
timer T:=1.0;
PC1:=ProcComponent2.create;
PC1.start(GetCall_behav1());
connect(self:Port0,PC1:Port1);
PC2:=ProcComponent2.create;
PC2.start(GetCall_behav3());
connect(self:Port0,PC2:Port1);
T.start;
Port0.call(MyProcTemplate,nowait) to PC1;
Port0.call(MyProc3Template,nowait) to PC2;
while(i<2) {
alt {
[]Port0.getreply(MyProcTemplate2 value true) from PC1 {
i:=i+1;
}
[]Port0.getreply(MyProc3Template value 2.78) from PC2 {
i:=i+1;
}
[]T.timeout {
setverdict(fail);stop;
}
}
}
setverdict(pass);
Port0.call(StopPTC,0.5) to PC1 {
[]Port0.getreply(StopPTC) from PC1 { }
[]Port0.catch(timeout) { setverdict(fail);stop; }
}
Port0.call(StopPTC,0.5) to PC2 {
[]Port0.getreply(StopPTC) from PC2 { }
[]Port0.catch(timeout) { setverdict(fail);stop; }
}
disconnect(self:Port0,PC1:Port1);
disconnect(self:Port0,PC2:Port1);
}
testcase Call_MultiPTC_anyport_tc() runs on ProcComponentMultiPort {
/* testing any-port operations with multiple PTCs */
var ProcComponent2 PC1,PC2;
var ProcComponent2 sndr;
var integer i:=0;
var boolean chk1:=true,chk2:=true;
timer T:=1.5;
PC1:=ProcComponent2.create;
PC1.start(GetCall_behav1());
connect(self:Port0,PC1:Port1);
PC2:=ProcComponent2.create;
PC2.start(GetCall_behav3());
connect(self:Port0,PC2:Port1);
T.start;
Port0.call(MyProcTemplate,nowait) to PC1;
Port0.call(MyProc3Template,nowait) to PC2;
while(i<4) {
alt {
[chk1]any port.check {
i:=i+1;
chk1:=false;
log("any port.check OK");
}
[chk2]any port.check(getreply -> sender sndr) {
i:=i+1;
chk2:=false;
log("any port.check(getreply) OK, sender: ",sndr);
}
[]any port.check(catch) {
log("any port.check(catch) matched --> fail");
setverdict(fail);stop;
}
[]any port.getcall {
log("any port.getcall matched --> fail");
setverdict(fail);stop;
}
[]any port.getreply from PC1 {
log("any port.getreply from PC1 OK");
i:=i+1;
}
[]any port.getreply from PC2 {
log("any port.getreply from PC2 OK");
i:=i+1;
}
[]T.timeout {
setverdict(fail);stop;
}
}
}
setverdict(pass);
Port0.call(StopPTC,0.5) to PC1 {
[]Port0.getreply(StopPTC) from PC1 { }
[]Port0.catch(timeout) { setverdict(fail);stop; }
}
Port0.call(StopPTC,0.5) to PC2 {
[]Port0.getreply(StopPTC) from PC2 { }
[]Port0.catch(timeout) { setverdict(fail);stop; }
}
disconnect(self:Port0,PC1:Port1);
disconnect(self:Port0,PC2:Port1);
}
testcase Check_tc1() runs on ProcComponent {
var ProcComponent2 PC2;
timer T:=1.5;
PC2:=ProcComponent2.create;
PC2.start(GetCall_behav3());
connect(self:Port0,PC2:Port1);
Port0.call(MyProcTemplate2,nowait);
T.start;
alt {
[]Port0.check(catch) { }
[]T.timeout {
setverdict(fail);
stop;
}
}
alt {
[]any port.check(catch) {
log("any port.check(catch) OK");
}
[]T.timeout {
setverdict(fail);
stop;
}
}
alt {
[]Port0.check(catch(MyProc,integer:272869)) {
Port0.catch;
}
[]T.timeout {
setverdict(fail);
stop;
}
}
Port0.call(MyProcTemplate,nowait);
alt {
[]Port0.check(getreply) { }
[]T.timeout {
setverdict(fail);
stop;
}
}
alt {
[]Port0.check(getreply(MyProcTemplateP(22,"G",199.99) value false)){
Port0.getreply;
setverdict(pass);
}
[]T.timeout {
setverdict(fail);
stop;
}
}
Port0.call(StopPTC,0.5) {
[]Port0.getreply(StopPTC) { }
[]Port0.catch(timeout) { }
}
}
testcase Check_tc2() runs on ProcComponent {
var ProcComponent2 PC2;
PC2:=ProcComponent2.create;
PC2.start(Check_getcall_behav());
connect(self:Port0,PC2:Port1);
Port0.call(MyProcTemplate2,1.0) {
[]Port0.getreply(MyProcTemplate value true) { }
[]Port0.catch(timeout) {
setverdict(fail);
stop;
}
}
Port0.call(MyProcTemplate,1.0) {
[]Port0.getreply(MyProcTemplate2 value false) {
setverdict(pass);
}
[]Port0.catch(timeout) {
setverdict(fail);
stop;
}
}
Port0.call(StopPTC,0.5) {
[]Port0.getreply(StopPTC) { }
[]Port0.catch(timeout) { }
}
}
testcase PortAddress_internal_usage() runs on ProcComponentMultiPort {
/* procedure based internal communication with address-supporting port */
var ProcComponent2 PC2;
var integer i:=0;
PC2:=ProcComponent2.create;
PC2.start(GetCall_behav3());
connect(self:Port4,PC2:Port1);
Port4.call(MyProcTemplateP(11,"T",99.012),1.0) {
[]Port4.getreply(MyProcTemplateP(22,"G",199.99) value false) {
i:=i+1;
}
[]Port4.catch(timeout) {
setverdict(fail);stop;
}
}
Port4.call(MyProcTemplate2,1.0) {
[]Port4.catch(MyProc,integer:272869) {
i:=i+1;
}
[]Port4.catch(timeout) {
setverdict(fail);stop;
}
}
if(i==2){setverdict(pass);}
Port4.call(StopPTC,1.0) {
[]Port4.getreply(StopPTC) { }
[]Port4.catch(timeout) {
setverdict(fail);
}
}
}
testcase PortAddress_external_usage1() runs on addressComponent
system addressComponent {
map(self:P,system:P);
P.call(MyProcTemplate,1.0) to valueof(MyAddress(321,67)) {
[]P.getreply(MyProcTemplate_any value true) from MyAddress(67,321) {
setverdict(pass);
}
[]P.catch(timeout) {
setverdict(fail);
}
}
unmap(self:P,system:P);
}
testcase PortAddress_external_usage2() runs on addressComponent
system addressComponent {
map(self:P,system:P);
P.call(MyProcTemplate,1.0) to valueof(MyAddress(321,68)) {
[]P.catch(MyProc,integer:389) from MyAddress(68,321) {
setverdict(pass);
}
[]P.catch(timeout) {
setverdict(fail);
}
}
unmap(self:P,system:P);
} }
}
unmap(self:P,system:P);
}
function signatureEncode(template MyProc par1, template MyProc par2) runs on addressComponent function signatureEncode(template MyProc par1, template MyProc par2) runs on addressComponent
{ {
log(par1, par2); log(par1, par2);
} }
// tests the 'param' directive in functions 'getcall' and 'getreply', // tests the 'param' directive in functions 'getcall' and 'getreply',
// specificly with signatures containing 'inout' parameters (HT93096) // specificly with signatures containing 'inout' parameters (HT93096)
testcase GetReplyParameters_tc() runs on ProcComponent3 { testcase tc_GetReplyParameters() runs on ProcComponent3 {
var ProcComponent3 c := ProcComponent3.create; var ProcComponent3 c := ProcComponent3.create;
connect(c:pt, self:pt); connect(c:pt, self:pt);
c.start(GetCallParameters_behav()); c.start(GetCallParameters_behav());
var integer x := 0; var integer x := 0;
pt.call(MyProc6:{c_CallParam}, 1.0) { pt.call(MyProc6:{c_CallParam}, 1.0) {
[] pt.getreply(MyProc6:{t_getCall_invalidValue}) { setverdict(fail, "invalid getcall parameter"); } [] pt.getreply(MyProc6:{t_getCall_invalidValue}) { setverdict(fail, "invalid getcall parameter"); }
[] pt.getreply(MyProc6:{t_getCall_timeout}) { setverdict(fail, "getcall timed out"); } [] pt.getreply(MyProc6:{t_getCall_timeout}) { setverdict(fail, "getcall timed out"); }
[] pt.getreply(MyProc6:{?}) -> param (x) { [] pt.getreply(MyProc6:{?}) -> param (x) {
if (c_ReplyParam == x) { setverdict(pass); } if (c_ReplyParam == x) { setverdict(pass); }
else { setverdict(fail, "invalid getreply parameter"); } else { setverdict(fail, "invalid getreply parameter"); }
} }
[] pt.catch(timeout) { setverdict(fail, "getreply timed out"); } [] pt.catch(timeout) { setverdict(fail, "getreply timed out"); }
} }
c.done; c.done;
} }
control { control {
execute(Call_tc1()); execute(tc1_Call());
execute(Call_tc2()); execute(tc2_Call());
execute(extCall_tc1()); execute(tc_extCall());
execute(extCall_tc2()); execute(tc_extCall_2());
execute(extCall_tc3()); execute(tc_extCall_3());
execute(Call_MultiPTC_tc()); execute(tc_Call_MultiPTC());
execute(Call_MultiPTC_anyport_tc()); execute(tc_Call_MultiPTC_anyport());
execute(Check_tc1()); execute(tc_Check_1());
execute(Check_tc2()); execute(tc_Check_2());
execute(PortAddress_internal_usage()); execute(tc_PortAddress_internal_usage());
execute(PortAddress_external_usage1()); execute(tc_PortAddress_external_usage1());
execute(PortAddress_external_usage2()); execute(tc_PortAddress_external_usage2());
execute(GetReplyParameters_tc()); execute(tc_GetReplyParameters());
} }
} }
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Copyright © Eclipse Foundation, Inc. All Rights Reserved.     Privacy Policy | Terms of Use | Copyright Agent