/******************************************************************************
 * 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: 
//DATE: 
//VERSION: 
*/
module boolean_test
{

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

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

modulepar {
  template boolean tspt_b_t := true;
  template boolean tspt_b_f := false;
  template boolean tspt_b_o := omit;
  template boolean tspt_b_a := *;
  template boolean tspt_b_q := ? ;
  template boolean tspt_b_tifp := true ifpresent;
  template boolean tspt_b_fifp := false ifpresent;
  template boolean tspt_b_oifp := omit ifpresent;  // omit ifpresent is meaningless!!!! => Should be comp error!!! TODO: put into neg test!!!
  template boolean tspt_b_aifp := * ifpresent;  // ?????? only "? ispresent" acceptable 
  template boolean tspt_b_qifp := ? ifpresent;
  template boolean tspt_b_c := complement (true); //complemented list
  template boolean tspt_b_tl :=  (true,false); //template list
  //template boolean tspt_b_n := not(true);
 
  //boolean template modification tests:
  template boolean tspt_b_a1 := *; //modified for true
  template boolean tspt_b_a2 := *; //modified for false
  template boolean tspt_b_a3 := *; //modified for omit
  template boolean tspt_b_a4 := *; //modified for *
  template boolean tspt_b_a5 := ?; //modified for ?
  template boolean tspt_b_a6 := ?; //modified for true ifpresent
  template boolean tspt_b_a7 := true; //modified for false ifpresent
  template boolean tspt_b_a8 := false; //modified for * ifpresent
  template boolean tspt_b_a9 := false; //modified for * ifpresent
  template boolean tspt_b_a10:= false; //modified for * ifpresent
  template boolean tspt_b_a11:= false; //modified for complement(true)
  template boolean tspt_b_err:= *; //wrong mod in cfg file  
}

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

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

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

//=========================================================================
// Templates
//=========================================================================

  template boolean t_b_t := true;
  template boolean t_b_f := false;
  template boolean t_b_o := omit;
  template boolean t_b_a := *;
  template boolean t_b_q := ? ;
  template boolean t_b_tifp := true ifpresent;
  template boolean t_b_fifp := false ifpresent;
  template boolean t_b_oifp := omit ifpresent;  // omit ifpresent is meaningless!!!! => Should be comp error!!! TODO: put into neg test!!!
  template boolean t_b_aifp := * ifpresent;  // ?????? only "? ispresent" acceptable 
  template boolean t_b_qifp := ? ifpresent;
  template boolean t_b_c := complement(true);

  template REC_BOH t_rec_b(template boolean pl_b) := {
    b:= pl_b,
    o:= omit,
    h:= omit
  }
  
//=========================================================================
// Altsteps
//=========================================================================

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

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

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

  //not modulepar template - template string check
  testcase tc_boolean_NoModulePar() runs on MC {
    log( t_rec_b(t_b_t) );
    if( log2str( t_rec_b(t_b_t) )  != "{ b := true, o := omit, h := omit }" ) { setverdict(fail) } else {setverdict(pass) }
    if( log2str( t_rec_b(t_b_f) )  != "{ b := false, o := omit, h := omit }") { setverdict(fail) };
    if( log2str( t_rec_b(t_b_o) )  != "{ b := omit, o := omit, h := omit }" ) { setverdict(fail) };
    if( log2str( t_rec_b(t_b_a) )  != "{ b := *, o := omit, h := omit }" ) { setverdict(fail) };
    if( log2str( t_rec_b(t_b_q) )  != "{ b := ?, o := omit, h := omit }" ) { setverdict(fail) };
    if( log2str( t_rec_b(t_b_tifp) )  != "{ b := true ifpresent, o := omit, h := omit }" ) { setverdict(fail) };
    if( log2str( t_rec_b(t_b_fifp) )  != "{ b := false ifpresent, o := omit, h := omit }" ) { setverdict(fail) };
    if( log2str( t_rec_b(t_b_oifp) )  != "{ b := omit ifpresent, o := omit, h := omit }" ) { setverdict(fail) };
    if( log2str( t_rec_b(t_b_aifp) )  != "{ b := * ifpresent, o := omit, h := omit }" ) { setverdict(fail) };
    if( log2str( t_rec_b(t_b_qifp) )  != "{ b := ? ifpresent, o := omit, h := omit }" ) { setverdict(fail) };
    //log(t_rec_b(t_b_c));
    if( log2str( t_rec_b(t_b_c) )  != "{ b := complement (true), o := omit, h := omit }" ) { setverdict(fail) };
  }

