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