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 ******************************************************************************/
11 type function un_oper(in integer a) return integer;
12 type function bin_oper(in integer a, in integer b) return integer;
14 function neg(in integer a) return integer { return -a; }
16 function add(in integer a, in integer b) return integer { return a+b; }
17 function sub(in integer a, in integer b) return integer { return a-b; }
18 function mul(in integer a, in integer b) return integer { return a*b; }
20 type union operator_type
26 type record of operator_type operator_list;
27 type record of integer operand_list;
29 function calculate_expr(in operand_list operands, in operator_list operators)
32 var integer operand_count := sizeof(operands);
33 var integer operator_count := sizeof(operators);
35 var integer current_operand := 1;
36 var integer result := operands[0];
37 for (i:=0; i<operator_count; i:=i+1)
39 if (ischosen(operators[i].unary))
41 result := operators[i].unary.apply(result);
45 result := operators[i].binary.apply(result, operands[current_operand]);
46 current_operand := current_operand + 1;
52 type component FuncRef_comp {
53 port tcport TCP1, TCP2;
56 testcase calculationTest() runs on FuncRef_comp
58 var operand_list operands_1 := { 1, 2, 3 }; // -1 + 2 - 3 = -2
59 var operand_list operands_2 := { 2, 2, -6 }; // 2 * 2 + -6 = -2
60 var operator_list operators_1 := { { unary := refers(neg) },
61 { binary := refers(add) },
62 { binary := refers(sub) } };
63 var operator_list operators_2 := { { binary := refers(mul) },
64 { binary := refers(add) } };
65 var integer result_1 := calculate_expr(operands_1, operators_1);
66 var integer result_2 := calculate_expr(operands_2, operators_2);
67 log("result 1 = ", result_1);
68 log("result 2 = ", result_2);
69 if (result_1 == result_2) { setverdict(pass); }
70 else { setverdict(fail); }
73 template bin_oper bin_oper_tmpl := (refers(add), refers(sub));
74 template bin_oper bin_oper_tmpl2 := *;
75 template bin_oper bin_oper_tmpl3 := omit;
77 testcase funcTemplateTest() runs on FuncRef_comp
82 var bin_oper a := refers(add);
83 var bin_oper s := refers(sub);
84 var bin_oper m := refers(mul);
85 if ( match(a, bin_oper_tmpl) != match(s, bin_oper_tmpl) )
87 if ( match(a, bin_oper_tmpl) == match(m, bin_oper_tmpl) )
89 if ( match(s, bin_oper_tmpl) == match(m, bin_oper_tmpl) )
91 if ( match(a, bin_oper_tmpl) != match(a, bin_oper_tmpl) )
93 if ( match(s, bin_oper_tmpl) != match(s, bin_oper_tmpl) )
95 if ( match(m, bin_oper_tmpl) != match(m, bin_oper_tmpl) )
97 if (not match(m, bin_oper_tmpl2))
99 if (match(m, bin_oper_tmpl3))
100 { setverdict(fail); }
104 type function fn_type();
107 function fn_fn(in fn_type f) return fn_type { return f; }
108 template fn_type fntmpl := refers(fn1);
110 type function fn_temp_ret_type() return template integer;
111 function fn_temp_ret_fn() return template integer { return 1; }
113 testcase funcRefOperTest() runs on FuncRef_comp
115 var fn_type f1 := refers(fn1);
116 var fn_type f2 := refers(fn2);
117 const fn_type f1c := refers(fn1);
118 var fn_temp_ret_type fn_temp_ret_var := refers(fn_temp_ret_fn);
119 if (not(f1==f1)) { setverdict(fail); }
120 if (f1==f2) { setverdict(fail); }
121 if (not(f1!=f2)) { setverdict(fail); }
122 if (f1!=f1) { setverdict(fail); }
123 if (not(f1c==f1)) { setverdict(fail); }
124 if (f1c!=f1) { setverdict(fail); }
125 if (valueof(fntmpl)!=f1) { setverdict(fail); }
126 if (fn_fn(f1)!=f1) { setverdict(fail); }
127 if (fn_fn(valueof(f2))!=f2) { setverdict(fail); }
128 if (fn_fn(valueof(f2))==f1) { setverdict(fail); }
129 if(not(1 == valueof(fn_temp_ret_var.apply()))) { setverdict(fail); }
130 if(not(match(valueof(fn_temp_ret_var.apply()),fn_temp_ret_var.apply()))) { setverdict(fail); }
134 type record my_message
139 type port TP message {
141 } with { extension "internal" }
143 type component main {
148 template my_message msg_tmpl := ?;
150 testcase transferTest() runs on main {
151 connect(mtc:tp, mtc:tp2);
152 const my_message sm1 := { refers(fn1) }
153 const my_message sm2 := { refers(fn2) }
158 tp2.receive(msg_tmpl) -> value rm1;
159 tp2.receive(msg_tmpl) -> value rm2;
160 if (rm1==rm2) { setverdict(fail); }
164 type function fact_func_type(in integer num, inout integer steps,
165 in fact_func_type ff) return integer;
167 function factorial1(in integer num, inout integer steps) return integer
169 //log("factorial1 called");
171 if (num<2) { return 1; }
172 else { return num*factorial1(num-1,steps); }
176 function factorial2(in integer num, inout integer steps, in fact_func_type ff)
179 //log("factorial2 called");
181 if (num<2) { return 1; }
182 else { return num*ff.apply(num-1,steps,refers(factorial3)); }
185 function factorial3(in integer num, inout integer steps, in fact_func_type ff)
188 //log("factorial3 called");
190 if (num<2) { return 1; }
191 else { return num*ff.apply(num-1,steps,refers(factorial2)); }
194 testcase recursiveCallTest() runs on FuncRef_comp
196 var integer steps1 := 0;
197 var integer steps2 := 0;
198 if (factorial1(5,steps1) != factorial2(5,steps2,refers(factorial3)))
199 { setverdict(fail); }
200 if (steps1!=steps2) { setverdict(fail); }
205 type function nested_rec_func(inout rec_list rl, in nested_rec_func nrf,
210 rec_list rl optional,
213 function nrf_create_list_item(inout rec_list rl, in nested_rec_func nrf,
218 var rec_list rl2 := { rl.nrf, omit, depth-1 }
219 rl.nrf.apply(rl2, rl2.nrf, rl2.depth);
224 testcase listRecursionTest() runs on FuncRef_comp
226 var rec_list rl := { refers(nrf_create_list_item), omit, 5 }
227 rl.nrf.apply(rl, rl.nrf, rl.depth);
228 var integer expected_sum := 0+1+2+3+4+5;
229 var integer sum := rl.depth;
230 while (ispresent(rl.rl))
232 var rec_list rl2 := rl.rl;
234 sum := sum + rl.depth;
236 if (sum!=expected_sum) { setverdict(fail); }
241 type function fv_type_1() return integer;
242 function fv_1_1() return integer { return 11; }
243 function fv_1_2() return integer { return 12; }
244 type function fv_type_2() return integer;
245 function fv_2_1() return integer { return 21; }
246 function fv_2_2() return integer { return 22; }
247 // test refers and apply operations
248 testcase funcRefOperationsTest() runs on FuncRef_comp
250 var fv_type_1 f11 := refers(fv_1_1);
251 var fv_type_1 f12 := refers(fv_1_2);
252 var fv_type_2 f21 := refers(fv_2_1);
253 var fv_type_2 f22 := refers(fv_2_2);
254 var template fv_type_1 tf11 := f11;
255 var template fv_type_2 tf21 := f21;
256 if (f11.apply()!=f11.apply()) { setverdict(fail); }
257 if (f11.apply()==f12.apply()) { setverdict(fail); }
258 var fv_type_1 f10 := valueof(tf11);
259 var fv_type_2 f20 := valueof(tf21);
260 if (f10.apply()!=f11.apply()) { setverdict(fail); }
261 if (f10.apply()==f12.apply()) { setverdict(fail); }
262 if (f10.apply()==f20.apply()) { setverdict(fail); }
263 if (not match(refers(fv_1_1), tf11)) { setverdict(fail); }
264 if (match(refers(fv_1_2), tf11)) { setverdict(fail); }
265 if (match(refers(fv_1_1), tf21)) { setverdict(fail); }
270 type function fn_par() return fn_par;
271 function fnp0() return fn_par { return refers(fnp0) }
272 function fnp1() return fn_par { return refers(fnp1) }
273 function fnp2() return fn_par { return refers(fnp2) }
274 function fnp3() return fn_par { return refers(fnp3) }
275 function fnp4() return fn_par { return refers(fnp4) }
276 function fnpnull() return fn_par { return null; }
277 function fn_params(fn_par p1, in fn_par p2, out fn_par p3, inout fn_par p4)
279 if ( p1.apply()!=refers(fnp0) or p2.apply()!=refers(fnp0) or
280 p4.apply()!=refers(fnp0) ) { setverdict(fail); }
285 if (p1.apply()==null) { setverdict(fail); }
286 if (p1.apply()!=refers(fnp1)) { setverdict(fail); }
287 if (p2.apply()!=refers(fnp2)) { setverdict(fail); }
288 if (p3.apply()!=refers(fnp4)) { setverdict(fail); }
289 if (p4.apply()!=refers(fnp4)) { setverdict(fail); }
291 testcase funcRefParamsTest() runs on FuncRef_comp
293 var fn_par fnp := refers(fnp0);
294 if (fnp0()!=refers(fnp0)) { setverdict(fail); }
295 if (fnp.apply()!=fnp0()) { setverdict(fail); }
296 if (fnp.apply()==null) { setverdict(fail); }
297 //fn_params(fnp,fnp,fnp,fnp);
298 //if (fnp.apply()!=refers(fnp4)) { setverdict(fail); }
300 if (fnpnull()!=null) { setverdict(fail); }
301 fnp := refers(fnpnull);
302 if (fnp.apply()!=null) { setverdict(fail); }
303 if (fnp.apply()!=fnpnull()) { setverdict(fail); }
306 if (fnp.apply().apply().apply() != fnp.apply()) { setverdict(fail); }
307 if (fnp0().apply() != refers(fnp0)) { setverdict(fail); }
322 function () f1 optional,
323 function () f2 optional,
324 function () f3 optional
328 function () f1 optional,
329 function () f2 optional,
330 function () f3 optional
332 // test predefined functions: sizeof(), ispresent(), ischosen()
333 testcase predefFuncOnNestedCompoundTypesTest() runs on FuncRef_comp
335 var REKORD v_r := { refers(fff), omit, refers(fff) }
336 var SET v_s := { f1 := refers(fff), f2 := omit, f3 := refers(fff) }
337 var UNION v_u := { f2 := refers(fff) }
338 var template REKORD t_r := v_r;
339 var template SET t_s := v_s;
340 var template UNION t_u := v_u;
341 if ( sizeof(v_r)!=2 or not ispresent(v_r.f1) or ispresent(v_r.f2) or
342 not ispresent(v_r.f3) )
343 { setverdict(fail); }
344 if ( sizeof(t_r)!=2 or not ispresent(t_r.f1) or ispresent(t_r.f2) or
345 not ispresent(t_r.f3) )
346 { setverdict(fail); }
347 if ( sizeof(v_s)!=2 or not ispresent(v_s.f1) or ispresent(v_s.f2) or
348 not ispresent(v_s.f3) )
349 { setverdict(fail); }
350 if ( sizeof(t_s)!=2 or not ispresent(t_s.f1) or ispresent(t_s.f2) or
351 not ispresent(t_s.f3) )
352 { setverdict(fail); }
353 if ( ischosen(v_u.f1) or not ischosen(v_u.f2) or ischosen(v_u.f3) )
354 { setverdict(fail); }
355 if ( ischosen(t_u.f1) or not ischosen(t_u.f2) or ischosen(t_u.f3) )
356 { setverdict(fail); }
361 type testcase tc_type() runs on FuncRef_comp;
362 type record of tc_type tc_recof;
364 type function MyFunction_RunsOnParent() runs on Parent_CT;
365 type function MyFunction_RunsOnChild() runs on Child_CT;
366 type function MyFunction_RunsOnSelf() runs on self;
368 type component Parent_CT
370 var MyFunction_RunsOnParent fs_parent := null;
371 var MyFunction_RunsOnSelf fs_self := null;
372 var charstring parent := "parent";
375 type component Child_CT extends Parent_CT
377 var MyFunction_RunsOnChild fs_child := null;
378 var charstring child := "child";
381 function f_parent(in MyFunction_RunsOnSelf p_self) runs on Parent_CT
386 function f_child() runs on Child_CT
388 child := "Running child function is done";
391 testcase tc_runsonself() runs on Child_CT
393 fs_self := refers(f_child);
397 if(child != "Running child function is done")
401 else { setverdict(pass); }
404 type port tcport message {
407 with { extension "internal" }
409 testcase tc_send_tc() runs on FuncRef_comp
411 var tc_recof sent_testcases := {
413 }, received_testcases;
414 connect(mtc:TCP1, mtc:TCP2);
415 TCP1.send(sent_testcases);
416 TCP2.receive(tc_recof : ?) -> value received_testcases;
417 if (received_testcases == sent_testcases) { setverdict(pass); }
418 else { setverdict(fail, match(received_testcases, sent_testcases)); }
419 disconnect(mtc:TCP1, mtc:TCP2);
423 type function f_myfunctype1(in charstring p1) runs on self
424 function f_myfunc1(in charstring p1) runs on empty_ct {}
425 type component empty_ct {var f_myfunctype1 v_myfuncvar1 := refers(f_myfunc1)}
427 testcase tc_functionrefIsbound() runs on FuncRef_comp
430 var fv_type_1 f1 := refers(fv_1_1);
431 if ( isvalue(f0) ) { setverdict(fail); } else { setverdict(pass); };
432 if ( isvalue(f1) ) { setverdict(pass); } else { setverdict(fail); };
436 type function f_FT();
438 function f_refers() {
439 var f_FT vf := valueof(f_FT:refers(f_refers));
446 var tc_recof testcases := {
447 refers(calculationTest),
448 refers(funcTemplateTest),
449 refers(funcRefOperTest),
450 refers(recursiveCallTest),
451 refers(listRecursionTest),
452 refers(funcRefOperationsTest),
453 refers(funcRefParamsTest),
454 refers(predefFuncOnNestedCompoundTypesTest)
456 for(i := 0; i < sizeof(testcases); i := i+1)
458 execute(derefers(testcases[i])());
460 execute(transferTest());
461 execute(tc_runsonself());
462 execute(tc_functionrefIsbound());
463 execute(tc_send_tc());