Commit | Line | Data |
---|---|---|
970ed795 | 1 | /****************************************************************************** |
3abe9331 | 2 | * Copyright (c) 2000-2015 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 | |
7 | ******************************************************************************/ | |
8 | module TverdictOper | |
9 | { type component verdictOper_mycomp {}; | |
10 | const verdicttype verdictOper_const1:=fail; | |
11 | ||
12 | testcase verdictAssign() runs on verdictOper_mycomp { | |
13 | var verdicttype x1:=inconc; | |
14 | var verdicttype x2; | |
15 | x2:=pass; | |
16 | if (x1==inconc) {setverdict(pass);} //at declaration | |
17 | else {setverdict(fail);} | |
18 | if (x2==pass) {setverdict(pass);} //later | |
19 | else {setverdict(fail);} | |
20 | } | |
21 | ||
22 | testcase verdictConst() runs on verdictOper_mycomp { | |
23 | const verdicttype const1:=inconc; | |
24 | if (verdictOper_const1==fail) {setverdict(pass);} //definition part declaration | |
25 | else {setverdict(fail);} | |
26 | if (const1==inconc) {setverdict(pass);} //testcase | |
27 | else {setverdict(fail);} | |
28 | } | |
29 | ||
30 | ||
31 | testcase verdictCompEq() runs on verdictOper_mycomp { | |
32 | var verdicttype x1,x2,x3; | |
33 | x1:=pass; | |
34 | x2:=pass; | |
35 | x3:=inconc; | |
36 | if (x1==x2) {setverdict(pass);} //variable_variable | |
37 | else {setverdict(fail);} | |
38 | if (not(x3==x2)) {setverdict(pass);} //variable_variable | |
39 | else {setverdict(fail);} | |
40 | if (x1==pass) {setverdict(pass);} //variable_value | |
41 | else {setverdict(fail);} | |
42 | if (not(x1==fail)) {setverdict(pass);} //variable_value | |
43 | else {setverdict(fail);} | |
44 | if (pass==x1) {setverdict(pass);} //value_variable | |
45 | else {setverdict(fail);} | |
46 | if (not(inconc==x1)) {setverdict(pass);} //value_variable | |
47 | else {setverdict(fail);} | |
48 | if (pass==pass) {setverdict(pass);} //value_value | |
49 | else {setverdict(fail);} | |
50 | if (not(pass==fail)) {setverdict(pass);} //value_value | |
51 | else {setverdict(fail);} | |
52 | } | |
53 | ||
54 | testcase verdictCompNotEq() runs on verdictOper_mycomp | |
55 | { var verdicttype x1,x2,x3; | |
56 | x1:=pass; | |
57 | x2:=fail; | |
58 | x3:=pass; | |
59 | if (x1!=x2) {setverdict(pass);} //variable_variable | |
60 | else {setverdict(fail);} | |
61 | if (not(x1!=x3)) {setverdict(pass);} //variable_variable | |
62 | else {setverdict(fail);} | |
63 | if (x1!=fail) {setverdict(pass);} //variable_value | |
64 | else {setverdict(fail);} | |
65 | if (not(x1!=pass)) {setverdict(pass);} //variable_value | |
66 | else {setverdict(fail);} | |
67 | if (pass!=x2) {setverdict(pass);} //value_variable | |
68 | else {setverdict(fail);} | |
69 | if (not(fail!=x2)) {setverdict(pass);} //value_variable | |
70 | else {setverdict(fail);} | |
71 | if (inconc!=fail) {setverdict(pass);} //value_value | |
72 | else {setverdict(fail);} | |
73 | if (not(pass!=pass)) {setverdict(pass);} //value_value | |
74 | else {setverdict(fail);} | |
75 | } | |
76 | ||
77 | testcase verdictSetGet() runs on verdictOper_mycomp { | |
78 | var verdicttype x1; | |
79 | if (getverdict != none) { setverdict(fail); stop; } | |
80 | setverdict(pass); | |
81 | x1 := getverdict; | |
82 | if (x1 != pass) { setverdict(fail); stop; } | |
83 | } | |
84 | ||
85 | testcase verdictSet_None() runs on verdictOper_mycomp { | |
86 | // do nothing | |
87 | } | |
88 | ||
89 | testcase verdictSet_n_None() runs on verdictOper_mycomp { | |
90 | setverdict(none); | |
91 | } | |
92 | ||
93 | testcase verdictSet_p_Pass() runs on verdictOper_mycomp { | |
94 | setverdict(pass); | |
95 | } | |
96 | ||
97 | testcase verdictSet_i_Inconc() runs on verdictOper_mycomp { | |
98 | setverdict(inconc); | |
99 | } | |
100 | ||
101 | testcase verdictSet_f_Fail() runs on verdictOper_mycomp { | |
102 | setverdict(fail, "fail alone is fail"); | |
103 | } | |
104 | ||
105 | testcase verdictSet_p_i_Inconc() runs on verdictOper_mycomp { | |
106 | setverdict(pass); | |
107 | setverdict(inconc); | |
108 | } | |
109 | ||
110 | testcase verdictSet_p_f_Fail() runs on verdictOper_mycomp { | |
111 | setverdict(pass); | |
112 | setverdict(fail, "fail after pass is fail"); | |
113 | } | |
114 | ||
115 | testcase verdictSet_p_n_Pass() runs on verdictOper_mycomp { | |
116 | setverdict(pass); | |
117 | setverdict(none); | |
118 | } | |
119 | ||
120 | testcase verdictSet_i_p_Inconc() runs on verdictOper_mycomp { | |
121 | setverdict(inconc); | |
122 | setverdict(pass); | |
123 | } | |
124 | ||
125 | testcase verdictSet_i_f_Fail() runs on verdictOper_mycomp { | |
126 | setverdict(inconc); | |
127 | setverdict(fail); | |
128 | } | |
129 | ||
130 | testcase verdictSet_i_n_Inconc() runs on verdictOper_mycomp { | |
131 | setverdict(inconc); | |
132 | setverdict(none); | |
133 | } | |
134 | ||
135 | testcase verdictSet_f_p_Fail() runs on verdictOper_mycomp { | |
136 | setverdict(fail); | |
137 | setverdict(pass, "pass after fail is still fail"); | |
138 | } | |
139 | ||
140 | testcase verdictSet_f_i_Fail() runs on verdictOper_mycomp { | |
141 | setverdict(fail); | |
142 | setverdict(inconc); | |
143 | } | |
144 | ||
145 | testcase verdictSet_f_n_Fail() runs on verdictOper_mycomp { | |
146 | setverdict(fail); | |
147 | setverdict(none); | |
148 | } | |
149 | ||
150 | testcase verdictSet_n_p_Pass() runs on verdictOper_mycomp { | |
151 | setverdict(none); | |
152 | setverdict(pass); | |
153 | } | |
154 | ||
155 | testcase verdictSet_n_i_Inconc() runs on verdictOper_mycomp { | |
156 | setverdict(none); | |
157 | setverdict(inconc); | |
158 | } | |
159 | ||
160 | testcase verdictSet_n_f_Fail() runs on verdictOper_mycomp { | |
161 | setverdict(none); | |
162 | setverdict(fail); | |
163 | } | |
164 | ||
165 | /*--- VERDICT REASON -----------------------------------------------*/ | |
166 | ||
167 | modulepar octetstring VR_mp := '12353425'O; | |
168 | const float VR_fl := 1.0; | |
169 | type record VR_rec { | |
170 | integer i, | |
171 | boolean b | |
172 | } | |
173 | ||
174 | testcase verdict_reason() runs on verdictOper_mycomp { | |
175 | ||
176 | template VR_rec VR_tmpl := { i := 1235, b := true}; | |
177 | var integer VR_int := 5; | |
178 | var boolean VR_bool; | |
179 | timer VR_timer := 5.0; | |
180 | VR_timer.start; | |
181 | ||
182 | setverdict(pass, "Module parameter identifier: ", VR_mp); | |
183 | setverdict(pass, "Literal value: ", "this is the value"); | |
184 | setverdict(pass, "Data constant identifier: ", VR_fl); | |
185 | setverdict(pass, "Template instance: ", VR_tmpl); | |
186 | setverdict(pass, "Data type variable identifier: ", VR_int); | |
187 | setverdict(pass, "Uninitialized data type variable identifier: ", VR_bool); | |
188 | setverdict(pass, "self component type variable identifier: ", self); | |
189 | setverdict(pass, "mtc component type variable identifier: ", mtc); | |
190 | setverdict(pass, "system component type variable identifier: ", system); | |
191 | setverdict(pass, "Timer running operation: ", VR_timer.running); | |
192 | setverdict(pass, "Timer name: ", VR_timer); | |
193 | setverdict(pass, "Getverdict operation: ", getverdict); | |
194 | setverdict(pass, "More parameters: ", getverdict, system, self, VR_tmpl, VR_mp, "and this is the and of all logging..."); | |
195 | setverdict(pass); | |
196 | } | |
197 | ||
198 | type verdicttype typedefbasic_myverdt; | |
199 | type verdicttype myv1 (pass, fail, none, inconc) | |
200 | type myv1 myv2 | |
201 | type verdicttype myv3 (error) | |
202 | type verdicttype myv4 (myv1, myv3) | |
203 | const myv1 c_myv1 := pass | |
204 | const myv4 c_myv2 := none | |
205 | template myv1 t_myv1 := f_v1() | |
206 | template myv1 t_myv2 := f_v2() | |
207 | template myv4 t_myv3 := fail | |
208 | ||
209 | modulepar myv1 mod1 := c_myv1 | |
210 | ||
211 | function f_v1() return myv1 { return inconc } | |
212 | function f_v2() return myv1 { return c_myv1 } | |
213 | ||
214 | testcase verdictSubtypes() runs on verdictOper_mycomp { | |
215 | if (pass == mod1 and mod1 == pass and f_v1() != f_v2()) { setverdict(pass) } | |
216 | else { setverdict(fail) } | |
217 | var template myv3 vt_v1 := error | |
218 | var myv3 v_v1 := valueof(vt_v1) | |
219 | if (error == v_v1 and match(error, vt_v1)) { setverdict(pass) } | |
220 | else { setverdict(fail) } | |
221 | } | |
222 | ||
223 | testcase verdictIsbound() runs on verdictOper_mycomp { | |
224 | var verdicttype v0; | |
225 | var verdicttype v1 := pass; | |
226 | if ( isvalue(v0) ) { setverdict(fail); } else { setverdict(pass); }; | |
227 | if ( isvalue(v1) ) { setverdict(pass); } else { setverdict(fail); }; | |
228 | } | |
229 | ||
230 | control{ | |
231 | var integer fault_count := 0; | |
232 | if (execute(verdictAssign()) != pass) { | |
233 | log("Test case verdictAssign has unexpected verdict."); | |
234 | fault_count := fault_count + 1; | |
235 | } | |
236 | if (execute(verdictConst()) != pass) { | |
237 | log("Test case verdictConst has unexpected verdict."); | |
238 | fault_count := fault_count + 1; | |
239 | } | |
240 | if (execute(verdictCompEq()) != pass) { | |
241 | log("Test case verdictCompEq has unexpected verdict."); | |
242 | fault_count := fault_count + 1; | |
243 | } | |
244 | if (execute(verdictCompNotEq()) != pass) { | |
245 | log("Test case verdictCompNotEq has unexpected verdict."); | |
246 | fault_count := fault_count + 1; | |
247 | } | |
248 | if (execute(verdictSetGet()) != pass) { | |
249 | log("Test case verdictSetGet has unexpected verdict."); | |
250 | fault_count := fault_count + 1; | |
251 | } | |
252 | if (execute(verdictSet_None()) != none) { | |
253 | log("Test case verdictSet_None has unexpected verdict."); | |
254 | fault_count := fault_count + 1; | |
255 | } | |
256 | if (execute(verdictSet_n_None()) != none) { | |
257 | log("Test case verdictSet_n_None has unexpected verdict."); | |
258 | fault_count := fault_count + 1; | |
259 | } | |
260 | if (execute(verdictSet_p_Pass()) != pass) { | |
261 | log("Test case verdictSet_p_Pass has unexpected verdict."); | |
262 | fault_count := fault_count + 1; | |
263 | } | |
264 | if (execute(verdictSet_i_Inconc()) != inconc) { | |
265 | log("Test case verdictSet_i_Inconc has unexpected verdict."); | |
266 | fault_count := fault_count + 1; | |
267 | } | |
268 | if (execute(verdictSet_f_Fail()) != fail) { | |
269 | log("Test case verdictSet_f_Fail has unexpected verdict."); | |
270 | fault_count := fault_count + 1; | |
271 | } | |
272 | if (execute(verdictSet_p_i_Inconc()) != inconc) { | |
273 | log("Test case verdictSet_p_i_Inconc has unexpected verdict."); | |
274 | fault_count := fault_count + 1; | |
275 | } | |
276 | if (execute(verdictSet_p_f_Fail()) != fail) { | |
277 | log("Test case verdictSet_p_f_Fail has unexpected verdict."); | |
278 | fault_count := fault_count + 1; | |
279 | } | |
280 | if (execute(verdictSet_p_n_Pass()) != pass) { | |
281 | log("Test case verdictSet_p_n_Pass has unexpected verdict."); | |
282 | fault_count := fault_count + 1; | |
283 | } | |
284 | if (execute(verdictSet_i_p_Inconc()) != inconc) { | |
285 | log("Test case verdictSet_i_p_Inconc has unexpected verdict."); | |
286 | fault_count := fault_count + 1; | |
287 | } | |
288 | if (execute(verdictSet_i_f_Fail()) != fail) { | |
289 | log("Test case verdictSet_i_f_Fail has unexpected verdict."); | |
290 | fault_count := fault_count + 1; | |
291 | } | |
292 | if (execute(verdictSet_i_n_Inconc()) != inconc) { | |
293 | log("Test case verdictSet_i_n_Inconc has unexpected verdict."); | |
294 | fault_count := fault_count + 1; | |
295 | } | |
296 | if (execute(verdictSet_f_p_Fail()) != fail) { | |
297 | log("Test case verdictSet_f_p_Fail has unexpected verdict."); | |
298 | fault_count := fault_count + 1; | |
299 | } | |
300 | if (execute(verdictSet_f_i_Fail()) != fail) { | |
301 | log("Test case verdictSet_f_i_Fail has unexpected verdict."); | |
302 | fault_count := fault_count + 1; | |
303 | } | |
304 | if (execute(verdictSet_f_n_Fail()) != fail) { | |
305 | log("Test case verdictSet_f_n_Fail has unexpected verdict."); | |
306 | fault_count := fault_count + 1; | |
307 | } | |
308 | if (execute(verdictSet_n_p_Pass()) != pass) { | |
309 | log("Test case verdictSet_n_p_Pass has unexpected verdict."); | |
310 | fault_count := fault_count + 1; | |
311 | } | |
312 | if (execute(verdictSet_n_i_Inconc()) != inconc) { | |
313 | log("Test case verdictSet_n_i_Inconc has unexpected verdict."); | |
314 | fault_count := fault_count + 1; | |
315 | } | |
316 | if (execute(verdictSet_n_f_Fail()) != fail) { | |
317 | log("Test case verdictSet_n_f_Fail has unexpected verdict."); | |
318 | fault_count := fault_count + 1; | |
319 | } | |
320 | if (execute(verdict_reason()) != pass) { | |
321 | log("Test case verdict_reason has unexpected verdict."); | |
322 | fault_count := fault_count + 1; | |
323 | } | |
324 | if (execute(verdictSubtypes()) != pass) { | |
325 | log("Test case verdictSubtypes() has unexpected verdict."); | |
326 | fault_count := fault_count + 1; | |
327 | } | |
328 | if (execute(verdictIsbound()) != pass) { | |
329 | log("Test case verdictSubtypes() has unexpected verdict."); | |
330 | fault_count := fault_count + 1; | |
331 | } | |
332 | if (fault_count == 0) { | |
333 | log("ALL TEST CASES HAVE PASSED!!!"); | |
334 | } else { | |
335 | var integer i := 0; | |
336 | log("NUMBER OF FAILED TEST CASES: ", fault_count); | |
337 | // this will cause an error | |
338 | i := 1 / i; | |
339 | } | |
340 | } | |
341 | } |