/******************************************************************************
 * 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
 *   Bartha, Norbert
 *   Delic, Adam
 *   Kovacs, Ferenc
 *   Raduly, Csaba
 *   Szabados, Kristof
 *   Szabo, Janos Zoltan – initial implementation
 *   Pandi, Krisztian
 *
 ******************************************************************************/
module FuncRef
{

type function un_oper(in integer a) return integer;
type function bin_oper(in integer a, in integer b) return integer;

function neg(in integer a) return integer { return -a; }

function add(in integer a, in integer b) return integer { return a+b; }
function sub(in integer a, in integer b) return integer { return a-b; }
function mul(in integer a, in integer b) return integer { return a*b; }

public function my_int2str(in integer a) return charstring {
  var charstring f := int2str(a);
  return f;
}

type function my_int2str_type(in integer a) return charstring;

modulepar my_int2str_type modulepar_my_intstr := refers(my_int2str);

function f_timer(timer t) return charstring {
  return log2str(t);
}

type function f_timer_type(timer t) return charstring;


type union operator_type
{
  un_oper  unary,
  bin_oper binary
}

type record of operator_type operator_list;
type record of integer         operand_list;

function calculate_expr(in operand_list operands, in operator_list operators)
return integer
{
  var integer operand_count  := sizeof(operands);
  var integer operator_count := sizeof(operators);
  var integer i;
  var integer current_operand := 1;
  var integer result := operands[0];
  for (i:=0; i<operator_count; i:=i+1)
  {
    if (ischosen(operators[i].unary))
    {
      result := operators[i].unary.apply(result);
    }
    else
    {
      result := operators[i].binary.apply(result, operands[current_operand]);
      current_operand := current_operand + 1;
    }
  }
  return result;
}

type component FuncRef_comp {
  port tcport TCP1, TCP2;
};

testcase calculationTest() runs on FuncRef_comp
{
  var operand_list operands_1 := { 1, 2, 3  }; // -1 + 2 - 3 = -2
  var operand_list operands_2 := { 2, 2, -6 }; // 2 * 2 + -6 = -2
  var operator_list operators_1 := { { unary := refers(neg) },
    { binary := refers(add) },
    { binary := refers(sub) } };
  var operator_list operators_2 := { { binary := refers(mul) },
    { binary  := refers(add) } };
  var integer result_1 := calculate_expr(operands_1, operators_1);
  var integer result_2 := calculate_expr(operands_2, operators_2);
  if (result_1 == result_2) { setverdict(pass); }
  else { setverdict(fail); }
}

template bin_oper bin_oper_tmpl  := (refers(add), refers(sub));
template bin_oper bin_oper_tmpl2 := *;
template bin_oper bin_oper_tmpl3 := omit;

testcase funcTemplateTest() runs on FuncRef_comp
{
  var bin_oper a := refers(add);
  var bin_oper s := refers(sub);
  var bin_oper m := refers(mul);
  if ( match(a, bin_oper_tmpl) != match(s, bin_oper_tmpl) )
  { setverdict(fail); }
  if ( match(a, bin_oper_tmpl) == match(m, bin_oper_tmpl) )
  { setverdict(fail); }
  if ( match(s, bin_oper_tmpl) == match(m, bin_oper_tmpl) )
  { setverdict(fail); }
  if ( match(a, bin_oper_tmpl) != match(a, bin_oper_tmpl) )
  { setverdict(fail); }
  if ( match(s, bin_oper_tmpl) != match(s, bin_oper_tmpl) )
  { setverdict(fail); }
  if ( match(m, bin_oper_tmpl) != match(m, bin_oper_tmpl) )
  { setverdict(fail); }
  if (not match(m, bin_oper_tmpl2))
  { setverdict(fail); }
  if (match(m, bin_oper_tmpl3))
  { setverdict(fail); }
  setverdict(pass);
}

type function fn_type();
function fn1() { }
function fn2() { }
function fn_fn(in fn_type f) return fn_type { return f; }
template fn_type fntmpl := refers(fn1);

type function fn_temp_ret_type() return template integer;
function fn_temp_ret_fn() return template integer { return 1; }

testcase funcRefOperTest() runs on FuncRef_comp
{
  var fn_type f1 := refers(fn1);
  var fn_type f2 := refers(fn2);
  const fn_type f1c := refers(fn1);
  var fn_temp_ret_type fn_temp_ret_var := refers(fn_temp_ret_fn);
  if (not(f1==f1)) { setverdict(fail); }
  if (f1==f2) { setverdict(fail); }
  if (not(f1!=f2)) { setverdict(fail); }
  if (f1!=f1) { setverdict(fail); }
  if (not(f1c==f1)) { setverdict(fail); }
  if (f1c!=f1) { setverdict(fail); }
  if (valueof(fntmpl)!=f1) { setverdict(fail); }
  if (fn_fn(f1)!=f1) { setverdict(fail); }
  if (fn_fn(valueof(f2))!=f2) { setverdict(fail); }
  if (fn_fn(valueof(f2))==f1) { setverdict(fail); }
  if(not(1 == valueof(fn_temp_ret_var.apply()))) { setverdict(fail); }
  if(not(match(valueof(fn_temp_ret_var.apply()),fn_temp_ret_var.apply()))) { setverdict(fail); }
  setverdict(pass);
}

type record my_message
{
  fn_type f
}

type port TP message {
  inout my_message;
} with { extension "internal" }

type component main {
  port TP tp;
  port TP tp2;
}

template my_message msg_tmpl := ?;

testcase transferTest() runs on main {
  connect(mtc:tp, mtc:tp2);
  const my_message sm1 := { refers(fn1) }
  const my_message sm2 := { refers(fn2) }
  var my_message rm1;
  var my_message rm2;
  tp.send(sm1);
  tp.send(sm2);
  tp2.receive(msg_tmpl) -> value rm1;
  tp2.receive(msg_tmpl) -> value rm2;
  if (rm1==rm2) { setverdict(fail); }
  setverdict(pass);
}

type function fact_func_type(in integer num, inout integer steps,
  in fact_func_type ff) return integer;

function factorial1(in integer num, inout integer steps) return integer
{
  steps := steps + 1;
  if (num<2) { return 1; }
  else { return num*factorial1(num-1,steps); }
}


function factorial2(in integer num, inout integer steps, in fact_func_type ff)
return integer
{
  steps := steps + 1;
  if (num<2) { return 1; }
  else { return num*ff.apply(num-1,steps,refers(factorial3)); }
}

function factorial3(in integer num, inout integer steps, in fact_func_type ff)
return integer
{
  steps := steps + 1;
  if (num<2) { return 1; }
  else { return num*ff.apply(num-1,steps,refers(factorial2)); }
}

testcase recursiveCallTest() runs on FuncRef_comp
{
  var integer steps1 := 0;
  var integer steps2 := 0;
  if (factorial1(5,steps1) != factorial2(5,steps2,refers(factorial3)))
  { setverdict(fail); }
  if (steps1!=steps2) { setverdict(fail); }
  setverdict(pass);
}


type function nested_rec_func(inout rec_list rl, in nested_rec_func nrf,
  in integer depth);
type record rec_list
{
  nested_rec_func nrf,
  rec_list rl optional,
  integer depth
}
function nrf_create_list_item(inout rec_list rl, in nested_rec_func nrf,
  in integer depth)
{
  if (depth>0)
  {
    var rec_list rl2 := { rl.nrf, omit, depth-1 }
    rl.nrf.apply(rl2, rl2.nrf, rl2.depth);
    rl.rl := rl2;
  }
}

testcase listRecursionTest() runs on FuncRef_comp
{
  var rec_list rl := { refers(nrf_create_list_item), omit, 5 }
  rl.nrf.apply(rl, rl.nrf, rl.depth);
  var integer expected_sum := 0+1+2+3+4+5;
  var integer sum := rl.depth;
  while (ispresent(rl.rl))
  {
    var rec_list rl2 := rl.rl;
    rl := rl2;
    sum := sum + rl.depth;
  }
  if (sum!=expected_sum) { setverdict(fail); }
  setverdict(pass);
}


type function fv_type_1() return integer;
function fv_1_1() return integer { return 11; }
function fv_1_2() return integer { return 12; }
type function fv_type_2() return integer;
function fv_2_1() return integer { return 21; }
function fv_2_2() return integer { return 22; }
// test refers and apply operations
testcase funcRefOperationsTest() runs on FuncRef_comp
{
  var fv_type_1 f11 := refers(fv_1_1);
  var fv_type_1 f12 := refers(fv_1_2);
  var fv_type_2 f21 := refers(fv_2_1);
  var fv_type_2 f22 := refers(fv_2_2);
  var template fv_type_1 tf11 := f11;
  var template fv_type_2 tf21 := f21;
  if (f11.apply()!=f11.apply()) { setverdict(fail); }
  if (f11.apply()==f12.apply()) { setverdict(fail); }
  var fv_type_1 f10 := valueof(tf11);
  var fv_type_2 f20 := valueof(tf21);
  if (f10.apply()!=f11.apply()) { setverdict(fail); }
  if (f10.apply()==f12.apply()) { setverdict(fail); }
  if (f10.apply()==f20.apply()) { setverdict(fail); }
  if (not match(refers(fv_1_1), tf11)) { setverdict(fail); }
  if (match(refers(fv_1_2), tf11)) { setverdict(fail); }
  if (match(refers(fv_1_1), tf21)) { setverdict(fail); }
  setverdict(pass);
}


type function fn_par() return fn_par;
function fnp0() return fn_par { return refers(fnp0) }
function fnp1() return fn_par { return refers(fnp1) }
function fnp2() return fn_par { return refers(fnp2) }
function fnp3() return fn_par { return refers(fnp3) }
function fnp4() return fn_par { return refers(fnp4) }
function fnpnull() return fn_par { return null; }
function fn_params(fn_par p1, in fn_par p2, out fn_par p3, inout fn_par p4)
{
  if ( p1.apply()!=refers(fnp0) or p2.apply()!=refers(fnp0) or
    p4.apply()!=refers(fnp0) ) { setverdict(fail); }
  p1 := refers(fnp1);
  p2 := refers(fnp2);
  p3 := refers(fnp3);
  p4 := refers(fnp4);
  if (p1.apply()==null) { setverdict(fail); }
  if (p1.apply()!=refers(fnp1)) { setverdict(fail); }
  if (p2.apply()!=refers(fnp2)) { setverdict(fail); }
  if (p3.apply()!=refers(fnp4)) { setverdict(fail); }
  if (p4.apply()!=refers(fnp4)) { setverdict(fail); }
}
testcase funcRefParamsTest() runs on FuncRef_comp
{
  var fn_par fnp := refers(fnp0);
  if (fnp0()!=refers(fnp0)) { setverdict(fail); }
  if (fnp.apply()!=fnp0()) { setverdict(fail); }
  if (fnp.apply()==null) { setverdict(fail); }
  //fn_params(fnp,fnp,fnp,fnp);
  //if (fnp.apply()!=refers(fnp4)) { setverdict(fail); }
  
  if (fnpnull()!=null) { setverdict(fail); }
  fnp := refers(fnpnull);
  if (fnp.apply()!=null) { setverdict(fail); }
  if (fnp.apply()!=fnpnull()) { setverdict(fail); }
  
  fnp := refers(fnp0);
  if (fnp.apply().apply().apply() != fnp.apply()) { setverdict(fail); }
  if (fnp0().apply() != refers(fnp0)) { setverdict(fail); }
  
  setverdict(pass);
}


function fff() {  }
type union UNION
{
  function () f1,
  function () f2,
  function () f3
}
type set SET
{
  function () f1 optional,
  function () f2 optional,
  function () f3 optional
}
type record REKORD
{
  function () f1 optional,
  function () f2 optional,
  function () f3 optional
}
// test predefined functions: sizeof(), ispresent(), ischosen()
testcase predefFuncOnNestedCompoundTypesTest() runs on FuncRef_comp
{
  var REKORD v_r := { refers(fff), omit, refers(fff) }
  var SET    v_s := { f1 := refers(fff), f2 := omit, f3 := refers(fff) }
  var UNION  v_u := { f2 := refers(fff) }
  var template REKORD t_r := v_r;
  var template SET    t_s := v_s;
  var template UNION  t_u := v_u;
  if ( sizeof(v_r)!=2 or not ispresent(v_r.f1) or ispresent(v_r.f2) or
    not ispresent(v_r.f3) )
  { setverdict(fail); }
  if ( sizeof(t_r)!=2 or not ispresent(t_r.f1) or ispresent(t_r.f2) or
    not ispresent(t_r.f3) )
  { setverdict(fail); }
  if ( sizeof(v_s)!=2 or not ispresent(v_s.f1) or ispresent(v_s.f2) or
    not ispresent(v_s.f3) )
  { setverdict(fail); }
  if ( sizeof(t_s)!=2 or not ispresent(t_s.f1) or ispresent(t_s.f2) or
    not ispresent(t_s.f3) )
  { setverdict(fail); }
  if ( ischosen(v_u.f1) or not ischosen(v_u.f2) or ischosen(v_u.f3) )
  { setverdict(fail); }
  if ( ischosen(t_u.f1) or not ischosen(t_u.f2) or ischosen(t_u.f3) )
  { setverdict(fail); }
  setverdict(pass);
}


type testcase tc_type() runs on FuncRef_comp;
type record of tc_type tc_recof;

type function MyFunction_RunsOnParent() runs on Parent_CT;
type function MyFunction_RunsOnChild() runs on Child_CT;
type function MyFunction_RunsOnSelf() runs on self;

type component Parent_CT
{
  var MyFunction_RunsOnParent fs_parent := null;
  var MyFunction_RunsOnSelf fs_self := null;
  var charstring parent := "parent";
}

type component Child_CT extends Parent_CT
{
  var MyFunction_RunsOnChild fs_child := null;
  var charstring child := "child";
}

function f_parent(in MyFunction_RunsOnSelf p_self) runs on Parent_CT
{
  p_self.apply();
}

function f_child() runs on Child_CT
{
  child := "Running child function is done";
}

testcase tc_runsonself() runs on Child_CT
{
  fs_self := refers(f_child);
  
  f_parent(fs_self);
  
  if(child != "Running child function is done")
  {
    setverdict(fail);
  }
  else { setverdict(pass); }
}

type port tcport message {
  inout tc_recof
}
with { extension "internal" }

testcase tc_send_tc() runs on FuncRef_comp
{
  var tc_recof sent_testcases := {
    refers(tc_send_tc)
  }, received_testcases;
  connect(mtc:TCP1, mtc:TCP2);
  TCP1.send(sent_testcases);
  TCP2.receive(tc_recof : ?) -> value received_testcases;
  if (received_testcases == sent_testcases) { setverdict(pass); }
  else { setverdict(fail, match(received_testcases, sent_testcases)); }
  disconnect(mtc:TCP1, mtc:TCP2);
}

// For TR HL26179.
type function f_myfunctype1(in charstring p1) runs on self
function f_myfunc1(in charstring p1) runs on empty_ct {}
type component empty_ct {var f_myfunctype1 v_myfuncvar1 := refers(f_myfunc1)}

testcase tc_functionrefIsbound() runs on FuncRef_comp
{
  var fv_type_1 f0;
  var fv_type_1 f1 := refers(fv_1_1);
  if ( isvalue(f0) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(f1) ) { setverdict(pass); } else { setverdict(fail); };
}

// for TR H029700
type function f_FT();

function f_refers() {
  var f_FT vf := valueof(f_FT:refers(f_refers));  
}

// for Bug 511976 
testcase tc_modulepar_refer() runs on FuncRef_comp {
  if (modulepar_my_intstr.apply(4) == "4") {
    setverdict(pass);
  } else {
    setverdict(fail);
  }
}

// for bug 546800
testcase tc_function_with_timer() runs on FuncRef_comp {
  var f_timer_type f := refers(f_timer);
  timer t1;
  var charstring res := f.apply(t1);
  if (res == "timer: { name: t1, default duration: none, state: inactive }") {
    setverdict(pass);
  }
  else {
    setverdict(fail, res);
  }
}


control
{
  var integer i;
  var tc_recof testcases := {
    refers(calculationTest),
    refers(funcTemplateTest),
    refers(funcRefOperTest),
    refers(recursiveCallTest),
    refers(listRecursionTest),
    refers(funcRefOperationsTest),
    refers(funcRefParamsTest),
    refers(predefFuncOnNestedCompoundTypesTest)
  }
  for(i := 0; i < sizeof(testcases); i := i+1)
  {
    execute(derefers(testcases[i])());
  }
  execute(transferTest());
  execute(tc_runsonself());
  execute(tc_functionrefIsbound());
  execute(tc_send_tc());
  execute(tc_modulepar_refer());
  execute(tc_function_with_timer());
}
}