Sync with 5.1.0

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

/******************************************************************************
 * Copyright (c) 2000-2014 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: ethbaat
//DATE: 2013-12-11
//VERSION: 1.0
*/
module integer_test
{

//=========================================================================
// Import Part
//=========================================================================

import from types all;
import from functions all;

//=========================================================================
// Module Parameters
//=========================================================================
modulepar {
  //integer
  integer tsp_j := 0;
  template integer tspt_i_v := 9;
  template integer tspt_i_o := omit;
  template integer tspt_i_a := *;
  template integer tspt_i_q :=  ?;
  template integer tspt_i_vl1 := (1);
  template integer tspt_i_vl2 := (0,1);
  template integer tspt_i_vl3 := (0,1,-1);
  template integer tspt_i_c := complement(0,1,-1);
  template integer tspt_i_r := (1..4); //range

  //templates overwritten:
  template integer tspt_i1 := *; //overwritten by cfg for value 9
  template integer tspt_i2 := 4; //overwritten by cfg for omit
  template integer tspt_i3 := 5; //overwritten by cfg for *
  template integer tspt_i4 := *; //overwritten by cfg for ?
  template integer tspt_i5 := ?; //overwritten by cfg for value list (0,1,-1)
  template integer tspt_i6 := *; //overwritten by cfg for 9 ifpresent
  template integer tspt_i7 := *; //overwritten by cfg for omit
  template integer tspt_i8 := *; //overwritten by cfg for *
  template integer tspt_i9 := *; //overwritten by cfg for ?
  template integer tspt_i10 := *; //overwritten by cfg for value list (0,1,-1)
  template integer tspt_i11 := *; //overwritten by cfg for complement
}

//=========================================================================
// 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
//=========================================================================

  template REC t_rec(template integer pl_i, template float pl_f, template charstring pl_cs, template bitstring pl_bs) := {
    i:= pl_i,
    f:= pl_f,
    cs:=pl_cs,
    bs:=pl_bs
  }

  template integer t_i_v := 9;
  template integer t_i_o := omit;
  template integer t_i_a := *;
  template integer t_i_q :=  ?;
  template integer t_i_vl := (0,1,-1)
  template integer t_i_c := complement(0,1,-1);
//=========================================================================
// Functions
//=========================================================================

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

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

  //Goal: simple integer template is  accepted as modulepar and it can be used
  testcase tc_integer_NoModulePar() runs on MC {
    if( log2str(t_i_v) != "9") { setverdict(fail)} else { setverdict(pass) }
    if( log2str(t_i_o) != "omit") { setverdict(fail)};
    if( log2str(t_i_a) != "*") { setverdict(fail)};
    if( log2str(t_i_q) != "?") { setverdict(fail)};
    //log(t_i_vl);
    if( log2str(t_i_vl) != "(0, 1, -1)") { setverdict(fail) };
    if( log2str(t_i_c) != "complement (0, 1, -1)") { setverdict(fail) };
  }

  testcase tc_integer_NoModulePar_Embedded() runs on MC {
    log(t_rec(t_i_v,omit,omit,omit));
    if( log2str(t_rec(t_i_v,omit,omit,omit)) != "{ i := 9, f := omit, cs := omit, bs := omit }") { setverdict(fail)} else { setverdict(pass) }
    log(t_rec(t_i_o,omit,omit,omit));
    if( log2str(t_rec(t_i_o,omit,omit,omit)) != "{ i := omit, f := omit, cs := omit, bs := omit }" ) { setverdict(fail)};
    log(t_rec(t_i_a,omit,omit,omit));
    if( log2str(t_rec(t_i_a,omit,omit,omit)) != "{ i := *, f := omit, cs := omit, bs := omit }" ) { setverdict(fail)};
    log(t_rec(t_i_q,omit,omit,omit));
    if( log2str(t_rec(t_i_q,omit,omit,omit)) != "{ i := ?, f := omit, cs := omit, bs := omit }") { setverdict(fail)};
    log( t_rec(t_i_vl,omit,omit,omit));
    if( log2str(t_rec(t_i_vl,omit,omit,omit)) !=  "{ i := (0, 1, -1), f := omit, cs := omit, bs := omit }") { setverdict(fail) };
    log( t_rec(t_i_c,omit,omit,omit));
    if( log2str(t_rec(t_i_c,omit,omit,omit)) != "{ i := complement (0, 1, -1), f := omit, cs := omit, bs := omit }") { setverdict(fail) };
  }

