/******************************************************************************
 * 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 float_test
{

//=========================================================================
// Import Part
//=========================================================================
import from types all;
import from functions all;

//=========================================================================
// Module Parameters
//=========================================================================

modulepar {
  template float tspt_f_v := 9.0;
  template float tspt_f_o := omit;
  template float tspt_f_a := *;
  template float tspt_f_q :=  ?;
  template float tspt_f_vl1 := (0.0)
  template float tspt_f_vl2 := (0.0,1.2)
  template float tspt_f_vl3 := (0.0,1.2,-1.9)
  template float tspt_f_c1 := complement(0.0);
  template float tspt_f_c3 := complement(0.0,1.2,-1.9);
  template float tspt_f_r := (-1.9..3.1);

  template float tspt_f1 := *; //overwritten by cfg for value 9.0
  template float tspt_f2 := 4.0; //overwritten by cfg for omit
  template float tspt_f3 := 5.0; //overwritten by cfg for *
  template float tspt_f4 := *; //overwritten by cfg for ?
  template float tspt_f_mod4vl1 := ?; //overwritten by cfg for value list (0.0)
  template float tspt_f_mod4vl3 := ?; //overwritten by cfg for value list (0.0,1.2,-1.9)
  template float tspt_f6 := *; //overwritten by cfg for 9.0 ifpresent
  template float tspt_f7 := *; //overwritten by cfg for omit ifpresent
  template float tspt_f8 := *; //overwritten by cfg for * ifpresent
  template float tspt_f9 := 9.0; //overwritten by cfg for ? ifpresent
  template float tspt_f10 := *; //overwritten by cfg for value list (0.0,1.2,-1.9) ifpresent
  template float tspt_f11 := *; //overwritten by cfg for complement 
  template float tspt_f12 := *; //overwritten by cfg for complement(9.0) ifpresent
  template float tspt_f13 := *;
  template float tspt_f14 := *;
}

//=========================================================================
// Data Types
//=========================================================================

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

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

//=========================================================================
// Templates
//=========================================================================
  template float t_f_v := 9.0;
  template float t_f_o := omit;
  template float t_f_a := *;
  template float t_f_q :=  ?;
  template float t_f_vl := (0.0,1.2,-1.9)
  template float t_f_c := complement(0.0,1.2,-1.9);

//=========================================================================
// 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_float_NoModulePar() runs on MC {
    log(t_f_v);
    if( log2str(t_f_v) != "9.000000") { setverdict(fail)} else { setverdict(pass) }
    if( log2str(t_f_o) != "omit") { setverdict(fail)};
    if( log2str(t_f_a) != "*") { setverdict(fail)};
    if( log2str(t_f_q) != "?") { setverdict(fail)};
    if( log2str(t_f_vl) != "(0.000000, 1.200000, -1.900000)") { setverdict(fail) };
    if( log2str(t_f_c) != "complement (0.000000, 1.200000, -1.900000)") { setverdict(fail) };
  }

  testcase tc_float_ModulePar() runs on MC {
    if( log2str(tspt_f_v) != "9.000000") { setverdict(fail)} else { setverdict(pass) }
    if( log2str(tspt_f_o) != "omit") { setverdict(fail)};
    if( log2str(tspt_f_a) != "*") { setverdict(fail)};
    if( log2str(tspt_f_q) != "?") { setverdict(fail)};
    log(tspt_f_vl3);
    if( log2str(tspt_f_vl1) != "0.000000") { setverdict(fail) };
    if( log2str(tspt_f_vl2) != "(0.000000, 1.200000)") { setverdict(fail) };
    if( log2str(tspt_f_vl3) != "(0.000000, 1.200000, -1.900000)") { setverdict(fail) };
    if( log2str(tspt_f_c1) != "complement (0.000000)") { setverdict(fail) };
    if( log2str(tspt_f_c3) != "complement (0.000000, 1.200000, -1.900000)") { setverdict(fail) };
    //log(tspt_f_r);
    if( log2str(tspt_f_r) != "(-1.900000 .. 3.100000)") { setverdict(fail) };
  }

  testcase tc_float_Embedded() runs on MC {
    log(t_rec(1,tspt_f_v,omit,omit));
    if( log2str(t_rec(1,tspt_f_v,omit,omit)) != "{ i := 1, f := 9.000000, cs := omit, bs := omit }") { setverdict(fail)} else { setverdict(pass) }
    if( log2str(t_rec(1,tspt_f_o,omit,omit)) != "{ i := 1, f := omit, cs := omit, bs := omit }") { setverdict(fail)};
    if( log2str(t_rec(1,tspt_f_a,omit,omit)) != "{ i := 1, f := *, cs := omit, bs := omit }") { setverdict(fail)};
    if( log2str(t_rec(1,tspt_f_q,omit,omit)) !=  "{ i := 1, f := ?, cs := omit, bs := omit }"){ setverdict(fail)};
    //log(tspt_f_vl3);
    if( log2str(t_rec(1,tspt_f_vl1,omit,omit)) != "{ i := 1, f := 0.000000, cs := omit, bs := omit }") { setverdict(fail) };
    if( log2str(t_rec(1,tspt_f_vl2,omit,omit)) != "{ i := 1, f := (0.000000, 1.200000), cs := omit, bs := omit }") { setverdict(fail) };
    if( log2str(t_rec(1,tspt_f_vl3,omit,omit)) != "{ i := 1, f := (0.000000, 1.200000, -1.900000), cs := omit, bs := omit }") { setverdict(fail) };
    if( log2str(t_rec(1,tspt_f_c1,omit,omit)) != "{ i := 1, f := complement (0.000000), cs := omit, bs := omit }") { setverdict(fail) };
    if( log2str(t_rec(1,tspt_f_c3,omit,omit)) != "{ i := 1, f := complement (0.000000, 1.200000, -1.900000), cs := omit, bs := omit }") { setverdict(fail) };
    //log(tspt_f_r);
    if( log2str(t_rec(1,tspt_f_r,omit,omit)) != "{ i := 1, f := (-1.900000 .. 3.100000), cs := omit, bs := omit }" ) { setverdict(fail) };
  }

  //value
  testcase tc_float_value() runs on MC {
    log( tspt_f_v );
    if( log2str(tspt_f_v) != "9.000000" ) { setverdict(fail) } else { setverdict(pass) }
    var RoF vl_good_values := {9.0}
    var RoF vl_wrong_values := {-1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f_v, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_omit() runs on MC {
    log( tspt_f_o );
    if( log2str(tspt_f_o) != "omit" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {}
    var RoF vl_wrong_values := {9.0, -1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f_o, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_a() runs on MC {
    log( tspt_f_a );
    if( log2str(tspt_f_a) != "*" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {9.0, -1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    var RoF vl_wrong_values := {}
    f_checkMatchingValues_float( tspt_f_a, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_q() runs on MC {
    log( tspt_f_q );
    if( log2str(tspt_f_q) != "?")  { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {9.0, -1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    var RoF vl_wrong_values := {}
    f_checkMatchingValues_float( tspt_f_a, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_vl() runs on MC {
    log( tspt_f_vl3 );
    if( log2str(tspt_f_vl3) != "(0.000000, 1.200000, -1.900000)" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := { 0.0, 1.2, -1.9 }
    var RoF vl_wrong_values := {9.0, -1000000.0, 0.01, -1.91, 8.99999, 9.0,  9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f_vl3, vl_good_values, vl_wrong_values );
  }

  //range
  testcase tc_float_r() runs on MC {
    log( tspt_f_r );
    if( log2str(tspt_f_r) != "(-1.900000 .. 3.100000)" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := { -1.900000, -1.8999999, -1.0, 0.0, 1.2, -1.9, 3.1 }
    var RoF vl_wrong_values := {3.10001, 9.0, -1000000.0, -1.91, 8.99999, 9.0,  9.0001, -2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f_r, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_right_value() runs on MC {
    var template float vlt := tspt_f_vl3;
    log( vlt );
    if( log2str(vlt) != "(0.000000, 1.200000, -1.900000)" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := { 0.0, 1.2, -1.9 }
    var RoF vl_wrong_values := {9.0, -1000000.0, 0.01, -1.91, 8.99999, 9.0,  9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( vlt, vl_good_values, vl_wrong_values );
  }

  //
  //value
  testcase tc_float_modified4v() runs on MC {
    log( tspt_f1 );
    if( log2str(tspt_f1) != "9.000000" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {9.0}
    var RoF vl_wrong_values := {-1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f1, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4o() runs on MC {
    log( tspt_f2 );
    if( log2str(tspt_f2) != "omit" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {}
    var RoF vl_wrong_values := {9.0, -1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f2, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4a() runs on MC {
    log( tspt_f3 );
    if( log2str(tspt_f3) != "*" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {9.0, -1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    var RoF vl_wrong_values := {}
    f_checkMatchingValues_float( tspt_f3, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4q() runs on MC {
    log( tspt_f4 );
    if( log2str(tspt_f4) != "?")  { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {9.0, -1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    var RoF vl_wrong_values := {}
    f_checkMatchingValues_float( tspt_f4, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4vl1() runs on MC {
    log( tspt_f_mod4vl1 );
    if( log2str(tspt_f_mod4vl1) != "0.000000" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := { 0.0 }
    var RoF vl_wrong_values := {1.2, -1.9, 9.0, -1000000.0, 0.01, -1.91, 8.99999, 9.0,  9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f_mod4vl1, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4vl3() runs on MC {
    log( tspt_f_mod4vl3 );
    if( log2str(tspt_f_mod4vl3) != "(0.000000, 1.200000, -1.900000)" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := { 0.0, 1.2, -1.9 }
    var RoF vl_wrong_values := {9.0, -1000000.0, 0.01, -1.91, 8.99999, 9.0,  9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f_mod4vl3, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4c() runs on MC {
    var template float vlt := tspt_f11;
    log( vlt );
    if( log2str(vlt) != "complement (9.000000)" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values :=  { -1000000.0, 0.01, -1.91, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    var RoF vl_wrong_values := { 9.0 }
    f_checkMatchingValues_float( vlt, vl_good_values, vl_wrong_values );
  }

  // modified 4 range from cfg file
  testcase tc_float_modified4r() runs on MC {
    log( tspt_f13 );
    if( log2str(tspt_f13) != "(-1.900000 .. 3.100000)" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := { -1.900000, -1.8999999, -1.0, 0.0, 1.2, -1.9, 3.1 }
    var RoF vl_wrong_values := {3.10001, 9.0, -1000000.0, -1.91, 8.99999, 9.0,  9.0001, -2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f13, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4vl_right_value() runs on MC {
    var template float vlt := tspt_f_mod4vl3;
    log( vlt );
    if( log2str(vlt) != "(0.000000, 1.200000, -1.900000)" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := { 0.0, 1.2, -1.9 }
    var RoF vl_wrong_values := {9.0, -1000000.0, 0.01, -1.91, 8.99999, 9.0,  9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( vlt, vl_good_values, vl_wrong_values );
  }  

  //value
  testcase tc_float_modified4vifp() runs on MC {
    log( tspt_f6 );
    if( log2str(tspt_f6) != "9.000000 ifpresent" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {9.0}
    var RoF vl_wrong_values := {-1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f6, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4oifp() runs on MC {
    log( tspt_f7 );
    if( log2str(tspt_f7) != "omit ifpresent" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {}
    var RoF vl_wrong_values := {9.0, -1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f7, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4aifp() runs on MC {
    log( tspt_f8 );
    if( log2str(tspt_f8) != "* ifpresent" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {9.0, -1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    var RoF vl_wrong_values := {}
    f_checkMatchingValues_float( tspt_f8, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4qifp() runs on MC {
    log( tspt_f4 );
    if( log2str(tspt_f9) != "? ifpresent")  { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := {9.0, -1000000.0, 0.0, -1.0, 8.99999, 9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    var RoF vl_wrong_values := {}
    f_checkMatchingValues_float( tspt_f9, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4vlifp() runs on MC {
    log( tspt_f10 );
    if( log2str(tspt_f10) != "(0.000000, 1.200000, -1.900000) ifpresent" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := { 0.0, 1.2, -1.9 }
    var RoF vl_wrong_values := {9.0, -1000000.0, 0.01, -1.91, 8.99999, 9.0,  9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f10, vl_good_values, vl_wrong_values );
  }

  testcase tc_float_modified4cifp() runs on MC {
    var template float vlt := tspt_f12;
    log( vlt );
    if( log2str(vlt) != "complement (9.000000) ifpresent" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values :=  { -1000000.0, 0.01, -1.91, 8.99999,  9.0001, 2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    var RoF vl_wrong_values := { 9.0 }
    f_checkMatchingValues_float( vlt, vl_good_values, vl_wrong_values );
  }  

  // modified 4 range from cfg file
  testcase tc_float_modified4rifp() runs on MC {
    log( tspt_f14 );
    if( log2str(tspt_f14) != "(-1.900000 .. 3.100000) ifpresent" ) { setverdict(fail) } else { setverdict(pass) }      
    var RoF vl_good_values := { -1.900000, -1.8999999, -1.0, 0.0, 1.2, -1.9, 3.1 }
    var RoF vl_wrong_values := {3.10001, 9.0, -1000000.0, -1.91, 8.99999, 9.0,  9.0001, -2.0, 20001.0e9, 4294967296.0, 4294967296.0+1.0}
    f_checkMatchingValues_float( tspt_f14, vl_good_values, vl_wrong_values );
  }

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

control {  
  log("****float tests****");
  execute(tc_float_NoModulePar());
  execute(tc_float_ModulePar());
  execute(tc_float_Embedded());
  execute(tc_float_value());
  execute(tc_float_omit());
  execute(tc_float_a());
  execute(tc_float_q());
  execute(tc_float_vl());
  execute(tc_float_r());
  execute(tc_float_right_value());
  execute(tc_float_modified4v());
  execute(tc_float_modified4o());
  execute(tc_float_modified4a());
  execute(tc_float_modified4q());
  execute(tc_float_modified4vl1());
  execute(tc_float_modified4vl3());
  execute(tc_float_modified4c());
  execute(tc_float_modified4r());
  execute(tc_float_modified4vl_right_value());
  execute(tc_float_modified4vifp());
  execute(tc_float_modified4oifp());
  execute(tc_float_modified4aifp());
  execute(tc_float_modified4qifp());
  execute(tc_float_modified4vlifp());
  execute(tc_float_modified4cifp());
  execute(tc_float_modified4rifp()); 
}

}  // end of module