[deliverable/titan.core.git] / regression_test / text2ttcn / recordof_test.ttcn

/******************************************************************************
 * Copyright (c) 2000-2015 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 ******************************************************************************/
/*
//AUTHOR: 
//DATE: 
//VERSION: 
*/
module recordof_test
{

//=========================================================================
// Import Part
//=========================================================================
import from types all;
import from functions all;
 
//=========================================================================
// Module Parameters
//=========================================================================
modulepar {
    //record of
  template RoI tspt_recof_i_v0 := {};
  template RoI tspt_recof_i_v1 := {1};
  template RoI tspt_recof_i_v2 := {1,2};
  //template RoI tspt_recof_i_v2 := {omit,2}; //not allowed
  template RoI tspt_recof_i_v3 := {1,2,3};
  template RoI tspt_recof_i_v3a := {1,*,3};
  template RoI tspt_recof_i_v3q := {1,?,3};
  template RoI tspt_recof_i_vl3 := {(1,2),2,(3,4)}; //value list
  template RoI tspt_recof_i_vl :=  ( {1,2,3}, {2,2,4} )
  template RoI tspt_recof_i_v10 := {1,2,3,4,5,6,7,8,9,10};
  template RoI tspt_recof_i_o := omit;
  template RoI tspt_recof_i_a := *;
  template RoI tspt_recof_i_q := ?;
  template RoI tspt_recof_i_r := {1,(1..3)}; //range
  //template RoI tspt_recof_i_c := complement {1,2}; //range
  template RoI tspt_recof_i_c := {1,complement(1,2,3)}
  //template RoI tspt_recof_i_cr := {1,complement(1..3)}
  template RoI tspt_recof_i_lv := ? length(3)
  template RoI tspt_recof_i_lr := ? length(3..5)  //length range
  template RoI tspt_recof_i_p := { permutation (1,2,3),10 }

  //it will modified for sth in cfg file:
  template RoI tspt_recof_i_mod4v0 := ? 
  template RoI tspt_recof_i_mod4v1 := ?
  template RoI tspt_recof_i_mod4v2 := ?;
  template RoI tspt_recof_i_mod4v3 := ?;
  template RoI tspt_recof_i_mod4v3a := ?;
  template RoI tspt_recof_i_mod4v3q := ?;
  template RoI tspt_recof_i_mod4vl3 := ({1},{(1,2),2,(3,4)}); //value list
  template RoI tspt_recof_i_mod4vl :=   ?
  template RoI tspt_recof_i_mod4v10 := ?
  template RoI tspt_recof_i_mod4o :=  {1,2,3,4,5,6,7,8,9,10};
  template RoI tspt_recof_i_mod4a :=  {1,2,3,4,5,6,7,8,9,10};
  template RoI tspt_recof_i_mod4q := {1,2,3,4,5,6,7,8,9,10};
  template RoI tspt_recof_i_mod4r :=  {2};
  template RoI tspt_recof_i_mod4cu :=  { permutation (1,2,3),10 }; ///almost bug
  template RoI tspt_recof_i_mod4c :=  { permutation (1,2,3),10 }; ///almost bug
  template RoI tspt_recof_i_mod4cm1 :=  { permutation (1,2,3) };
  template RoI tspt_recof_i_mod4cm2 :=  { permutation (1,2,3),10 };
  template RoI tspt_recof_i_mod4lv :=  ?
  template RoI tspt_recof_i_mod4lr :=  *
  template RoI tspt_recof_i_mod4p := {12,34}
  template RoI tspt_recof_i_mod4rifp := {12,34} //will be changed for range
  template RoI tspt_recof_i_mod4vlifp := *  //will be changed
  //rec of float
  template RoF tspt_recof_f_v0 := {};
  template RoF tspt_recof_f_v1 := {1.0};
  template RoF tspt_recof_f_v2 := {1.0,2.0};
  //template RoF tspt_recof_f_v2 := {omit,2.0}; //not allowed
  template RoF tspt_recof_f_v3 := {1.0,2.0,3.0};
  template RoF tspt_recof_f_v3a := {1.0,*,3.0};
  template RoF tspt_recof_f_v3q := {1.0,?,3.0};
  template RoF tspt_recof_f_vl3 := {(1.0,2.0),2.0,(3.0,4.0)}; //value list
  template RoF tspt_recof_f_vl :=  ( {1.0,2.0,3.0}, {2.0,2.0,4.0} )
  template RoF tspt_recof_f_v10 := {1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0};
  template RoF tspt_recof_f_o := omit;
  template RoF tspt_recof_f_a := *;
  template RoF tspt_recof_f_q := ?;
  template RoF tspt_recof_f_r := {1.0,(1.0..3.0)}; //range
  //template RoF tspt_recof_f_c := complement {1.0,2.0}; //range
  template RoF tspt_recof_f_c := {1.0,complement(1.0,2.0,3.0)}
  //template RoF tspt_recof_f_cr := {1,complement(1.0..3.0)}
  template RoF tspt_recof_f_lv := ? length(3)
  template RoF tspt_recof_f_lr := ? length(3..5)  //length range
  template RoF tspt_recof_f_p := { permutation (1.0,2.0,3.0),10.0 }

  //it will modified for sth in cfg file:
  template RoF tspt_recof_f_mod4v0 := ? 
  template RoF tspt_recof_f_mod4v1 := ?
  template RoF tspt_recof_f_mod4v2 := ?;
  template RoF tspt_recof_f_mod4v3 := ?;
  template RoF tspt_recof_f_mod4v3a := ?;
  template RoF tspt_recof_f_mod4v3q := ?;
  template RoF tspt_recof_f_mod4vl3 := ({1.0},{(1.0,2.0),2.0,(3.0,4.0)}); //value list
  template RoF tspt_recof_f_mod4vl :=   ?
  template RoF tspt_recof_f_mod4v10 := ?
  template RoF tspt_recof_f_mod4o :=  {1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0};
  template RoF tspt_recof_f_mod4a :=  {1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0};
  template RoF tspt_recof_f_mod4q := {1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0};
  template RoF tspt_recof_f_mod4r :=  {2.0};
  template RoF tspt_recof_f_mod4cu :=  { permutation (1.0,2.0,3.0),10.0 }; ///almost bug
  template RoF tspt_recof_f_mod4c :=  { permutation (1.0,2.0,3.0),10.0 }; ///almost bug
  template RoF tspt_recof_f_mod4cm1 :=  { permutation (1.0,2.0,3.0) };
  template RoF tspt_recof_f_mod4cm2 :=  { permutation (1.0,2.0,3.0),10.0 };
  template RoF tspt_recof_f_mod4lv :=  ?
  template RoF tspt_recof_f_mod4lr :=  *
  template RoF tspt_recof_f_mod4p := {12.0,34.0}
  template RoF tspt_recof_f_mod4rifp := {12.0,34.0} //will be changed for range
}
//=========================================================================
// Data Types
//=========================================================================

// Insert data type defintions here if applicable!
// You can use the data_type skeleton!

//=========================================================================
// Signatures
//=========================================================================

// Insert signature definitions here if applicable!
// You can use the signature skeleton!

//=========================================================================
//Port Types
//=========================================================================

// Insert port type defintions here if applicable!
// You can use the port_type skeleton!

//=========================================================================
//Component Types
//=========================================================================

// Insert component type defintions here if applicable!
// You can use the component_type skeleton!

//=========================================================================
// Constants
//=========================================================================

// Insert constants here if applicable!
// You can use the constant skeleton!

//=========================================================================
// Templates
//=========================================================================
  //record of
  template RoI t_recof_i_v0 := {};
  template RoI t_recof_i_v1 := {1};
  template RoI t_recof_i_v2 := {1,2};
  //template RoI t_recof_i_v2 := {omit,2}; //not allowed
  template RoI t_recof_i_v3 := {1,2,3};
  template RoI t_recof_i_v3a := {1,*,3};
  template RoI t_recof_i_v3q := {1,?,3};
  template RoI t_recof_i_vl3 := {(1,2),2,(3,4)}; //value list
  template RoI t_recof_i_v10 := {1,2,3,4,5,6,7,8,9,10};
  template RoI t_recof_i_o := omit;
  template RoI t_recof_i_a := *;
  template RoI t_recof_i_q := ?;
  template RoI t_recof_i_r := {1,(1..3)}; //range
  //template RoI t_recof_i_c := complement {1,2}; 
  template RoI t_recof_i_c := {1,complement(1,2,3)}
  //template RoI t_recof_i_cr := {1,complement(1..3)} //TODO: check why it is not accepted
  template RoI t_recof_i_lv := ? length(3)
  template RoI t_recof_i_lr := ? length(3..5)  //length range
  template RoI t_recof_i_p := { permutation (1,2,3),10 }

//=========================================================================
// Altsteps
//=========================================================================

// Insert altsteps here if applicable!
// You can use the altstep skeleton!

//=========================================================================
// Functions
//=========================================================================

// Insert functions here if applicable!
// You can use the function skeleton!

//=========================================================================
// Testcases
//=========================================================================

