Commit | Line | Data |
---|---|---|
970ed795 EL |
1 | /****************************************************************************** |
2 | * Copyright (c) 2000-2014 Ericsson Telecom AB | |
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 | |
7 | ******************************************************************************/ | |
8 | module TboolOper | |
9 | {const boolean TboolOper_const1:=true; | |
10 | type component boolOper_comptype { }; | |
11 | ||
12 | testcase boolAssign() runs on boolOper_comptype | |
13 | { var boolean x1:=true; | |
14 | var boolean x4:=x1; | |
15 | var boolean x2,x3; | |
16 | x2:=false; | |
17 | x3:=x2; | |
18 | if (x1) {setverdict(pass);} //at declaration, value | |
19 | else {setverdict(fail);} | |
20 | if (x4) {setverdict(pass);} //at declaration, variable | |
21 | else {setverdict(fail);} | |
22 | if (not(x2)) {setverdict(pass);} //later, value | |
23 | else {setverdict(fail);} | |
24 | if (not(x3)) {setverdict(pass);} //later, variable | |
25 | else {setverdict(fail);} | |
26 | } | |
27 | ||
28 | testcase boolConst() runs on boolOper_comptype { | |
29 | const boolean TboolOper_const3:=false; | |
30 | if (TboolOper_const1) {setverdict(pass);} //definition part | |
31 | else {setverdict(fail);} | |
32 | //if (TboolOper_const2==2) {setverdict(pass);} //control part | |
33 | // else {setverdict(fail);} | |
34 | if (not(TboolOper_const3)) {setverdict(pass);} //testcase | |
35 | else {setverdict(fail);} | |
36 | } | |
37 | ||
38 | testcase boolCompEq() runs on boolOper_comptype | |
39 | { var boolean x1,x2,x3; | |
40 | x1:=true; | |
41 | x2:=true; | |
42 | x3:=false; | |
43 | if (x1==x2) {setverdict(pass);} //variable_variable | |
44 | else {setverdict(fail);} | |
45 | if (not(x3==x2)) {setverdict(pass);} //variable_variable | |
46 | else {setverdict(fail);} | |
47 | if (x1==true) {setverdict(pass);} //variable_value | |
48 | else {setverdict(fail);} | |
49 | if (not(x1==false)) {setverdict(pass);} //variable_value | |
50 | else {setverdict(fail);} | |
51 | if (true==x1) {setverdict(pass);} //value_variable | |
52 | else {setverdict(fail);} | |
53 | if (not(false==x1)) {setverdict(pass);} //value_variable | |
54 | else {setverdict(fail);} | |
55 | if (true==true) {setverdict(pass);} //value_value | |
56 | else {setverdict(fail);} | |
57 | if (not(true==false)) {setverdict(pass);} //value_value | |
58 | else {setverdict(fail);} | |
59 | } | |
60 | ||
61 | testcase boolCompNotEq() runs on boolOper_comptype | |
62 | { var boolean x1,x2,x3; | |
63 | x1:=true; | |
64 | x2:=false; | |
65 | x3:=true; | |
66 | if (x1!=x2) {setverdict(pass);} //variable_variable | |
67 | else {setverdict(fail);} | |
68 | if (not(x1!=x3)) {setverdict(pass);} //variable_variable | |
69 | else {setverdict(fail);} | |
70 | if (x1!=false) {setverdict(pass);} //variable_value | |
71 | else {setverdict(fail);} | |
72 | if (not(x1!=true)) {setverdict(pass);} //variable_value | |
73 | else {setverdict(fail);} | |
74 | if (true!=x2) {setverdict(pass);} //value_variable | |
75 | else {setverdict(fail);} | |
76 | if (not(false!=x2)) {setverdict(pass);} //value_variable | |
77 | else {setverdict(fail);} | |
78 | if (true!=false) {setverdict(pass);} //value_value | |
79 | else {setverdict(fail);} | |
80 | if (not(false!=false)) {setverdict(pass);} //value_value | |
81 | else {setverdict(fail);} | |
82 | } | |
83 | ||
84 | testcase boolNot() runs on boolOper_comptype | |
85 | { var boolean x1,x2,x3,x4,x5,x6; | |
86 | x1:=true; | |
87 | x2:=false; | |
88 | x3:=not(x1); | |
89 | x4:=not(x2); | |
90 | x5:=not(true); | |
91 | x6:=not(false); | |
92 | if (not(x3)) {setverdict(pass);} //variable | |
93 | else {setverdict(fail);} | |
94 | if (x4) {setverdict(pass);} //variable | |
95 | else {setverdict(fail);} | |
96 | if (not(x5)) {setverdict(pass);} //value | |
97 | else {setverdict(fail);} | |
98 | if (x6) {setverdict(pass);} //value | |
99 | else {setverdict(fail);} | |
100 | } | |
101 | ||
102 | testcase boolAnd() runs on boolOper_comptype | |
103 | { var boolean x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18; | |
104 | x1:=true; | |
105 | x2:=false; | |
106 | x3:=x1 and x1; | |
107 | x4:=x1 and x2; | |
108 | x5:=x2 and x1; | |
109 | x6:=x2 and x2; | |
110 | x7:=x1 and true; | |
111 | x8:=x1 and false; | |
112 | x9:=x2 and true; | |
113 | x10:=x2 and false; | |
114 | x11:=true and x1; | |
115 | x12:=true and x2; | |
116 | x13:=false and x1; | |
117 | x14:=false and x2; | |
118 | x15:=true and true; | |
119 | x16:=true and false; | |
120 | x17:=false and true; | |
121 | x18:=false and false; | |
122 | if (x3) {setverdict(pass);} //variable_variable | |
123 | else {setverdict(fail);} | |
124 | if (not(x4)) {setverdict(pass);} //variable_variable | |
125 | else {setverdict(fail);} | |
126 | if (not(x5)) {setverdict(pass);} //variable_variable | |
127 | else {setverdict(fail);} | |
128 | if (not(x6)) {setverdict(pass);} //variable_variable | |
129 | else {setverdict(fail);} | |
130 | if (x7) {setverdict(pass);} //variable_value | |
131 | else {setverdict(fail);} | |
132 | if (not(x8)) {setverdict(pass);} //variable_value | |
133 | else {setverdict(fail);} | |
134 | if (not(x9)) {setverdict(pass);} //variable_value | |
135 | else {setverdict(fail);} | |
136 | if (not(x10)) {setverdict(pass);} //variable_value | |
137 | else {setverdict(fail);} | |
138 | if (x11) {setverdict(pass);} //value_variable | |
139 | else {setverdict(fail);} | |
140 | if (not(x12)) {setverdict(pass);} //value_variable | |
141 | else {setverdict(fail);} | |
142 | if (not(x13)) {setverdict(pass);} //value_variable | |
143 | else {setverdict(fail);} | |
144 | if (not(x14)) {setverdict(pass);} //value_variable | |
145 | else {setverdict(fail);} | |
146 | if (x15) {setverdict(pass);} //value_value | |
147 | else {setverdict(fail);} | |
148 | if (not(x16)) {setverdict(pass);} //value_value | |
149 | else {setverdict(fail);} | |
150 | if (not(x17)) {setverdict(pass);} //value_value | |
151 | else {setverdict(fail);} | |
152 | if (not(x18)) {setverdict(pass);} //value_value | |
153 | else {setverdict(fail);} | |
154 | } | |
155 | ||
156 | testcase boolOr() runs on boolOper_comptype | |
157 | { var boolean x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18; | |
158 | x1:=true; | |
159 | x2:=false; | |
160 | x3:=x1 or x1; | |
161 | x4:=x1 or x2; | |
162 | x5:=x2 or x1; | |
163 | x6:=x2 or x2; | |
164 | x7:=x1 or true; | |
165 | x8:=x1 or false; | |
166 | x9:=x2 or true; | |
167 | x10:=x2 or false; | |
168 | x11:=true or x1; | |
169 | x12:=true or x2; | |
170 | x13:=false or x1; | |
171 | x14:=false or x2; | |
172 | x15:=true or true; | |
173 | x16:=true or false; | |
174 | x17:=false or true; | |
175 | x18:=false or false; | |
176 | if (x3) {setverdict(pass);} //variable_variable | |
177 | else {setverdict(fail);} | |
178 | if (x4) {setverdict(pass);} //variable_variable | |
179 | else {setverdict(fail);} | |
180 | if (x5) {setverdict(pass);} //variable_variable | |
181 | else {setverdict(fail);} | |
182 | if (not(x6)) {setverdict(pass);} //variable_variable | |
183 | else {setverdict(fail);} | |
184 | if (x7) {setverdict(pass);} //variable_value | |
185 | else {setverdict(fail);} | |
186 | if (x8) {setverdict(pass);} //variable_value | |
187 | else {setverdict(fail);} | |
188 | if (x9) {setverdict(pass);} //variable_value | |
189 | else {setverdict(fail);} | |
190 | if (not(x10)) {setverdict(pass);} //variable_value | |
191 | else {setverdict(fail);} | |
192 | if (x11) {setverdict(pass);} //value_variable | |
193 | else {setverdict(fail);} | |
194 | if (x12) {setverdict(pass);} //value_variable | |
195 | else {setverdict(fail);} | |
196 | if (x13) {setverdict(pass);} //value_variable | |
197 | else {setverdict(fail);} | |
198 | if (not(x14)) {setverdict(pass);} //value_variable | |
199 | else {setverdict(fail);} | |
200 | if (x15) {setverdict(pass);} //value_value | |
201 | else {setverdict(fail);} | |
202 | if (x16) {setverdict(pass);} //value_value | |
203 | else {setverdict(fail);} | |
204 | if (x17) {setverdict(pass);} //value_value | |
205 | else {setverdict(fail);} | |
206 | if (not(x18)) {setverdict(pass);} //value_value | |
207 | else {setverdict(fail);} | |
208 | } | |
209 | ||
210 | testcase boolXor() runs on boolOper_comptype | |
211 | { var boolean x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18; | |
212 | x1:=true; | |
213 | x2:=false; | |
214 | x3:=x1 xor x1; | |
215 | x4:=x1 xor x2; | |
216 | x5:=x2 xor x1; | |
217 | x6:=x2 xor x2; | |
218 | x7:=x1 xor true; | |
219 | x8:=x1 xor false; | |
220 | x9:=x2 xor true; | |
221 | x10:=x2 xor false; | |
222 | x11:=true xor x1; | |
223 | x12:=true xor x2; | |
224 | x13:=false xor x1; | |
225 | x14:=false xor x2; | |
226 | x15:=true xor true; | |
227 | x16:=true xor false; | |
228 | x17:=false xor true; | |
229 | x18:=false xor false; | |
230 | if (not(x3)) {setverdict(pass);} //variable_variable | |
231 | else {setverdict(fail);} | |
232 | if (x4) {setverdict(pass);} //variable_variable | |
233 | else {setverdict(fail);} | |
234 | if (x5) {setverdict(pass);} //variable_variable | |
235 | else {setverdict(fail);} | |
236 | if (not(x6)) {setverdict(pass);} //variable_variable | |
237 | else {setverdict(fail);} | |
238 | if (not(x7)) {setverdict(pass);} //variable_value | |
239 | else {setverdict(fail);} | |
240 | if (x8) {setverdict(pass);} //variable_value | |
241 | else {setverdict(fail);} | |
242 | if (x9) {setverdict(pass);} //variable_value | |
243 | else {setverdict(fail);} | |
244 | if (not(x10)) {setverdict(pass);} //variable_value | |
245 | else {setverdict(fail);} | |
246 | if (not(x11)) {setverdict(pass);} //value_variable | |
247 | else {setverdict(fail);} | |
248 | if (x12) {setverdict(pass);} //value_variable | |
249 | else {setverdict(fail);} | |
250 | if (x13) {setverdict(pass);} //value_variable | |
251 | else {setverdict(fail);} | |
252 | if (not(x14)) {setverdict(pass);} //value_variable | |
253 | else {setverdict(fail);} | |
254 | if (not(x15)) {setverdict(pass);} //value_value | |
255 | else {setverdict(fail);} | |
256 | if (x16) {setverdict(pass);} //value_value | |
257 | else {setverdict(fail);} | |
258 | if (x17) {setverdict(pass);} //value_value | |
259 | else {setverdict(fail);} | |
260 | if (not(x18)) {setverdict(pass);} //value_value | |
261 | else {setverdict(fail);} | |
262 | } | |
263 | ||
264 | type boolean myb1 | |
265 | type boolean myb2 (true) | |
266 | type boolean myb3 (false) | |
267 | // FATAL_ERROR() with R8B: `type boolean myb3 (true, valueof(t_myb1))'. | |
268 | type boolean myb4 (c_myb1, not c_myb1 and c_myb1) | |
269 | type myb3 myb5 | |
270 | type boolean myb6 (myb2, myb3) | |
271 | ||
272 | const boolean c_myb1 := true | |
273 | const myb6 c_myb2 := c_myb1 | |
274 | ||
275 | template boolean t_myb1 := true | |
276 | template myb6 t_myb2 := t_myb1 | |
277 | ||
278 | function f_b1(in boolean p1) return boolean { return p1 } | |
279 | ||
280 | function f_b2() return myb4 { | |
281 | var template boolean vt_myb1 := t_myb1 | |
282 | if (valueof(t_myb1) and valueof(vt_myb1)) { return true } | |
283 | else { return false } | |
284 | } | |
285 | ||
286 | function f_b3() return myb4 { | |
287 | var myb4 v_myb1 := false | |
288 | var template myb4 vt_myb1 := c_myb1 | |
289 | if (not v_myb1 and valueof(vt_myb1) == true) { return true } | |
290 | else { return false } | |
291 | } | |
292 | ||
293 | testcase boolSubtypes() runs on boolOper_comptype { | |
294 | if (f_b1(c_myb1) == f_b2()) { setverdict(pass) } | |
295 | else { setverdict(fail) } | |
296 | } | |
297 | ||
298 | testcase boolIsvalue() runs on boolOper_comptype{ | |
299 | var template boolean vt0; | |
300 | var template boolean vt1 := ( true, true, true ); | |
301 | ||
302 | if ( isvalue(vt0) ) { setverdict(fail); } else { setverdict(pass); }; | |
303 | if ( isvalue(vt1) ) { setverdict(fail); } else { setverdict(pass); }; | |
304 | } | |
305 | ||
a38c6d4c | 306 | type union TestUnion { |
307 | integer t, | |
308 | boolean b | |
309 | } | |
310 | ||
311 | type record TestRecord { | |
312 | integer t, | |
313 | boolean b optional | |
314 | } | |
315 | ||
316 | // for TR fix HT60781 | |
317 | testcase boolShortCircuit() runs on boolOper_comptype { | |
318 | // create a union variable, make sure the boolean field is not chosen | |
319 | var TestUnion myUnion := { t := 1 }; | |
320 | ||
321 | // reference the boolean field in the 2nd part of a condition using 'and' or 'or' | |
322 | // only the first part of the condition should be evaluated, since | |
323 | // evaluating the 2nd part would produce a DTE (because the field isn't chosen) | |
324 | if (ischosen(myUnion.b) and myUnion.b) { | |
325 | setverdict(fail, "Error in 'if' condition, field 'b' is not supposed to be chosen"); | |
326 | } | |
327 | while (ischosen(myUnion.b) and myUnion.b) { | |
328 | setverdict(fail, "Error in 'while' condition, field 'b' is not supposed to be chosen"); | |
329 | } | |
330 | var integer i; | |
331 | for (i := 0; ischosen(myUnion.b) and myUnion.b and i < 5; i := i + 1) { | |
332 | setverdict(fail, "Error in 'for' condition, field 'b' is not supposed to be chosen"); | |
333 | } | |
334 | var boolean res := not ischosen(myUnion.b) or myUnion.b; | |
335 | if (not res) { | |
336 | setverdict(fail, "Error in boolean assignment, field 'b' is not supposed to be chosen"); | |
337 | } | |
338 | ||
339 | // create a record variable, make sure the boolean field is omitted | |
340 | var TestRecord myRec := { t := 1, b := omit }; | |
341 | ||
342 | // reference the boolean field in the 2nd part of a condition, same as with the union field | |
343 | // (referencing the boolean field would cause a DTE again, because it is omitted) | |
344 | if (ispresent(myRec.b) and myRec.b) { | |
345 | setverdict(fail, "Error in 'if' condition, field 'b' is not supposed to be present"); | |
346 | } | |
347 | while (ispresent(myRec.b) and myRec.b) { | |
348 | setverdict(fail, "Error in 'if' condition, field 'b' is not supposed to be present"); | |
349 | } | |
350 | for (i := 0; ispresent(myRec.b) and myRec.b and i < 5; i := i + 1) { | |
351 | setverdict(fail, "Error in 'for' condition, field 'b' is not supposed to be present"); | |
352 | } | |
353 | res := not ispresent(myRec.b) or myRec.b; | |
354 | if (not res) { | |
355 | setverdict(fail, "Error in boolean assignment, field 'b' is not supposed to be present"); | |
356 | } | |
357 | setverdict(pass); | |
358 | } | |
359 | ||
970ed795 EL |
360 | control { |
361 | const boolean cl_1:=true; | |
362 | var boolean vl_1; | |
363 | ||
364 | execute(boolAssign()); | |
365 | execute(boolConst()); | |
366 | execute(boolCompEq()); | |
367 | execute(boolCompNotEq()); | |
368 | execute(boolNot()); | |
369 | execute(boolAnd()); | |
370 | execute(boolOr()); | |
371 | execute(boolXor()); | |
372 | execute(boolSubtypes()); | |
373 | execute(boolIsvalue()); | |
a38c6d4c | 374 | execute(boolShortCircuit()); |
970ed795 EL |
375 | } |
376 | ||
377 | } |