  testcase tc_integer_Embedded() runs on MC {
    log(t_rec(tspt_i_v,omit,omit,omit));
    if( log2str(t_rec(tspt_i_v,omit,omit,omit)) != "{ i := 9, f := omit, cs := omit, bs := omit }") { setverdict(fail)} else { setverdict(pass) }
    log(t_rec(tspt_i_o,omit,omit,omit));
    if( log2str(t_rec(tspt_i_o,omit,omit,omit)) != "{ i := omit, f := omit, cs := omit, bs := omit }" ) { setverdict(fail)};
    log(t_rec(tspt_i_a,omit,omit,omit));
    if( log2str(t_rec(tspt_i_a,omit,omit,omit)) != "{ i := *, f := omit, cs := omit, bs := omit }" ) { setverdict(fail)};
    log(t_rec(tspt_i_q,omit,omit,omit));
    if( log2str(t_rec(tspt_i_q,omit,omit,omit)) != "{ i := ?, f := omit, cs := omit, bs := omit }") { setverdict(fail)};
    log( t_rec(tspt_i_vl1,omit,omit,omit));
    if( log2str(t_rec(tspt_i_vl1,omit,omit,omit)) !=  "{ i := 1, f := omit, cs := omit, bs := omit }") { setverdict(fail) };
    log( t_rec(tspt_i_vl2,omit,omit,omit));
    if( log2str(t_rec(tspt_i_vl2,omit,omit,omit)) !=  "{ i := (0, 1), f := omit, cs := omit, bs := omit }") { setverdict(fail) };
    log( t_rec(tspt_i_vl3,omit,omit,omit));
    if( log2str(t_rec(tspt_i_vl3,omit,omit,omit)) !=  "{ i := (0, 1, -1), f := omit, cs := omit, bs := omit }") { setverdict(fail) };
    log( t_rec(tspt_i_c,omit,omit,omit));
    if( log2str(t_rec(tspt_i_c,omit,omit,omit)) != "{ i := complement (0, 1, -1), f := omit, cs := omit, bs := omit }") { setverdict(fail) };
  }

  testcase tc_integer_Embedded_value() runs on MC {
    template REC vlt:=t_rec(tspt_i_v,omit,omit,omit);
    var RoREC vl_good_values :=  {{ 9,omit,omit,omit}};
    var RoREC vl_wrong_values := { { 10,omit,omit,omit}, { 9,1.0,omit,omit},{ 9,1.0,"lambada",'01'B}, { 10000,1.0,"lambada",'01'B} };
    f_checkMatchingValues_rec( vlt, vl_good_values, vl_wrong_values );
  }

  testcase tc_integer_Embedded_complement() runs on MC {
    template REC vlt:=t_rec(tspt_i_c,omit,omit,omit);
    var RoREC vl_good_values :=  { {2,omit,omit,omit},{3,omit,omit,omit},{4,omit,omit,omit},{-2,omit,omit,omit}};
    var RoREC vl_wrong_values := { {1,omit,omit,omit},{-1,omit,omit,omit},{0,omit,omit,omit},{ 9,1.0,omit,omit},{ 9,1.0,"lambada",'01'B}, { 10000,1.0,"lambada",'01'B} };
    f_checkMatchingValues_rec( vlt, vl_good_values, vl_wrong_values );
  }

  testcase tc_integer_Embedded_range() runs on MC {
    template REC vlt:=t_rec(tspt_i_r,omit,omit,omit);
    var RoREC vl_good_values :=  {{1,omit,omit,omit},{2,omit,omit,omit},{3,omit,omit,omit},{4,omit,omit,omit}};
    var RoREC vl_wrong_values := { {-1,omit,omit,omit},{5,omit,omit,omit},{9,omit,omit,omit},{ 10,omit,omit,omit}, { 9,1.0,omit,omit},{ 9,1.0,"lambada",'01'B}, { 10000,1.0,"lambada",'01'B} };
    f_checkMatchingValues_rec( vlt, vl_good_values, vl_wrong_values );
  }