  testcase tc_recordof_i_NoModulePar() runs on MC {

    log(t_recof_i_v0);
    if( log2str(t_recof_i_v0) != "{ }") { setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_v1);
    if( log2str(t_recof_i_v1) != "{ 1 }") {setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_v2);
    if( log2str(t_recof_i_v2) != "{ 1, 2 }") {setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_v3);
    if( log2str(t_recof_i_v3) != "{ 1, 2, 3 }") {setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_v3a);
    if( log2str(t_recof_i_v3a) != "{ 1, *, 3 }") {setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_v3q);
    if( log2str(t_recof_i_v3q) != "{ 1, ?, 3 }") {setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_vl3);
    if( log2str(t_recof_i_vl3) != "{ (1, 2), 2, (3, 4) }") {setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_v10);
    if( log2str(t_recof_i_v10) != "{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }") {setverdict(fail) };
    log(t_recof_i_o);
    if( log2str(t_recof_i_o) != "omit") { setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_a);
    if( log2str(t_recof_i_a) != "*") { setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_q);
    if( log2str(t_recof_i_q) != "?") { setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_r);
    if( log2str(t_recof_i_r) != "{ 1, (1 .. 3) }") { setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_c);
    if( log2str(t_recof_i_c) != "{ 1, complement (1, 2, 3) }") { setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_lv);
    if( log2str(t_recof_i_lv) != "? length (3)") { setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_lr);
    if( log2str(t_recof_i_lr) != "? length (3 .. 5)") { setverdict(fail) } else { setverdict(pass) };
    log(t_recof_i_p);
    if( log2str(t_recof_i_p) != "{ permutation(1, 2, 3), 10 }") { setverdict(fail) } else { setverdict(pass) };
  }