  //modulepar template - template string check
  testcase tc_boolean_Embedded() runs on MC {
    log(tspt_b_t);
    //embedded in record:
    log( "template value:", t_rec_b(tspt_b_t) );
    if( log2str( t_rec_b(tspt_b_t) ) != "{ b := true, o := omit, h := omit }" ) { setverdict(fail) } else {setverdict(pass) }    
    log( "template value:", t_rec_b(tspt_b_f) );
    if( log2str( t_rec_b(tspt_b_f) )  != "{ b := false, o := omit, h := omit }") { setverdict(fail) };
    log( "template value:", t_rec_b(tspt_b_o) );
    if( log2str( t_rec_b(tspt_b_o) )  != "{ b := omit, o := omit, h := omit }" ) { setverdict(fail) };
    log( "template value:", t_rec_b(tspt_b_a) );
    if( log2str( t_rec_b(tspt_b_a) )  != "{ b := *, o := omit, h := omit }" ) { setverdict(fail) };
    log( "template value:", t_rec_b(tspt_b_q) );
    if( log2str( t_rec_b(tspt_b_q) )  != "{ b := ?, o := omit, h := omit }" ) { setverdict(fail) };
    log( "template value:", t_rec_b(tspt_b_tifp) );
    if( log2str( t_rec_b(tspt_b_tifp) )  != "{ b := true ifpresent, o := omit, h := omit }" ) { setverdict(fail) };
    log( "template value:", t_rec_b(tspt_b_fifp) );
    if( log2str( t_rec_b(tspt_b_fifp) )  != "{ b := false ifpresent, o := omit, h := omit }" ) { setverdict(fail) };
    log( "template value:", t_rec_b(tspt_b_aifp) );
    if( log2str( t_rec_b(tspt_b_aifp) )  != "{ b := * ifpresent, o := omit, h := omit }" ) { setverdict(fail) };
    log( "template value:", t_rec_b(tspt_b_qifp) );
    if( log2str( t_rec_b(tspt_b_qifp) )  != "{ b := ? ifpresent, o := omit, h := omit }" ) { setverdict(fail) };
    log( "template value:", t_rec_b(tspt_b_c) );
    if( log2str( t_rec_b(tspt_b_c) )  != "{ b := complement (true), o := omit, h := omit }" ) { setverdict(fail) };
  }

  //true
  testcase tc_boolean_t() runs on MC {
    log(tspt_b_t);
    if( log2str( tspt_b_t)  != "true" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true}
    var RoB vl_wrong_values := {false}
    f_checkMatchingValues_bool(tspt_b_t,vl_good_values,vl_wrong_values);
  }