  //value
  testcase tc_integer_value() runs on MC {
    log( tspt_i_v );
    if( log2str(tspt_i_v) != "9" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoI vl_good_values := {9}
    var RoI vl_wrong_values := {-1000000, 0, -1,2,20001, 4294967296, 4294967296+1}
    f_checkMatchingValues_int( tspt_i_v, vl_good_values, vl_wrong_values );
  }

  //omit
  testcase tc_integer_omit() runs on MC {
    log( tspt_i_o );
    if( log2str(tspt_i_o) != "omit" ) { setverdict(fail) } else { setverdict(pass) }  
    var RoI vl_good_values := {}
    var RoI vl_wrong_values := { -100000, -1, 0,1,9, 4294967296, 4294967296+1} 
    f_checkMatchingValues_int( tspt_i_o, vl_good_values, vl_wrong_values );
  }

  //asterix
  testcase tc_integer_a() runs on MC {
    log( tspt_i_a );
    if( log2str(tspt_i_a) != "*" ) { setverdict(fail) } else { setverdict(pass) } 
    var RoI vl_good_values := {-100000, -1, 0,1,9, 4294967296, 4294967296+1}
    var RoI vl_wrong_values := {} 
    f_checkMatchingValues_int( tspt_i_a, vl_good_values, vl_wrong_values );
  }  

  testcase tc_integer_q() runs on MC {
    log( tspt_i_q );
    if( log2str(tspt_i_q) != "?" ) { setverdict(fail) } else { setverdict(pass) }
    var RoI vl_good_values := {-100000, -1, 0,1, 4294967296, 4294967296+1}
    var RoI vl_wrong_values := {} 
    f_checkMatchingValues_int( tspt_i_q, vl_good_values, vl_wrong_values );
  }
  //Goal: to test if integer template is modified from cfg file:
  //value list
  testcase tc_integer_vl() runs on MC {
    log( tspt_i_vl3 );
    if( log2str(tspt_i_vl3) != "(0, 1, -1)" ) { setverdict(fail) } else { setverdict(pass) }
    var RoI vl_good_values := {-1,0,1}
    var RoI vl_wrong_values := {-1000000,2,9,20001}
    f_checkMatchingValues_int(tspt_i_vl3, vl_good_values,vl_wrong_values);
  }

  //goal: to test if template modulepar can be a right value
  testcase tc_integer_vl_right_value() runs on MC {
    var template integer vlt := tspt_i_vl3;
    log( tspt_i_vl3 );    
    if( log2str(vlt) != "(0, 1, -1)" ) { setverdict(fail) } else { setverdict(pass) }
    var RoI vl_good_values := {-1,0,1}
    var RoI vl_wrong_values := {-1000000,2,20001}
    f_checkMatchingValues_int(vlt, vl_good_values,vl_wrong_values);
  }  

  //integer modulepar templates modified from cfg file:

  // for value
  testcase tc_integer_modified4v() runs on MC {
    log( tspt_i1 );
    if( log2str(tspt_i1) != "9" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoI vl_good_values := {9}
    var RoI vl_wrong_values := {-1000000, 0, -1,2,20001, 4294967296, 4294967296+1}
    f_checkMatchingValues_int( tspt_i1, vl_good_values, vl_wrong_values );
  }

  //for omit
  testcase tc_integer_modified4o() runs on MC {
    log( tspt_i2 );
    if( log2str(tspt_i2) != "omit" ) { setverdict(fail) } else { setverdict(pass) }  
    var RoI vl_good_values := {}
    var RoI vl_wrong_values := { -100000, -1, 0,1,9, 4294967296, 4294967296+1} 
    f_checkMatchingValues_int( tspt_i2, vl_good_values, vl_wrong_values );
  }

  //asterix
  testcase tc_integer_modified4a() runs on MC {
    log( tspt_i3 );
    if( log2str(tspt_i3) != "*" ) { setverdict(fail) } else { setverdict(pass) } 
    var RoI vl_good_values := {-100000, -1, 0,1,9, 4294967296, 4294967296+1}
    var RoI vl_wrong_values := {} 
    f_checkMatchingValues_int( tspt_i3, vl_good_values, vl_wrong_values );
  }  

  testcase tc_integer_modified4q() runs on MC {
    log( tspt_i4 );
    if( log2str(tspt_i4) != "?" ) { setverdict(fail) } else { setverdict(pass) }
    var RoI vl_good_values := {-100000, -1, 0,1,9, 4294967296, 4294967296+1}
    var RoI vl_wrong_values := {} 
    f_checkMatchingValues_int( tspt_i4, vl_good_values, vl_wrong_values );
  }

  //value list
  testcase tc_integer_modified4vl() runs on MC {
    log( tspt_i5 );
    if( log2str(tspt_i5) != "(0, 1, -1)" ) { setverdict(fail) } else { setverdict(pass) }
    var RoI vl_good_values := {-1,0,1}
    var RoI vl_wrong_values := {-1000000,2,20001}
    f_checkMatchingValues_int(tspt_i5, vl_good_values,vl_wrong_values);
  }

  // for value
  testcase tc_integer_modified4vifp() runs on MC {
    log( tspt_i6 );
    if( log2str(tspt_i6) != "9 ifpresent" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoI vl_good_values := {9}
    var RoI vl_wrong_values := {-1000000, 0, -1,2,20001, 4294967296, 4294967296+1}
    f_checkMatchingValues_int( tspt_i6, vl_good_values, vl_wrong_values );
  }
  //for omit
  testcase tc_integer_modified4oifp() runs on MC {
    log( tspt_i7 );
    if( log2str(tspt_i7) != "omit ifpresent" ) { setverdict(fail) } else { setverdict(pass) }  
    var RoI vl_good_values := {}
    var RoI vl_wrong_values := { -100000, -1, 0,1,9, 4294967296, 4294967296+1} 
    f_checkMatchingValues_int( tspt_i7, vl_good_values, vl_wrong_values );
  }

  //asterix
  testcase tc_integer_modified4aifp() runs on MC {
    log( tspt_i8 );
    if( log2str(tspt_i8) != "* ifpresent" ) { setverdict(fail) } else { setverdict(pass) } 
    var RoI vl_good_values := {-100000, -1, 0,1,9, 4294967296, 4294967296+1}
    var RoI vl_wrong_values := {} 
    f_checkMatchingValues_int( tspt_i8, vl_good_values, vl_wrong_values );
  }  

  testcase tc_integer_modified4qifp() runs on MC {
    log( tspt_i9 );
    if( log2str(tspt_i9) != "? ifpresent" ) { setverdict(fail) } else { setverdict(pass) }
    var RoI vl_good_values := {-100000, -1, 0,1,9, 4294967296, 4294967296+1}
    var RoI vl_wrong_values := {} 
    f_checkMatchingValues_int( tspt_i9, vl_good_values, vl_wrong_values );
  }

  //value list
  testcase tc_integer_modified4vlifp() runs on MC {
    log( tspt_i10 );
    if( log2str(tspt_i10) != "(0, 1, -1) ifpresent" ) { setverdict(fail) } else { setverdict(pass) }
    var RoI vl_good_values := {-1,0,1}
    var RoI vl_wrong_values := {-1000000,2,20001}
    f_checkMatchingValues_int(tspt_i10, vl_good_values,vl_wrong_values);
  }

  //complement
  testcase tc_integer_modified4c() runs on MC {
    log( tspt_i11);
    if( log2str(tspt_i11) != "complement (9)" ) { setverdict(fail) } else { setverdict(pass) }
    var RoI vl_good_values := {-100000, -1, 0,1, 4294967296, 4294967296+1}
    var RoI vl_wrong_values := {9} 
    f_checkMatchingValues_int( tspt_i11, vl_good_values, vl_wrong_values );
  }



//=========================================================================
// Control
//=========================================================================
control {
   log("****Integer tests****")
  execute(tc_integer_NoModulePar());
  execute(tc_integer_NoModulePar_Embedded()); //with template record containing template argument
  execute(tc_integer_Embedded());
  execute(tc_integer_Embedded_value());
  execute(tc_integer_Embedded_complement());
  execute(tc_integer_Embedded_range());
  execute(tc_integer_value());
  execute(tc_integer_omit());
  execute(tc_integer_a());
  execute(tc_integer_q());
  execute(tc_integer_vl());
  execute(tc_integer_vl_right_value());
  //integer templates modified from cfg file"
  execute(tc_integer_modified4v());
  execute(tc_integer_modified4o());
  execute(tc_integer_modified4a());
  execute(tc_integer_modified4q());
  execute(tc_integer_modified4vl());
  execute(tc_integer_modified4vifp());
  execute(tc_integer_modified4oifp());
  execute(tc_integer_modified4aifp());
  execute(tc_integer_modified4qifp());
  execute(tc_integer_modified4vlifp());
  execute(tc_integer_modified4c()); 
}

}  // end of module