  testcase tc_recordof_i_ModulePar() runs on MC {

    log(tspt_recof_i_v0);
    if( log2str(tspt_recof_i_v0) != "{ }") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_v1);
    if( log2str(tspt_recof_i_v1) != "{ 1 }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_v2);
    if( log2str(tspt_recof_i_v2) != "{ 1, 2 }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_v3);
    if( log2str(tspt_recof_i_v3) != "{ 1, 2, 3 }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_v3a);
    if( log2str(tspt_recof_i_v3a) != "{ 1, *, 3 }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_v3q);
    if( log2str(tspt_recof_i_v3q) != "{ 1, ?, 3 }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_vl3);
    if( log2str(tspt_recof_i_vl3) != "{ (1, 2), 2, (3, 4) }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_v10);
    if( log2str(tspt_recof_i_v10) != "{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }") {setverdict(fail) };
    log(tspt_recof_i_o);
    if( log2str(tspt_recof_i_o) != "omit") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_a);
    if( log2str(tspt_recof_i_a) != "*") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_q);
    if( log2str(tspt_recof_i_q) != "?") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_r);
    if( log2str(tspt_recof_i_r) != "{ 1, (1 .. 3) }") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_c);
    if( log2str(tspt_recof_i_c) != "{ 1, complement (1, 2, 3) }") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_lv);
    if( log2str(tspt_recof_i_lv) != "? length (3)") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_lr);
    if( log2str(tspt_recof_i_lr) != "? length (3 .. 5)") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_i_p);
    if( log2str(tspt_recof_i_p) != "{ permutation(1, 2, 3), 10 }") { setverdict(fail) } else { setverdict(pass) };
  }

  testcase tc_recordof_i_Embedded() runs on MC { //TODO
    //TODO
  }
  //=====  
  testcase tc_recordof_i_v0() runs on MC {
    log(tspt_recof_i_v0);
    var RoI vl_long :={}; //to stress test
    for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i }
    var RoRoI vl_good_values := { {} }
    var RoRoI vl_wrong_values := { {1},{2},{1,2,3},{1,2,3,4,1000}, vl_long } 
    f_checkMatchingValues_roi(tspt_recof_i_v0,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_v1() runs on MC {
    log(tspt_recof_i_v1);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1} };
    var RoRoI vl_wrong_values := { {2},{1,2},{1,2,3},{1,2,3,4,1000} }   //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_v1,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_v2() runs on MC {
    log(tspt_recof_i_v2);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,2} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,3},{1,2,3,4,1000} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_v2,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_v3() runs on MC {
    log(tspt_recof_i_v3);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,2,3} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_v3,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_v3a() runs on MC {
    log(tspt_recof_i_v3a);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,1,3}, {1,2,3}, {1,3,3}, {1,4,3}, {1,9999,3} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_v3a,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_v3q() runs on MC {
    log(tspt_recof_i_v3q);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,1,3}, {1,2,3}, {1,3,3}, {1,4,3}, {1,9999,3} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_v3q,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_vl3() runs on MC {
    log(tspt_recof_i_vl3);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,2,3}, {2,2,3}, {1,2,4}, {2,2,4} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,5},{1,2,3,4,1000} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_vl3,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_vl() runs on MC {
    log(tspt_recof_i_vl);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,2,3},  {2,2,4} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000}, {2,2,3}, {1,2,4} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_vl,vl_good_values,vl_wrong_values);
  }  

  testcase tc_recordof_i_v10() runs on MC {
    log(tspt_recof_i_v10);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,2,3,4,5,6,7,8,9,10} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11}} //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_v10,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_o() runs on MC {
    log(tspt_recof_i_o);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := {};
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_o,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_a() runs on MC {
    log(tspt_recof_i_a);
    var RoRoI vl_good_values := {{}, {2},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    var RoRoI vl_wrong_values := {}; 
    f_checkMatchingValues_roi(tspt_recof_i_a,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_q() runs on MC {
    log(tspt_recof_i_q);
    var RoRoI vl_good_values := { {}, {2},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    var RoRoI vl_wrong_values := {}; 
    f_checkMatchingValues_roi(tspt_recof_i_q,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_r() runs on MC {
    log(tspt_recof_i_r);
    var RoRoI vl_good_values := { {1,1},{1,2},{1,3} } 
    var RoRoI vl_wrong_values := { {}, {2},{1,4},{-1,4},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_r,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_c() runs on MC {
    log(tspt_recof_i_c);
    var RoRoI vl_good_values := { {1,0},{1,4},{1,5}} 
    var RoRoI vl_wrong_values := { {}, {2},{1,1},{1,2},{1,3}, {2,4},{-1,4},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_c,vl_good_values,vl_wrong_values);
  }  

  testcase tc_recordof_i_lv() runs on MC {
    log(tspt_recof_i_lv);
    var RoRoI vl_good_values := { {0,1,0},{1,4,5},{1,5,-1},{1000,6000,700},{11,5,-3},{1,2,4}} 
    var RoRoI vl_wrong_values := { {}, {2},{1,1},{1,2},{1,3},{2,4},{-1,4},{2,3},{1,2,3,4,1000},{1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_lv,vl_good_values,vl_wrong_values);
  }  

  //length range
  testcase tc_recordof_i_lr() runs on MC {
    log(tspt_recof_i_lr);
    var RoRoI vl_good_values := { {1,0,1},{1,2,3,4},{1,2,3,4,5},{-5,4,3,2,1}, {0,0,0} } 
    var RoRoI vl_wrong_values := { {}, {2},{1,1},{1,2},{1,3},{2,4},{-1,4},{2,3}, {1,2,3,4,1000,1001}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_lr,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_p() runs on MC {
    log(tspt_recof_i_p);
    var RoRoI vl_good_values := { {1,2,3,10},{1,3,2,10},{2,1,3,10},{2,3,1,10},{3,1,2,10},{3,2,1,10} }
    var RoRoI vl_wrong_values := { {}, {2},{1,1},{1,2},{1,3},{2,4},{-1,4},{2,3},{11,5,-3},{1,2,4},{1,2,3,11}, {4,2,3,10},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_p,vl_good_values,vl_wrong_values);
  }    

  //====recordof templates modified from cfg file=====

  testcase tc_recordof_i_mod4v0() runs on MC {
    log(tspt_recof_i_mod4v0);
    var RoI vl_long :={}; //to stress test
    for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i }
    var RoRoI vl_good_values := { {} }
    var RoRoI vl_wrong_values := { {1},{2},{1,2,3},{1,2,3,4,1000}, vl_long } 
    f_checkMatchingValues_roi(tspt_recof_i_mod4v0,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4v1() runs on MC {
    log(tspt_recof_i_mod4v1);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1} };
    var RoRoI vl_wrong_values := { {},{2},{1,2},{1,2,3},{1,2,3,4,1000} }   //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_mod4v1,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4v2() runs on MC {
    log(tspt_recof_i_mod4v2);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,2} };
    var RoRoI vl_wrong_values := { {},{1},{2},{2,3},{1,2,3},{1,2,3,4,1000} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_mod4v2,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4v3() runs on MC {
    log(tspt_recof_i_mod4v3);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,2,3} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_mod4v3,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4v3a() runs on MC {
    log(tspt_recof_i_mod4v3a);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,1,3}, {1,2,3}, {1,3,3}, {1,4,3}, {1,9999,3} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_mod4v3a,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4v3q() runs on MC {
    log(tspt_recof_i_mod4v3q);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,1,3}, {1,2,3}, {1,3,3}, {1,4,3}, {1,9999,3} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_mod4v3q,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4vl3() runs on MC {
    log(tspt_recof_i_mod4vl3);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,2,3}, {2,2,3}, {1,2,4}, {2,2,4} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,5},{1,2,3,4,1000} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_mod4vl3,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4vl() runs on MC {
    log(tspt_recof_i_mod4vl);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,2,3},  {2,2,4} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000}, {2,2,3}, {1,2,4} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_mod4vl,vl_good_values,vl_wrong_values);
  }  

  testcase tc_recordof_i_mod4v10() runs on MC {
    log(tspt_recof_i_mod4v10);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := { {1,2,3,4,5,6,7,8,9,10} };
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11}} //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_mod4v10,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4o() runs on MC {
    log(tspt_recof_i_mod4o);
    //var RoI vl_long :={}; //to stress test
    //for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= i };
    var RoRoI vl_good_values := {};
    var RoRoI vl_wrong_values := { {2},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } //, vl_long };
    f_checkMatchingValues_roi(tspt_recof_i_mod4o,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4a() runs on MC {
    log(tspt_recof_i_mod4a);
    var RoRoI vl_good_values := {{}, {2},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    var RoRoI vl_wrong_values := {}; 
    f_checkMatchingValues_roi(tspt_recof_i_mod4a,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4q() runs on MC {
    log(tspt_recof_i_mod4q);
    var RoRoI vl_good_values := { {}, {2},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    var RoRoI vl_wrong_values := {}; 
    f_checkMatchingValues_roi(tspt_recof_i_mod4q,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4r() runs on MC {
    log(tspt_recof_i_mod4r);
    var RoRoI vl_good_values := { {1,1},{1,2},{1,3} } 
    var RoRoI vl_wrong_values := { {}, {2},{1,4},{-1,4},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_mod4r,vl_good_values,vl_wrong_values);
  }

  //fails
  testcase tc_recordof_i_cu_noconfig() runs on MC {
    var template RoI vlt := { permutation (1,2,3),10 }
    log("Before mod: ",vlt);   //Before mod: { permutation(1, 2, 3), 10 }
    vlt := { 1, complement(1,2,3),3,4 } ;
    log("after mod: ",vlt); //after mod:  { permutation(1, complement (1, 2, 3), 3), 4 } but it should be { 1, complement(1,2,3),3,4 } 
    var RoRoI vl_good_values := {{1,0,3,4},{1,4,3,4},{1,5,3,4},{1,-1,3,4}}
    var RoRoI vl_wrong_values := { {}, {2},{1,1,3,4},{1,2,3,4},{1,3,3,4},{1,2,3,4},{1,3},{3,1,1,4} } 
    f_checkMatchingValues_roi(vlt,vl_good_values,vl_wrong_values);
  }

  //fails
  testcase tc_recordof_i_mod4c_undefined() runs on MC {
    //original:
    log(tspt_recof_i_mod4cu); //expected: { 1, complement(1,2,3),3,4 } , got:  { permutation(1, complement (1, 2, 3), 3), 4 }
    var RoRoI vl_good_values :=   {{1,0,3,4},{1,4,3,4},{1,5,3,4},{1,-1,3,4}}
    var RoRoI vl_wrong_values :=  { {}, {2},{1,1,3,4},{1,2,3,4},{1,3,3,4},{1,2,3,4},{1,3},{3,1,1,4} } 
    f_checkMatchingValues_roi(tspt_recof_i_mod4cu,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4c() runs on MC {
    log(tspt_recof_i_mod4c);
    var RoRoI vl_good_values := {{1,0,1,1},{1,4,1,1},{1,5,1,1}}
    var RoRoI vl_wrong_values := { {}, {2},{1,1},{1,2},{1,3}, {2,4},{-1,4},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_mod4c,vl_good_values,vl_wrong_values);
  }  

  //3->3 elements
  testcase tc_recordof_i_mod4cm1() runs on MC {
    log(tspt_recof_i_mod4cm1);
    var RoRoI vl_good_values := {{1,0,1},{1,4,1},{1,5,1}}
    var RoRoI vl_wrong_values := { {}, {2},{1,1},{1,2},{1,3}, {2,4},{-1,4},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_mod4cm1,vl_good_values,vl_wrong_values);
  }
  //3->5 elements
  testcase tc_recordof_i_mod4cm2() runs on MC {
    log(tspt_recof_i_mod4cm2);
    var RoRoI vl_good_values := {{1,0,1,1,1},{1,4,1,1,1},{1,5,1,1,1}}
    var RoRoI vl_wrong_values := { {}, {2},{1,1},{1,2},{1,3}, {2,4},{-1,4},{2,3},{1,2,4},{1,2,3,10}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_mod4cm2,vl_good_values,vl_wrong_values);
  }
  testcase tc_recordof_i_mod4lv() runs on MC {
    log(tspt_recof_i_mod4lv);
    var RoRoI vl_good_values := { {0,1,0},{1,4,5},{1,5,-1},{1000,6000,700},{11,5,-3},{1,2,4},{2,3,4}} 
    var RoRoI vl_wrong_values := { {}, {2},{1,1},{1,2},{1,3},{2,4},{-1,4},{1,2,3,4,1000},{1,2,3,4,5,6,7,8,9,11}} 
    f_checkMatchingValues_roi(tspt_recof_i_mod4lv,vl_good_values,vl_wrong_values);
  }  

  //length range
  testcase tc_recordof_i_mod4lr() runs on MC {
    log(tspt_recof_i_mod4lr);
    var RoRoI vl_good_values := { {1,0,1},{1,2,3,4},{1,2,3,4,5},{-5,4,3,2,1}, {0,0,0} } 
    var RoRoI vl_wrong_values := { {}, {2},{1,1},{1,2},{1,3},{2,4},{-1,4},{2,3}, {1,2,3,4,1000,1001}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_mod4lr,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4p() runs on MC {
    log(tspt_recof_i_mod4p);
    var RoRoI vl_good_values := { {1,2,3,10},{1,3,2,10},{2,1,3,10},{2,3,1,10},{3,1,2,10},{3,2,1,10} }
    var RoRoI vl_wrong_values := { {}, {2},{1,1},{1,2},{1,3},{2,4},{-1,4},{2,3},{11,5,-3},{1,2,4},{1,2,3,11}, {4,2,3,10},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_mod4p,vl_good_values,vl_wrong_values);
  } 

  testcase tc_recordof_i_mod4rifp() runs on MC {
    log(tspt_recof_i_mod4rifp);
    var RoRoI vl_good_values := { {1,1},{1,2},{1,3} }
    var RoRoI vl_wrong_values := { {}, {2},{1,4},{-1,4},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_mod4rifp,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_i_mod4vlifp() runs on MC {
    log(tspt_recof_i_mod4vlifp);
    var RoRoI vl_good_values := { {1,2,3},{2,2,4} }
    var RoRoI vl_wrong_values := { {}, {2},{1,4},{-1,4},{2,3},{1,2,4},{1,2,3,4,1000}, {1,2,3,4,5,6,7,8,9,11},{1,2,3,4,5,6,7,8,9,10} } 
    f_checkMatchingValues_roi(tspt_recof_i_mod4vlifp,vl_good_values,vl_wrong_values);
  }
  
  //record of floats
  testcase tc_recordof_f_ModulePar() runs on MC {

    log(tspt_recof_f_v0);
    if( log2str(tspt_recof_f_v0) != "{ }") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_v1);
    if( log2str(tspt_recof_f_v1) != "{ 1.000000 }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_v2);
    if( log2str(tspt_recof_f_v2) != "{ 1.000000, 2.000000 }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_v3);
    if( log2str(tspt_recof_f_v3) != "{ 1.000000, 2.000000, 3.000000 }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_v3a);
    if( log2str(tspt_recof_f_v3a) != "{ 1.000000, *, 3.000000 }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_v3q);
    if( log2str(tspt_recof_f_v3q) != "{ 1.000000, ?, 3.000000 }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_vl3);
    if( log2str(tspt_recof_f_vl3) != "{ (1.000000, 2.000000), 2.000000, (3.000000, 4.000000) }") {setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_v10);
    if( log2str(tspt_recof_f_v10) != "{ 1.000000, 2.000000, 3.000000, 4.000000, 5.000000, 6.000000, 7.000000, 8.000000, 9.000000, 10.000000 }") {setverdict(fail) };
    log(tspt_recof_f_o);
    if( log2str(tspt_recof_f_o) != "omit") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_a);
    if( log2str(tspt_recof_f_a) != "*") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_q);
    if( log2str(tspt_recof_f_q) != "?") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_r);
    if( log2str(tspt_recof_f_r) != "{ 1.000000, (1.000000 .. 3.000000) }") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_c);
    if( log2str(tspt_recof_f_c) != "{ 1.000000, complement (1.000000, 2.000000, 3.000000) }") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_lv);
    if( log2str(tspt_recof_f_lv) != "? length (3)") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_lr);
    if( log2str(tspt_recof_f_lr) != "? length (3 .. 5)") { setverdict(fail) } else { setverdict(pass) };
    log(tspt_recof_f_p);
    if( log2str(tspt_recof_f_p) != "{ permutation(1.000000, 2.000000, 3.000000), 10.000000 }") { setverdict(fail) } else { setverdict(pass) };
  }

  testcase tc_recordof_f_v0() runs on MC {
    log(tspt_recof_f_v0);
    var RoF vl_long :={}; //to stress test
    for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= int2float(i) }
    var RoRoF vl_good_values := { {} }
    var RoRoF vl_wrong_values := { {1.0},{2.0},{1.0,2.0,3.0},{1.0,2.0,3.0,4.0,1.0000}, vl_long } 
    f_checkMatchingValues_rof(tspt_recof_f_v0,vl_good_values,vl_wrong_values);
  }  

  testcase tc_recordof_f_v1() runs on MC {
    log(tspt_recof_f_v1);
    var RoF vl_long :={}; //to stress test
    for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= int2float(i) }
    var RoRoF vl_good_values := { {1.0} }
    var RoRoF vl_wrong_values := { {},{2.0},{1.0,2.0,3.0},{1.0,2.0,3.0,4.0,1.0000}, vl_long } 
    f_checkMatchingValues_rof(tspt_recof_f_v1,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_f_v2() runs on MC {
    log(tspt_recof_f_v2);
    var RoF vl_long :={}; //to stress test
    for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= int2float(i) }
    var RoRoF vl_good_values := { {1.0,2.0} }
    var RoRoF vl_wrong_values := { {},{2.0},{2.0,1.0},{1.0,2.0,3.0},{1.0,2.0,3.0,4.0,1.0000}, vl_long } 
    f_checkMatchingValues_rof(tspt_recof_f_v2,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_f_v3() runs on MC {
    log(tspt_recof_f_v3);
    var RoF vl_long :={}; //to stress test
    for( var integer i:=0;i<1000;i:=i+1) { vl_long[i]:= int2float(i) }
    var RoRoF vl_good_values := { {1.0,2.0,3.0} }
    var RoRoF vl_wrong_values := { {},{2.0},{2.0,1.0},{1.0,2.0}, {1.0,3.0,2.0}, {1.0,2.0,4.0},{1.0,2.0,3.0, -4.9},{1.0,2.0,3.0,4.0,1.0000}, vl_long } 
    f_checkMatchingValues_rof(tspt_recof_f_v3,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_f_v3a() runs on MC {
    log(tspt_recof_f_v3a);
    var RoRoF vl_good_values := { {1.0,2.0,3.0}, {1.0,29.9,3.0}, {1.0,-29.9,3.0} }
    var RoRoF vl_wrong_values := { {},{2.0},{2.0,1.0},{1.0,2.0}, {1.0,3.0,2.0}, {1.0,2.0,4.0},{1.0,2.0,3.0, -4.9},{1.0,2.0,3.0,4.0,1.0000}} 
    f_checkMatchingValues_rof(tspt_recof_f_v3a,vl_good_values,vl_wrong_values);
  }

  testcase tc_recordof_f_v3q() runs on MC {
    log(tspt_recof_f_v3q);
    var RoRoF vl_good_values := { {1.0,2.0,3.0}, {1.0,29.9,3.0}, {1.0,-29.9,3.0} }
    var RoRoF vl_wrong_values := { {},{2.0},{2.0,1.0},{1.0,2.0}, {1.0,3.0,2.0}, {1.0,2.0,4.0},{1.0,2.0,3.0, -4.9},{1.0,2.0,3.0,4.0,1.0000}} 
    f_checkMatchingValues_rof(tspt_recof_f_v3q,vl_good_values,vl_wrong_values);
  }
  testcase tc_recordof_f_vl3() runs on MC {
    log(tspt_recof_f_vl3);
    var RoRoF vl_good_values := { {1.0,2.0,3.0}, {2.0,2.0,3.0}, {1.0,2.0,4.0}, {2.0,2.0,4.0} }
    var RoRoF vl_wrong_values := { {},{2.0},{2.0,1.0},{1.0,2.0}, {1.0,3.0,2.0}, {1.0,2.0,5.0},{1.0,2.0,3.0, -4.9},{1.0,2.0,3.0,4.0,1.0000}} 
    f_checkMatchingValues_rof(tspt_recof_f_vl3,vl_good_values,vl_wrong_values);
  }  

  testcase tc_recordof_f_vl() runs on MC {
    log(tspt_recof_f_vl);
    var RoRoF vl_good_values := { {1.0,2.0,3.0}, {2.0,2.0,4.0} }
    var RoRoF vl_wrong_values := { {},{2.0},{2.0,1.0},{1.0,2.0},{1.0,2.0,4.0}, {2.0,3.0,4.0},{1.0,3.0,2.0}, {1.0,2.0,4.0},{1.0,2.0,3.0, -4.9},{1.0,2.0,3.0,4.0,1.0000}} 
    f_checkMatchingValues_rof(tspt_recof_f_vl,vl_good_values,vl_wrong_values);
  }  
  testcase tc_recordof_f_v10() runs on MC {
    log(tspt_recof_f_v10);
    var RoRoF vl_good_values := { {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0} }
    var RoRoF vl_wrong_values := { {},{2.0},{2.0,1.0},{1.0,2.0},{1.0,2.0,4.0}, {2.0,3.0,4.0},{1.0,3.0,2.0}, {1.0,2.0,4.0},{1.0,2.0,3.0, -4.9},{1.0,2.0,3.0,4.0,1.0000}} 
    f_checkMatchingValues_rof(tspt_recof_f_v10,vl_good_values,vl_wrong_values);
  }
  //TODO: record of charstring, bitstring etc + rec of type

//=========================================================================
// Control
//=========================================================================

control {
   log("***record of tests****");
  execute(tc_recordof_i_NoModulePar());
  execute(tc_recordof_i_ModulePar());
  execute(tc_recordof_i_v0());
  execute(tc_recordof_i_v1());
  execute(tc_recordof_i_v2());
  execute(tc_recordof_i_v3());
  execute(tc_recordof_i_v3a());
  execute(tc_recordof_i_v3q());
  execute(tc_recordof_i_vl3());
  execute(tc_recordof_i_vl());
  execute(tc_recordof_i_v10());
  execute(tc_recordof_i_o());
  execute(tc_recordof_i_a());
  execute(tc_recordof_i_q());
  execute(tc_recordof_i_r());
  execute(tc_recordof_i_c());
  execute(tc_recordof_i_lv());
  execute(tc_recordof_i_lr());
  execute(tc_recordof_i_p());

  execute(tc_recordof_i_mod4v0());
  execute(tc_recordof_i_mod4v1());
  execute(tc_recordof_i_mod4v2());
  execute(tc_recordof_i_mod4v3());
  execute(tc_recordof_i_mod4v3a());
  execute(tc_recordof_i_mod4v3q());
  execute(tc_recordof_i_mod4vl3());
  execute(tc_recordof_i_mod4vl());
  execute(tc_recordof_i_mod4v10());
  execute(tc_recordof_i_mod4o());
  execute(tc_recordof_i_mod4a());
  execute(tc_recordof_i_mod4q());
  execute(tc_recordof_i_mod4r());
  //execute(tc_recordof_i_cu_noconfig()); //fails, TR: HS10984
  //execute(tc_recordof_i_mod4c_undefined()); //fails, TR: HS10984
  execute(tc_recordof_i_mod4c());
  execute(tc_recordof_i_mod4cm1());
  execute(tc_recordof_i_mod4cm2());
  execute(tc_recordof_i_mod4lv());
  execute(tc_recordof_i_mod4lr());
  execute(tc_recordof_i_mod4p());
  execute(tc_recordof_i_mod4rifp());
  execute(tc_recordof_i_mod4vlifp());

  execute(tc_recordof_f_ModulePar());
  execute(tc_recordof_f_v0());
  execute(tc_recordof_f_v1());
  execute(tc_recordof_f_v2());
  execute(tc_recordof_f_v3());
  execute(tc_recordof_f_v3a());
  execute(tc_recordof_f_v3q());
  execute(tc_recordof_f_vl3());
  execute(tc_recordof_f_vl());
  execute(tc_recordof_f_v10()); 
}
}  // end of module