  //false
  testcase tc_boolean_f() runs on MC {
    log(tspt_b_f);
    if( log2str( tspt_b_f)  != "false" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {false};
    var RoB vl_wrong_values := {true};
    f_checkMatchingValues_bool(tspt_b_f,vl_good_values,vl_wrong_values);    
    }

  //omit
  testcase tc_boolean_o() runs on MC {
    log(tspt_b_o);
    if( log2str( tspt_b_o)  != "omit" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {};
    var RoB vl_wrong_values := {true,false};
    f_checkMatchingValues_bool(tspt_b_o,vl_good_values,vl_wrong_values);
  }

  //asterix
  testcase tc_boolean_a() runs on MC {
    log(tspt_b_a);
    if( log2str( tspt_b_a)  != "*" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true,false};
    var RoB vl_wrong_values := {};
    f_checkMatchingValues_bool(tspt_b_a,vl_good_values,vl_wrong_values);
  }

  //question mark
  testcase tc_boolean_q() runs on MC {
    log(tspt_b_q);
    if( log2str( tspt_b_q)  != "?" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true,false};
    var RoB vl_wrong_values := {};//omit cannot be checked here
    f_checkMatchingValues_bool(tspt_b_q,vl_good_values,vl_wrong_values);
  }

  //true ifpresent
  testcase tc_boolean_tifp() runs on MC {
    log(tspt_b_tifp);
    if( log2str( tspt_b_tifp)  != "true ifpresent" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true}
    var RoB vl_wrong_values := {false}; //omit cannot be checked here
    f_checkMatchingValues_bool(tspt_b_tifp,vl_good_values,vl_wrong_values);
  }

  //false ifpresent
  testcase tc_boolean_fifp() runs on MC {
    log(tspt_b_fifp);
    if( log2str( tspt_b_fifp)  != "false ifpresent" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {false};
    var RoB vl_wrong_values := {true};
    f_checkMatchingValues_bool(tspt_b_fifp,vl_good_values,vl_wrong_values);
  }
  //* ifpresent
  testcase tc_boolean_aifp() runs on MC {
    log(tspt_b_aifp);
    if( log2str( tspt_b_aifp)  != "* ifpresent" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true,false}
    var RoB vl_wrong_values := {}; //omit cannot be checked here
    f_checkMatchingValues_bool(tspt_b_aifp,vl_good_values,vl_wrong_values);
  }

  //? ifpresent
  testcase tc_boolean_qifp() runs on MC {
    log(tspt_b_qifp);
    if( log2str( tspt_b_qifp)  != "? ifpresent" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true,false};
    var RoB vl_wrong_values := {};
    f_checkMatchingValues_bool(tspt_b_qifp,vl_good_values,vl_wrong_values);
  }

  testcase tc_boolean_c() runs on MC {
    log(tspt_b_c);
    if( log2str( tspt_b_c)  != "complement (true)" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {false};
    var RoB vl_wrong_values := {true};
    f_checkMatchingValues_bool(tspt_b_c,vl_good_values,vl_wrong_values);
  } 

  testcase tc_boolean_tl() runs on MC {
    log(tspt_b_tl);
    if( log2str( tspt_b_tl)  != "(true, false)" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true,false};
    var RoB vl_wrong_values := {};
    f_checkMatchingValues_bool(tspt_b_tl,vl_good_values,vl_wrong_values);
  } 

  //modulepar modified in cfg file
  testcase tc_boolean_modified4t() runs on MC {
    log(tspt_b_a1);
    if( log2str( tspt_b_a1)  != "true" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true}
    var RoB vl_wrong_values := {false}
    f_checkMatchingValues_bool(tspt_b_a1,vl_good_values,vl_wrong_values);
  }

  testcase tc_boolean_modified4f() runs on MC {
    log(tspt_b_a2);
    if( log2str( tspt_b_a2)  != "false" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {false};
    var RoB vl_wrong_values := {true};
    f_checkMatchingValues_bool(tspt_b_a2,vl_good_values,vl_wrong_values);
  }  

  testcase tc_boolean_modified4o() runs on MC {
    log(tspt_b_a3);
    if( log2str( tspt_b_a3)  != "omit" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {};
    var RoB vl_wrong_values := {true,false};
    f_checkMatchingValues_bool(tspt_b_a3,vl_good_values, vl_wrong_values);
  }

  testcase tc_boolean_modified4a() runs on MC {
    log(tspt_b_a4);
    if( log2str( tspt_b_a4)  != "*" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true,false};
    var RoB vl_wrong_values := {};
    f_checkMatchingValues_bool(tspt_b_a4,vl_good_values,vl_wrong_values);
  }

  testcase tc_boolean_modified4q() runs on MC {
    log(tspt_b_a5);
    if( log2str( tspt_b_a5)  != "?" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true,false};
    var RoB vl_wrong_values := {};
    f_checkMatchingValues_bool(tspt_b_a5,vl_good_values,vl_wrong_values);
  }

  testcase tc_boolean_modified4tifp() runs on MC {
    log(tspt_b_a6);
    if( log2str( tspt_b_a6)  != "true ifpresent" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true};
    var RoB vl_wrong_values := {false};
    f_checkMatchingValues_bool(tspt_b_a6,vl_good_values,vl_wrong_values);
  }

  testcase tc_boolean_modified4fifp() runs on MC {
    log(tspt_b_a7);
    if( log2str( tspt_b_a7)  != "false ifpresent" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {false};
    var RoB vl_wrong_values := {true};
    f_checkMatchingValues_bool(tspt_b_a7,vl_good_values,vl_wrong_values);
  }

  testcase tc_boolean_modified4aifp() runs on MC {
    log(tspt_b_a8);
    if( log2str( tspt_b_a8)  != "* ifpresent" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true,false};
    var RoB vl_wrong_values := {};
    f_checkMatchingValues_bool(tspt_b_a8,vl_good_values,vl_wrong_values);
  }

  testcase tc_boolean_modified4qifp() runs on MC {
    log(tspt_b_a9);
    if( log2str( tspt_b_a9)  != "? ifpresent" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true,false};
    var RoB vl_wrong_values := {};
    f_checkMatchingValues_bool(tspt_b_a9,vl_good_values,vl_wrong_values);
  }

  testcase tc_boolean_modified4tf() runs on MC {
    log(tspt_b_a10);
    if( log2str( tspt_b_a10)  != "(true, false)" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {true,false};
    var RoB vl_wrong_values := {};
    f_checkMatchingValues_bool(tspt_b_a10,vl_good_values,vl_wrong_values);
  }

  //modified for complement(true)
  testcase tc_boolean_modified4ct() runs on MC {
    log(tspt_b_a11);
    if( log2str( tspt_b_a11)  != "complement (true)" ) { setverdict(fail) } else {setverdict(pass) } 
    var RoB vl_good_values := {false};
    var RoB vl_wrong_values := {true};
    f_checkMatchingValues_bool(tspt_b_a11,vl_good_values,vl_wrong_values);
  }


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

control {
  log("****Boolean tests****")
  execute(tc_boolean_NoModulePar());
  execute(tc_boolean_Embedded());
  execute(tc_boolean_t());
  execute(tc_boolean_f());
  execute(tc_boolean_o());
  execute(tc_boolean_a());
  execute(tc_boolean_tifp());
  execute(tc_boolean_fifp());
  execute(tc_boolean_aifp());
  execute(tc_boolean_qifp());
  execute(tc_boolean_c());
  execute(tc_boolean_tl());
  //boolean template, modified from cfg file:
  execute(tc_boolean_modified4t());
  execute(tc_boolean_modified4f());
  execute(tc_boolean_modified4o());
  execute(tc_boolean_modified4a());
  execute(tc_boolean_modified4q());
  execute(tc_boolean_modified4tifp());
  execute(tc_boolean_modified4fifp());
  execute(tc_boolean_modified4aifp());
  execute(tc_boolean_modified4qifp());
  execute(tc_boolean_modified4tf());
  execute(tc_boolean_modified4ct());	  
}


}  // end of module