1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
|
/******************************************************************************
* Copyright (c) 2000-2021 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
*
* Contributors:
* Balasko, Jeno
* Baranyi, Botond
* Gecse, Roland
* Harai, Tibor
* Kovacs, Ferenc
* Raduly, Csaba
* Szabo, Janos Zoltan – initial implementation
*
******************************************************************************/
module TbasicStatem {
type component basicStatem_mycomp {};
testcase basicStatemIf() runs on basicStatem_mycomp {
// literal constants in the expression
if (true) {setverdict(pass)}
else {setverdict(fail)}
if (false) {setverdict(fail)}
else {setverdict(pass)}
// variable references in the expression
var boolean b := true;
if (b) {setverdict(pass)}
else {setverdict(fail)}
b := false;
if (b) {setverdict(fail)}
else {setverdict(pass)}
}
testcase basicStatemElseIf() runs on basicStatem_mycomp {
// literal constants in the expressions
if (false) {setverdict(fail)}
else if (false) {setverdict(fail)}
else {setverdict(pass)}
if (false) {setverdict(fail)}
else if (true) {setverdict(pass)}
else {setverdict(fail)}
if (true) {setverdict(pass)}
else if (false) {setverdict(fail)}
else {setverdict(fail)}
// variable references in the expressions
var boolean b1 := false, b2 := false;
if (b1) {setverdict(fail)}
else if (b2) {setverdict(fail)}
else {setverdict(pass)}
b2 := true;
if (b1) {setverdict(fail)}
else if (b2) {setverdict(pass)}
else {setverdict(fail)}
b1 := true;
if (b1) {setverdict(pass)}
else if (b2) {setverdict(fail)}
else {setverdict(fail)}
}
type record address { integer filed }
testcase basicStatemSelectCase() runs on basicStatem_mycomp {
var bitstring bit1, bit2;
bit1:='1001'B;
bit2:='11001'B;
select (bit1) {
case ('11'B,'101000101'B) { setverdict(fail); }
case ('1001'B,bit2,'10'B) { setverdict(pass); }
case else { setverdict(inconc); }
}
var boolean boo1, boo2;
boo1:=false;
boo2:=true;
select (boo1) {
case (true,boo2) { setverdict(fail); }
case (false) { setverdict(pass); }
case else { setverdict(inconc); }
}
var charstring char1, char2;
char1:="A";
char2:="cvs";
select (char1) {
case ("lkjsd",char2) { setverdict(fail); }
case ("ff","C","A") { setverdict(pass); }
case else { setverdict(inconc); }
}
var universal charstring uchar1, uchar2;
uchar1:=char(0,0,1,113);
uchar2:=char(0,0,0,129);
select (uchar1) {
case (uchar2,char(0,0,0,67)) { setverdict(fail); }
case (char(0,0,0,69),char(0,0,0,68),char(0,0,1,113)) { setverdict(pass); }
case else { setverdict(inconc); }
}
var integer int1, int2;
int1:= 4;
int2:= 7;
select (int1) {
case (3,0) { setverdict(fail); }
case (11,int2,4) { setverdict(pass); }
case else { setverdict(inconc); }
}
select (int1 + int2) {
case (3,0) { setverdict(fail); }
case (11,4) { setverdict(pass); }
case else { setverdict(inconc); }
}
select (int1 + int2) {
case (3,0) { setverdict(fail); }
case (3) { setverdict(fail); }
case (0,3) { setverdict(fail); }
case (0,4) { setverdict(fail); }
case (99999999999999999999999999999999999) { setverdict(fail); }
case (11,4) { setverdict(pass); }
case else { setverdict(inconc); }
case else { setverdict(inconc); }
}
select (int1 + int2) {
case (3,0) { setverdict(fail); }
case (3) { setverdict(fail); }
case (0,3) { setverdict(fail); }
case (0,4) { setverdict(fail); }
case (11,4) { setverdict(pass); }
case else { setverdict(inconc); }
}
var octetstring octet1, octet2;
octet1:= 'A9'O;
octet2:= '1267FD'O;
select (octet1) {
case ('FF'O,'A9'O,octet2) { setverdict(pass); }
case ('067B'O,'FA'O) { setverdict(fail); }
case else { setverdict(inconc); }
}
var hexstring hex1, hex2;
hex1:= '12C'H;
hex2:= 'A778F'H;
select (hex1) {
case ('D'H,'AA'H) { setverdict(fail); }
case (hex2,'12C'H,'3'H) { setverdict(pass); }
case else { setverdict(inconc); }
}
var verdicttype verd1, verd2;
verd1:= none;
verd2:= error;
select (verd1) {
case (pass,fail) { setverdict(fail); }
case (verd2,none,inconc) { setverdict(pass); }
case else { setverdict(inconc); }
}
var float float1, float2;
float1:= 2.3;
float2:= 7.89;
select (float1) {
case (float2,0.4) { setverdict(fail); }
case (2.31,7.0,2.29) { setverdict(inconc); }
case else { setverdict(pass); }
}
var address v_add1 := {23};
var address v_add2 := {47};
select (v_add1) {
case ({56},v_add2) { setverdict(fail); }
case ({4},{23},{234}) { setverdict(pass); }
case else { setverdict(inconc); }
}
}
testcase basicStatemFor() runs on basicStatem_mycomp {
var integer i,x1,x2;
x1:=0;
x2:=0;
for (i:=1;i<=10;i:=i+1) {x1:=x1+1};
for (var integer j:=1;j<1000;j:=j*2) {x2:=x2+2;}
if (x1==10) {setverdict(pass);} // index variable declared separately
else {setverdict(fail);}
if (x2==20) {setverdict(pass);} // index variable declared in the loop
else {setverdict(fail);}
}
testcase basicStatemWhile() runs on basicStatem_mycomp {
var integer i,x1,x2;
x1:=0;
x2:=0;
i:=1;
while (i<=10) {i:=i+1; x1:=x1+1};
i:=1
while (i<=0) {i:=i+1; x2:=x2+1};
if (x1==10) {setverdict(pass)}
else {setverdict(fail)};
if (x2==0) {setverdict(pass)} // zero-sized loop
else {setverdict(fail)};
}
testcase basicStatemDoWhile() runs on basicStatem_mycomp {
var integer i,x1,x2;
x1:=0;
x2:=0;
i:=1;
do {i:=i+1; x1:=x1+1} while (i<=10);
i:=1;
do {i:=i+1; x2:=x2+1} while (i<=0);
if (x1==10) {setverdict(pass)}
else {setverdict(fail)};
if (x2==1) {setverdict(pass)} // "zero-sized" loop
else {setverdict(fail)};
}
testcase basicStatemLabelGoto1() runs on basicStatem_mycomp {
goto L1; // forward
setverdict(fail);
label L1;
setverdict(pass);
}
testcase basicStatemLabelGoto2() runs on basicStatem_mycomp {
var integer x;
x:=0
label L1; // backward
x:=x+1;
if (x==2) {setverdict(pass)}
else { goto L1};
}
testcase basicStatemStop() runs on basicStatem_mycomp {
setverdict(pass);
stop;
setverdict(fail);
}
function f_aliasValue(integer par1, in integer par2, out integer par3,
inout integer par4, template integer par5)
{
// all parameters should be zero, par3 is inaccessible yet
if (par1 == 0 and par2 == 0 and par4 == 0 and valueof(par5) == 0)
{ setverdict(pass); }
else { setverdict(fail); }
par3 := 1;
// par3 and par4 should change to one, the rest should remain zero
if (par1 == 0 and par2 == 0 and par3 == 1 and par4 == 1 and
valueof(par5) == 0) { setverdict(pass); }
else { setverdict(fail); }
par1 := 2;
// nothing except par1 should change
if (par1 == 2 and par2 == 0 and par3 == 1 and par4 == 1 and
valueof(par5) == 0) { setverdict(pass); }
else { setverdict(fail); }
}
function f_aliasTemplate(template integer par1, in template integer par2,
out template integer par3, inout template integer par4, integer par5)
{
if (valueof(par1) == 0 and valueof(par2) == 0 and valueof(par4) == 0 and
par5 == 0) { setverdict(pass); }
else { setverdict(fail); }
par3 := 1;
if (valueof(par1) == 0 and valueof(par2) == 0 and valueof(par3) == 1 and
valueof(par4) == 1 and par5 == 0) { setverdict(pass); }
else { setverdict(fail); }
par1 := 2;
if (valueof(par1) == 2 and valueof(par2) == 0 and valueof(par3) == 1 and
valueof(par4) == 1 and par5 == 0) { setverdict(pass); }
else { setverdict(fail); }
}
testcase basicStatemfunctionCallAlias() runs on basicStatem_mycomp
{
var integer i := 0;
f_aliasValue(i, i, i, i, i);
if (i == 1) { setverdict(pass); }
else { setverdict(fail); }
var template integer j := 0;
f_aliasTemplate(j, j, j, j, valueof(j));
if (valueof(j) == 1) { setverdict(pass); }
else { setverdict(fail); }
}
type record r_empty { }
type set s_empty { }
type record of r_empty ro_empty
type set of s_empty so_empty
type union u_empty { ro_empty f1, so_empty f2 }
type anytype a_empty
type enumerated e_empty { f1, f2 }
type component c_HM79493
{
var integer i; var template integer it
var float f; var template float ft
var boolean b; var template boolean bt
var verdicttype v; var template verdicttype vt
var bitstring bs; var template bitstring bst
var hexstring hs; var template hexstring hst
var octetstring os; var template octetstring ost
var charstring cs; var template charstring cst
var universal charstring ucs; var template universal charstring ucst
var c_HM79493 c; var template c_HM79493 ct
var r_empty r; var template r_empty rt
var s_empty s; var template s_empty st
var ro_empty ro; var template ro_empty rot
var so_empty so; var template so_empty sot
var u_empty u; var template u_empty ut
var a_empty a; var template a_empty at
var e_empty e; var template e_empty et
// HQ19911: uncomment and watch the DTE
// var template ro_empty tro := { permutation({}) }
}
testcase tc_HM79493_set() runs on c_HM79493
{
i := 100; it := 100
f := 100.0; ft := 100.0
b := true; bt := true
v := pass; vt := pass
bs := '00'B; bst := '00'B
hs := '00'H; hst := '00'H
os := '00'O; ost := '00'O
cs := "00"; cst := "00"
ucs := char(0, 0, 0, 0); ucst := char(0, 0, 0, 0)
c := self; ct := self
r := { }; rt := { }
s := { }; st := { }
ro := { }; rot := { }
so := { }; sot := { }
u := { f1 := { } }; ut := { f1 := { } }
a := { u_empty := { f1 := { } } }; at := { u_empty := { f1 := { } } }
e := f1; et := f1
setverdict(pass)
}
testcase tc_HM79493_check() runs on c_HM79493
{
if (log2str(i) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(it) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(f) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(ft) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(b) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(bt) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(v) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(vt) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(bs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(bst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(hs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(hst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(os) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(ost) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(cs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(cst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(ucs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(ucst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(c) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(ct) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(r) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(rt) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(s) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(st) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(ro) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(rot) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(so) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(sot) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(u) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(ut) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(a) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(at) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(e) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
if (log2str(et) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
}
control {
execute(basicStatemIf());
execute(basicStatemElseIf());
execute(basicStatemSelectCase());
execute(basicStatemFor());
execute(basicStatemWhile());
execute(basicStatemDoWhile());
execute(basicStatemLabelGoto1());
execute(basicStatemLabelGoto2());
execute(basicStatemStop());
//execute(basicStatemfunctionCallAlias());
execute(tc_HM79493_set()); // Set component variables/variable templates.
execute(tc_HM79493_check()); // All component variables/variable templates must be unbound.
}
} with { extension "anytype u_empty" }
|
